{"Package":"RemixAutoML","Title":"Remix Automated Machine Learning","Version":"0.4.9","Date":"2021-03-21","Authors@R":"\nc(person(given = \"Adrian\",\nfamily = \"Antico\",\nrole = c(\"aut\",\"cre\",\"ctb\"),\nemail = \"adrianantico@gmail.com\"),\nperson(\"Douglas\",\"Pestana\", role=\"ctb\"),\nperson(\"Jan\",\"Gorecki\", role=\"ctb\"),\nperson(\"Solomon\",\"Daner\", role=\"ctb\"))","Maintainer":"Adrian Antico ","Description":"R package for the automation of machine learning, forecasting, feature engineering, model evaluation, model interpretation, data generation, and recommenders. Built using data.table for all tabular data-related tasks.","License":"MPL-2.0 | file LICENSE","URL":"https://github.com/AdrianAntico/RemixAutoML","BugReports":"https://github.com/AdrianAntico/RemixAutoML/issues","Depends":"R (>= 3.5.0)","Imports":"arules, bit64, catboost, combinat, data.table, doParallel, e1071, fBasics,\nforeach, forecast, ggplot2, grid, h2o, itertools, lime, lubridate, methods,\nMLmetrics, monreg, nortest, parallel, pROC, RColorBrewer, recommenderlab,\nRfast, scatterplot3d, stats, stringr, timeDate, tsoutliers, wordcloud, xgboost","Suggests":"knitr, rmarkdown, sde, testthat, fpp, gridExtra","VignetteBuilder":"knitr","Additional_repositories":"\nhttps://github.com/catboost/catboost/tree/master/catboost/R-package","Contact":"Adrian Antico","Encoding":"UTF-8","Language":"en-US","LazyData":"true","NeedsCompilation":"no","Packaged":"2021-03-21 14:00:00 UTC","RoxygenNote":"7.1.1","SystemRequirements":"Java (>= 7.0)","Author":"Adrian Antico [aut, cre], Douglas Pestana [ctb]","ByteCompile":"TRUE","repoType":"github","tarballUrl":"https://api.github.com/repos/AdrianAntico/RemixAutoML/tarball/V0.4.9","jsonAuthors":[{"name":"Adrian Antico","email":"adrianantico@gmail.com","maintainer":true},{"name":"Douglas Pestana","email":null,"maintainer":false},{"name":"Jan Gorecki","email":null,"maintainer":false},{"name":"Solomon Daner","email":null,"maintainer":false}],"readme":"![Version: 0.4.8](https://img.shields.io/static/v1?label=Version&message=0.4.8&color=blue&?style=plastic)\n![Build: Passing](https://img.shields.io/static/v1?label=Build&message=passing&color=brightgreen)\n[![License: MPL 2.0](https://img.shields.io/badge/License-MPL%202.0-brightgreen.svg)](https://opensource.org/licenses/MPL-2.0)\n[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity)\n[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=default)](http://makeapullrequest.com)\n\n

\n\n## Background\n\n![RemixAutoML Reference Manual](https://github.com/AdrianAntico/RemixAutoML/tree/master/vignette)\n\n

Expand to view content

\n \n> Automated Machine Learning - In my view, AutoML should consist of functions to help make professional model development and operationalization more efficient. Most ML projects include at least one of the following: data wrangling, feature engineering, feature selection, model development, model evaluation, model interpretation, model optimization, and model operationalization. The functions in this package have been tested across a variety of industries and have consistently out-performd \"state of the art\" deep learning methods. I've watched coworkers spend months tuning and reconfiguring deep learning models just to have them lose to the functions here, in a matter of a day or two. My recommendation is to first utilize the functions here to establish a legit baseline performance. Then go and test out all the other methods. \n\n### Package Details\n> Supervised Learning - Currently, I'm utilizing CatBoost, XGBoost, and H2O for all of the automated Machine Learning related functions. GPU's can be utilized with CatBoost and XGBoost. Multi-armed bandit grid tuning is available for CatBoost and XGBoost models, which utilize the concept of randomized probability matching, which is detailed in the R pacakge \"bandit\". \n\n> Time series forecasting - Automated functions for single series, panel data, vector autoregression, intermittent demand, and cohort panel data. The panel data models utilize the machine learning algos from above and the feature engineering functions below. They are extremely feature rich and the combination of all possible feature settings is huge. The models for individual series are fully optimized versions from the R package \"forecast\". I utilize the multi-armed bandit grid tuning algo used in the supervised learning models and apply it to the SARIMA and NNETAR models from the forecast package. I also measure performance on hold out data (and training data, or a blend of the two).\n\n> Feature Engineering - Some of the feature engineering functions you can only find in this package, such as the AutoLagRollStats() and AutoLagRollStatsScoring() functions. You could classify the above functions into several buckets: categorical encoding, target encoding, and distributed lag. You can generate any number of discontiguous lags and rolling statistics (mean, sd, skewness, kurtosis, and every 5th percentile) along with time between records and their associated lags and rolling statistics for transactional level data. The function runs extremely fast if you don't utilize rolling stats other than mean (I still use data.table::frollapply() but the data.table guys admit it isn't optimized like the data.table::frollmean() function). Furthermore, you can generate all these features by any number of categorical variables and their interactions PLUS you can request those sets of features to be generated for differnt levels of time aggregations such as transactional, hourly, daily, weekly, monthly, quarterly, and yearly, all in one shot (that is, you do not have to run the function repeatedly to generate the features). Lastly, generating these kinds of time series features on the fly for only a subset of records in a data.table (typically for on-demand model scoring) is not an easy task to do correctly and quickly. However, I spent the time to make it run as fast as I could but I am open to suggestions for making it faster (that goes for any of the functions in RemixAutoML).\n\n> Data Management - Every function here is written with fully-optimized data.table code so they run blazingly fast and are as memory efficient as possible. The current set of machine learning algorithms were chosen for their ability to work with big data and their ability to outperform other models, as demonstrated across a variety of real world use cases. The focus of the package is quality, not quantity.\n\n> Documentation - Each exported function in the package has a help file and can be viewed in your RStudio session, e.g. ?RemixAutoML::ModelDataPrep. Many of them come with examples coded up in the help files (at the bottom) that you can run to get a feel for how to set the parameters. There's also a listing of exported functions by category with code examples at the bottom of this readme. You can also jump into the R folder here to dig into the source code. \n\n

\n\n## Installation\n\n

Expand to view content

\n\n#### 1. First, install R package dependencies: \nXGBoost runs significantly faster with GPU (it's already pretty fast on CPU) but it can be tricky to get installed. The blog below has been shown to be reliable for getting it done.\n [Install XGBoost on Windows for R with GPU Capability](https://medium.com/@karthikdulam/installing-xgboost-gpu-for-r-on-windows-10-7927a65c0ca8)\n \n```\n# Install Dependencies----\nif(!(\"remotes\" %in% rownames(installed.packages()))) install.packages(\"remotes\"); print(\"remotes\")\nif(!(\"arules\" %in% rownames(installed.packages()))) install.packages(\"arules\"); print(\"arules\")\nif(!(\"bit64\" %in% rownames(installed.packages()))) install.packages(\"bit64\"); print(\"bit64\")\nif(!(\"caTools\" %in% rownames(installed.packages()))) install.packages(\"caTools\"); print(\"caTools\")\nif(!(\"combinat\" %in% rownames(install.packages()))) install.packages(\"combinat\"); print(\"combinat\")\nif(!(\"data.table\" %in% rownames(installed.packages()))) install.packages(\"data.table\"); print(\"data.table\")\nif(!(\"doParallel\" %in% rownames(installed.packages()))) install.packages(\"doParallel\"); print(\"doParallel\")\nif(!(\"e1071\" %in% rownames(installed.packages()))) install.packages(\"e1071\"); print(\"e1071\")\nif(!(\"fBasics\" %in% rownames(installed.packages()))) install.packages(\"fBasics\"); print(\"fBasics\")\nif(!(\"foreach\" %in% rownames(installed.packages()))) install.packages(\"foreach\"); print(\"foreach\")\nif(!(\"forecast\" %in% rownames(installed.packages()))) install.packages(\"forecast\"); print(\"forecast\")\nif(!(\"fpp\" %in% rownames(installed.packages()))) install.packages(\"fpp\"); print(\"fpp\")\nif(!(\"ggplot2\" %in% rownames(installed.packages()))) install.packages(\"ggplot2\"); print(\"ggplot2\")\nif(!(\"gridExtra\" %in% rownames(installed.packages()))) install.packages(\"gridExtra\"); print(\"gridExtra\")\nif(!(\"here\" %in% rownames(installed.packages()))) install.packages(\"here\"); print(\"here\")\nif(!(\"itertools\" %in% rownames(installed.packages()))) install.packages(\"itertools\"); print(\"itertools\")\nif(!(\"lime\" %in% rownames(installed.packages()))) install.packages(\"lime\"); print(\"lime\")\nif(!(\"lubridate\" %in% rownames(installed.packages()))) install.packages(\"lubridate\"); print(\"lubridate\")\nif(!(\"Matrix\" %in% rownames(installed.packages()))) install.packages(\"Matrix\"); print(\"Matrix\")\nif(!(\"MLmetrics\" %in% rownames(installed.packages()))) install.packages(\"MLmetrics\"); print(\"MLmetrics\")\nif(!(\"monreg\" %in% rownames(installed.packages()))) install.packages(\"monreg\"); print(\"monreg\")\nif(!(\"nortest\" %in% rownames(installed.packages()))) install.packages(\"nortest\"); print(\"nortest\")\nif(!(\"RColorBrewer\" %in% rownames(installed.packages()))) install.packages(\"RColorBrewer\"); print(\"RColorBrewer\")\nif(!(\"recommenderlab\" %in% rownames(installed.packages()))) install.packages(\"recommenderlab\"); print(\"recommenderlab\")\nif(!(\"ROCR\" %in% rownames(installed.packages()))) install.packages(\"ROCR\"); print(\"ROCR\")\nif(!(\"pROC\" %in% rownames(installed.packages()))) install.packages(\"pROC\"); print(\"pROC\")\nif(!(\"Rfast\" %in% rownames(installed.packages()))) install.packages(\"Rfast\"); print(\"Rfast\")\nif(!(\"scatterplot3d\" %in% rownames(installed.packages()))) install.packages(\"scatterplot3d\"); print(\"scatterplot3d\")\nif(!(\"stringr\" %in% rownames(installed.packages()))) install.packages(\"stringr\"); print(\"stringr\")\nif(!(\"sde\" %in% rownames(installed.packages()))) install.packages(\"sde\"); print(\"sde\")\nif(!(\"timeDate\" %in% rownames(installed.packages()))) install.packages(\"timeDate\"); print(\"timeDate\")\nif(!(\"tsoutliers\" %in% rownames(installed.packages()))) install.packages(\"tsoutliers\"); print(\"tsoutliers\")\nif(!(\"wordcloud\" %in% rownames(installed.packages()))) install.packages(\"wordcloud\"); print(\"wordcloud\")\nif(!(\"xgboost\" %in% rownames(installed.packages()))) install.packages(\"xgboost\"); print(\"xgboost\")\nfor (pkg in c(\"RCurl\",\"jsonlite\")) if (! (pkg %in% rownames(installed.packages()))) { install.packages(pkg) }\ninstall.packages(\"h2o\", type = \"source\", repos = (c(\"http://h2o-release.s3.amazonaws.com/h2o/latest_stable_R\")))\nremotes::install_github('catboost/catboost', subdir = 'catboost/R-package')\nremotes::install_github('AdrianAntico/RemixAutoML', upgrade = FALSE, dependencies = FALSE, force = TRUE)\n```\n\n### Installation Troubleshooting \nThe most common issue some users are having when trying to install RemixAutoML is the installation of the catboost package dependency. Since catboost is not on CRAN it can only be installed through GitHub. To install catboost without error (and consequently install RemixAutoML without error), try running this line of code first, then restart your R session, then re-run the 2-step installation process above. (Reference):\nIf you're still having trouble submit an issue and I'll work with you to get it installed.\n\n```\n# Be sure to use the version you want versus what is listed below\noptions(devtools.install.args = c(\"--no-multiarch\", \"--no-test-load\"))\ninstall.packages(\"https://github.com/catboost/catboost/releases/download/v0.17.3/catboost-R-Windows-0.17.3.tgz\", repos = NULL, type = \"source\", INSTALL_opts = c(\"--no-multiarch\", \"--no-test-load\"))\n```\n \nIf you're having still having trouble installing see if the issue below helps out:\n\n![Issue #19](https://github.com/AdrianAntico/RemixAutoML/issues/19)\n\n

\n\n## Common Workflows\n\n

Expand to view content

\n\n### Supervised Learning\n#### An example workflow with function references\n

Expand to view content

\n \n1. Pull in data from your data warehouse (or from wherever) and clean it up\n2. Run all the applicable feature engineering functions, such as AutoLagRollStats(), AutoInteraction(), AutoDiffLagN(), AutoWord2VecModeler(), H2OAutoencoder(), CreateCalendarVariables(), CreateHolidayVariables(), etc.\n3. Partition your data with AutoDataPartition() You can create any number of data sets, supply stratification variables, and you can choose between 'random' splits, 'time' splits, and 'timeseries' splits. The distinction between 'time' and 'timeseries' splits is that 'time' should be used when you aren't directly working with panel data whereas the 'timeseries' split is for panel data (meaning that the number of records for each combination of group variables are identical). 'time' will first sort you data by the date column and then sort by stratification variables, if you provide some, but there is a risk that some group levels won't make it into all of your data sets.\n4. Run AutoCatBoostRegression() or AutoCatBoostClassifier() or AutoCatBoostMultiClass() with GPU if you have access to one\n5. Run AutoXGBoostRegression() or AutoXGBoostClassifier() or AutoXGBoostMultiClass() with GPU if you have access to one\n6. Run AutoH2oGBMRegression() or AutoH2oGBMClassifier() or AutoH2oGBMMultiClass() if you have the patience to wait for a CPU build.\n7. Run AutoH2oGLMRegression() or AutoH2oGLMClassifier() or AutoH2oGLMMultiClass() if you want to give a generalized linear model a shot.\n8. Run AutoH2oMLRegression() or AutoH2oMLClassifier() or AutoH2oMLMultiClass() to run H2O's AutoML function inside the RemixAutoML framework.\n9. Run AutoH2oDRFRegression() or AutoH2oDRFClassifier() or AutoH2oDRFMultiClass() H2O's Distributed Random Forest can take a really long time to build. H2O's documentation has a great explanation for the reason why it takes much longer compared to their GBM algo.\n10. Investigate model performance contained in the output object returned by those functions. You will be able to look at model calibration plots or box plots, ROC plots, partial depence calibration plots or boxplots, model metrics, etc.\n11. Pick your model of choice and kick off an extended grid tuning and figure out something else to do that week (or run it over the weekend). \n12. Compare your results with your coworkers results and see what's working and what isn't. Then you can either move on or continue exploring. Bargain with your boss to get more time so you can explore and learn new things.\n\n

\n\n### Forecasting\n#### Single series and panel data using Time Series models or Machine Learning models\n\n

Expand to view content

\n \nSupply a data.table to run the functions below:\n1. For single series check out AutoBanditSarima(), AutoBanditNNet(), AutoTBATS(), \nAutoETS(), AutoArfima(), or AutoTS() (older function; no longer developing)\n2. For panel data OR single series check out AutoCatBoostCARMA(), AutoXGBoostCARMA(), AutoH2OCARMA(),AutoCatBoostHurdleCARMA or AutoCatBoostVectorCARMA or build a loop and run functions from (1)\n3. If you have to do any funnel forecasting, check out AutoCatBoostChainLadder(). First you need to structure you data like the help example. When you think you have found a good configuration, set the parameter SaveModelObjects = TRUE. Then you can run the AutoMLChainLadderForecasting(). \n\n

\n\n

\n\n## RemixAutoML Blogs\n\n

Expand to view content

\n \n[The Most Feature Rich ML Forecasting Methods Available](https://adrianantico.medium.com/the-most-feature-rich-ml-forecasting-methods-available-compliments-of-remixautoml-61b53daf42e6)\n\n[AutoML Frameworks in R & Python](https://iamnagdev.com/2020/04/01/automl-frameworks-in-r-python/)\n\n[AI for Small to Medium Size Businesses: A Management Take On The Challenges...](https://www.remixinstitute.com/blog/business-ai-for-small-to-medium-sized-businesses-with-remixautoml/#.XX-lD2ZlD8A)\n\n[Why Machine Learning is more Practical than Econometrics in the Real World](https://medium.com/@adrianantico/machine-learning-vs-econometrics-in-the-real-world-4058095b1013)\n\n[Build Thousands of Automated Demand Forecasts in 15 Minutes Using AutoCatBoostCARMA in R](https://www.remixinstitute.com/blog/automated-demand-forecasts-using-autocatboostcarma-in-r/#.XUIO1ntlCDM)\n\n[Automate Your KPI Forecasts With Only 1 Line of R Code Using AutoTS](https://www.remixinstitute.com/blog/automate-your-kpi-forecasts-with-only-1-line-of-r-code-using-autots/#.XUIOr3tlCDM)\n\n[Companies Are Demanding Model Interpretability. Here’s How To Do It Right](https://www.remixinstitute.com/blog/companies-are-demanding-model-interpretability-heres-how-to-do-it-right/#.XUIN1HtlCDM)\n\n[The Easiest Way to Create Thresholds And Improve Your Classification Model](https://www.remixinstitute.com/blog/the-easiest-way-to-create-thresholds-and-improve-your-classification-model/#.XUINVntlCDM)\n\n

\n\n

\n\n## Feature Engineering

Expand to view content

\n\n#### **AutoLagRollStats()** and **AutoLagRollStatsScoring()**\n\n

Code Example

\n\n```\n# Create fake Panel Data----\nCount <- 1L\nfor(Level in LETTERS) {\n datatemp <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.75,\n N = 25000L,\n ID = 0L,\n ZIP = 0L,\n FactorCount = 0L,\n AddDate = TRUE,\n Classification = FALSE,\n MultiClass = FALSE)\n datatemp[, Factor1 := eval(Level)]\n if(Count == 1L) {\n data <- data.table::copy(datatemp)\n } else {\n data <- data.table::rbindlist(list(data, data.table::copy(datatemp)))\n }\n Count <- Count + 1L\n}\n\n# Add scoring records\ndata <- RemixAutoML::AutoLagRollStats(\n\n # Data\n data = data,\n DateColumn = \"DateTime\",\n Targets = \"Adrian\",\n HierarchyGroups = NULL,\n IndependentGroups = c(\"Factor1\"),\n TimeUnitAgg = \"days\",\n TimeGroups = c(\"days\", \"weeks\", \"months\", \"quarters\"),\n TimeBetween = NULL,\n TimeUnit = \"days\",\n\n # Services\n RollOnLag1 = TRUE,\n Type = \"Lag\",\n SimpleImpute = TRUE,\n\n # Calculated Columns\n Lags = list(\"days\" = c(seq(1,5,1)), \"weeks\" = c(seq(1,3,1)), \"months\" = c(seq(1,2,1)), \"quarters\" = c(seq(1,2,1))),\n MA_RollWindows = list(\"days\" = c(seq(1,5,1)), \"weeks\" = c(seq(1,3,1)), \"months\" = c(seq(1,2,1)), \"quarters\" = c(seq(1,2,1))),\n SD_RollWindows = NULL,\n Skew_RollWindows = NULL,\n Kurt_RollWindows = NULL,\n Quantile_RollWindows = NULL,\n Quantiles_Selected = NULL,\n Debug = FALSE)\n```\n\n

\n\n

Code Example

\n\n```\n# Create fake Panel Data----\nCount <- 1L\nfor(Level in LETTERS) {\n datatemp <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.75,\n N = 25000L,\n ID = 0L,\n ZIP = 0L,\n FactorCount = 0L,\n AddDate = TRUE,\n Classification = FALSE,\n MultiClass = FALSE)\n datatemp[, Factor1 := eval(Level)]\n if(Count == 1L) {\n data <- data.table::copy(datatemp)\n } else {\n data <- data.table::rbindlist(list(data, data.table::copy(datatemp)))\n }\n Count <- Count + 1L\n}\n\n# Create ID columns to know which records to score\ndata[, ID := .N:1L, by = \"Factor1\"]\ndata.table::set(data, i = which(data[[\"ID\"]] == 2L), j = \"ID\", value = 1L)\n\n# Score records\ndata <- RemixAutoML::AutoLagRollStatsScoring(\n\n # Data\n data = data,\n RowNumsID = \"ID\",\n RowNumsKeep = 1,\n DateColumn = \"DateTime\",\n Targets = \"Adrian\",\n HierarchyGroups = c(\"Store\",\"Dept\"),\n IndependentGroups = NULL,\n\n # Services\n TimeBetween = NULL,\n TimeGroups = c(\"days\", \"weeks\", \"months\"),\n TimeUnit = \"day\",\n TimeUnitAgg = \"day\",\n RollOnLag1 = TRUE,\n Type = \"Lag\",\n SimpleImpute = TRUE,\n\n # Calculated Columns\n Lags = list(\"days\" = c(seq(1,5,1)), \"weeks\" = c(seq(1,3,1)), \"months\" = c(seq(1,2,1))),\n MA_RollWindows = list(\"days\" = c(seq(1,5,1)), \"weeks\" = c(seq(1,3,1)), \"months\" = c(seq(1,2,1))),\n SD_RollWindows = list(\"days\" = c(seq(1,5,1)), \"weeks\" = c(seq(1,3,1)), \"months\" = c(seq(1,2,1))),\n Skew_RollWindows = list(\"days\" = c(seq(1,5,1)), \"weeks\" = c(seq(1,3,1)), \"months\" = c(seq(1,2,1))),\n Kurt_RollWindows = list(\"days\" = c(seq(1,5,1)), \"weeks\" = c(seq(1,3,1)), \"months\" = c(seq(1,2,1))),\n Quantile_RollWindows = list(\"days\" = c(seq(1,5,1)), \"weeks\" = c(seq(1,3,1)), \"months\" = c(seq(1,2,1))),\n Quantiles_Selected = c(\"q5\",\"q10\",\"q95\"),\n Debug = FALSE)\n```\n\n

\n\n

Function Description

\n \nAutoLagRollStats() builds lags and rolling statistics by grouping variables and their interactions along with multiple different time aggregations if selected. Rolling stats include mean, sd, skewness, kurtosis, and the 5th - 95th percentiles. This function was inspired by the distributed lag modeling framework but I wanted to use it for time series analysis as well and really generalize it as much as possible. The beauty of this function is inspired by analyzing whether a baseball player will get a basehit or more in his next at bat. One easy way to get a better idea of the likelihood is to look at his batting average and his career batting average. However, players go into hot streaks and slumps. How do we account for that? Well, in comes the functions here. You look at the batting average over the last N to N+x at bats, for various N and x. I keep going though - I want the same windows for calculating the players standard deviation, skewness, kurtosis, and various quantiles over those time windows. I also want to look at all those measure but by using weekly data - as in, over the last N weeks, pull in those stats too. \n\nAutoLagRollStatsScoring() builds the above features for a partial set of records in a data set. The function is extremely useful as it can compute these feature vectors at a significantly faster rate than the non scoring version which comes in handy for scoring ML models. If you can find a way to make it faster, let me know.\n\n

\n\n#### **AutoDiffLagN()**\n\n

Code Example

\n \n```\n##############################\n# Current minus lag1\n##############################\n \n# Create fake data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.70,\n N = 50000,\n ID = 2L,\n FactorCount = 3L,\n AddDate = TRUE,\n ZIP = 0L,\n TimeSeries = FALSE,\n ChainLadderData = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Store Cols to diff\nCols <- names(data)[which(unlist(data[, lapply(.SD, is.numeric)]))]\n\n# Clean data before running AutoDiffLagN\ndata <- RemixAutoML::ModelDataPrep(\n data = data,\n Impute = FALSE,\n CharToFactor = FALSE,\n FactorToChar = TRUE)\n\n# Run function\ndata <- RemixAutoML::AutoDiffLagN(\n data,\n DateVariable = \"DateTime\",\n GroupVariables = c(\"Factor_1\", \"Factor_2\", \"Factor_3\"),\n DiffVariables = Cols,\n DiffDateVariables = \"DateTime\",\n NLag1 = 0,\n NLag2 = 1,\n Sort = TRUE,\n RemoveNA = TRUE)\n\n##############################\n# lag1 minus lag3\n##############################\n\n# Create fake data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.70,\n N = 50000,\n ID = 2L,\n FactorCount = 3L,\n AddDate = TRUE,\n ZIP = 0L,\n TimeSeries = FALSE,\n ChainLadderData = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Store Cols to diff\nCols <- names(data)[which(unlist(data[, lapply(.SD, is.numeric)]))]\n\n# Clean data before running AutoDiffLagN\ndata <- RemixAutoML::ModelDataPrep(\n data = data,\n Impute = FALSE,\n CharToFactor = FALSE,\n FactorToChar = TRUE)\n\n# Run function\ndata <- RemixAutoML::AutoDiffLagN(\n data,\n DateVariable = \"DateTime\",\n GroupVariables = c(\"Factor_1\", \"Factor_2\", \"Factor_3\"),\n DiffVariables = Cols,\n DiffDateVariables = \"DateTime\",\n NLag1 = 1,\n NLag2 = 3,\n Sort = TRUE,\n RemoveNA = TRUE)\n```\n\n

\n\n

Function Description

\n \nAutoDiffLagN() Generate differences for numeric columns and date columns, by groups. You can specify NLag1 = 0 and NLag2 to generate the diffs based on a lag 1 to lag 2 differences for a column, and multiple columns.\n\n

\n\n#### **AutoInteraction()**\n\n

Code Example

\n\n```\n#########################################\n# Feature Engineering for Model Training\n#########################################\n\n# Create fake data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.70,\n N = 50000,\n ID = 2L,\n FactorCount = 2L,\n AddDate = TRUE,\n ZIP = 0L,\n TimeSeries = FALSE,\n ChainLadderData = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Print number of columns\nprint(ncol(data))\n\n# Store names of numeric and integer cols\nCols <-names(data)[c(which(unlist(lapply(data, is.numeric))),\n which(unlist(lapply(data, is.integer))))]\n\n# Model Training Feature Engineering\nsystem.time(data <- RemixAutoML::AutoInteraction(\n data = data,\n NumericVars = Cols,\n InteractionDepth = 4,\n Center = TRUE,\n Scale = TRUE,\n SkipCols = NULL,\n Scoring = FALSE,\n File = getwd()))\n\n# user system elapsed\n# 0.32 0.22 0.53\n\n# Print number of columns\nprint(ncol(data))\n# 16\n\n########################################\n# Feature Engineering for Model Scoring\n########################################\n\n# Create fake data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.70,\n N = 50000,\n ID = 2L,\n FactorCount = 2L,\n AddDate = TRUE,\n ZIP = 0L,\n TimeSeries = FALSE,\n ChainLadderData = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Print number of columns\nprint(ncol(data))\n# 16\n\n# Reduce to single row to mock a scoring scenario\ndata <- data[1L]\n\n# Model Scoring Feature Engineering\nsystem.time(data <- RemixAutoML::AutoInteraction(\n data = data,\n NumericVars = names(data)[\n c(which(unlist(lapply(data, is.numeric))),\n which(unlist(lapply(data, is.integer))))],\n InteractionDepth = 4,\n Center = TRUE,\n Scale = TRUE,\n SkipCols = NULL,\n Scoring = TRUE,\n File = file.path(getwd(), \"Standardize.Rdata\")))\n\n# user system elapsed\n# 0.19 0.00 0.19\n\n# Print number of columns\nprint(ncol(data))\n# 1095\n```\n\n

\n\n

Function Description

\n\nAutoInteraction() will build out any number of interactions you want for numeric variables. You supply a character vector of numeric or integer column names, along with the names of any numeric columns you want to skip (including the interaction column names) and the interactions will be automatically created for you. For example, if you want a 4th degree interaction from 10 numeric columns, you will have 10 C 2, 10 C 3, and 10 C 4 columns created. Now, let's say you build all those features and decide you don't want all 10 features to be included. Remove the feature name from the NumericVars character vector. Now, let's say you modeled all of the interaction features and want to remove the ones will the lowest scores on the variable importance list. Grab the names and run the interaction function again except this time supply those poor performing interaction column names to the SkipCols argument and they will be ignored. Now, if you want to interact any categorical variable with a numeric variable, you'll have to dummify the categorical variable first and then include the level specific dummy variable column names to the NumericVars character vector argument. If you set Center and Scale to TRUE then the interaction multiplication won't create huge numbers.\n\n

\n\n#### **AutoWord2VecModeler()** and **AutoWord2VecScoring()**\n\n

Code Example

\n\n```\n# Create fake data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.70,\n N = 1000L,\n ID = 2L,\n FactorCount = 2L,\n AddDate = TRUE,\n AddComment = TRUE,\n ZIP = 2L,\n TimeSeries = FALSE,\n ChainLadderData = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Create Model and Vectors\ndata <- RemixAutoML::AutoWord2VecModeler(\n data,\n BuildType = \"individual\",\n stringCol = c(\"Comment\"),\n KeepStringCol = FALSE,\n ModelID = \"Model_1\",\n model_path = getwd(),\n vects = 10,\n MinWords = 1,\n WindowSize = 1,\n Epochs = 25,\n SaveModel = \"standard\",\n Threads = max(1,parallel::detectCores()-2),\n MaxMemory = \"28G\")\n\n# Remove data\nrm(data)\n\n# Create fake data for mock scoring\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.70,\n N = 1000L,\n ID = 2L,\n FactorCount = 2L,\n AddDate = TRUE,\n AddComment = TRUE,\n ZIP = 2L,\n TimeSeries = FALSE,\n ChainLadderData = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Create vectors for scoring\ndata <- RemixAutoML::AutoWord2VecScoring(\n data,\n BuildType = \"individual\",\n ModelObject = NULL,\n ModelID = \"Model_1\",\n model_path = getwd(),\n stringCol = \"Comment\",\n KeepStringCol = FALSE,\n H2OStartUp = TRUE,\n H2OShutdown = TRUE,\n Threads = max(1L, parallel::detectCores() - 2L),\n MaxMemory = \"28G\")\n\n```\n\n

\n\n

Function Description

\n \nAutoWord2VecModeler() generates a specified number of vectors (word2vec) for each column of text data in your data set that you specify and it will save the models if you specify for re-creating them later in a model scoring process. You can choose to build individual models for each column or one model for all your columns. If you need to run several models for groups of text variables you can run the function several times. \n\nAutoWord2VecScoring() this is for generating word2vec vectors for model scoring situations. The function will load the model, create the transformations, and merge them onto the source data.table just like the training version does.\n\n

\n\n#### **H2OAutoencoder()** and **H2OAutoencoderScoring()**\n\n

Code Example

\n\n\n```\n############################\n# Training\n############################\n\n# Create simulated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.70,\n N = 1000L,\n ID = 2L,\n FactorCount = 2L,\n AddDate = TRUE,\n AddComment = FALSE,\n ZIP = 2L,\n TimeSeries = FALSE,\n ChainLadderData = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run algo\nOutput <- RemixAutoML::H2OAutoencoder(\n \n # Select the service\n AnomalyDetection = TRUE,\n DimensionReduction = TRUE,\n\n # Data related args\n data = data,\n ValidationData = NULL,\n Features = names(data)[2L:(ncol(data)-1L)],\n per_feature = FALSE,\n RemoveFeatures = TRUE,\n ModelID = \"TestModel\",\n model_path = getwd(),\n\n # H2O Environment\n NThreads = max(1L, parallel::detectCores()-2L),\n MaxMem = \"28G\",\n H2OStart = TRUE,\n H2OShutdown = TRUE,\n \n # H2O ML Args\n LayerStructure = NULL,\n ReturnLayer = 4L,\n Activation = \"Tanh\",\n Epochs = 5L,\n L2 = 0.10,\n ElasticAveraging = TRUE,\n ElasticAveragingMovingRate = 0.90,\n ElasticAveragingRegularization = 0.001)\n\n# Inspect output\ndata <- Output$Data\nModel <- Output$Model\n\n# If ValidationData is not null\nValidationData <- Output$ValidationData\n\n############################\n# Scoring\n############################\n\n# Create simulated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.70,\n N = 1000L,\n ID = 2L,\n FactorCount = 2L,\n AddDate = TRUE,\n AddComment = FALSE,\n ZIP = 2L,\n TimeSeries = FALSE,\n ChainLadderData = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run algo\ndata <- RemixAutoML::H2OAutoencoderScoring(\n\n # Select the service\n AnomalyDetection = TRUE,\n DimensionReduction = TRUE,\n \n # Data related args\n data = data,\n Features = names(data)[2L:ncol(data)],\n RemoveFeatures = TRUE,\n ModelObject = NULL,\n ModelID = \"TestModel\",\n model_path = getwd(),\n\n # H2O args\n NThreads = max(1L, parallel::detectCores()-2L),\n MaxMem = \"28G\",\n H2OStart = TRUE,\n H2OShutdown = TRUE,\n ReturnLayer = 4L,\n per_feature = FALSE)\n```\n\n

\n\n

Function Description

\n\nH2OAutoencoder() Use for dimension reduction and anomaly detection\n\nH2OAutoencoderScoring() Use for dimension reduction and anomaly detection scoring\n\n

\n\n#### **H2OIsolationForest()** and **H2OIsolationForestScoring()**\n\n

Code Example

\n\n```\n# Create simulated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.70,\n N = 50000,\n ID = 2L,\n FactorCount = 2L,\n AddDate = TRUE,\n ZIP = 0L,\n TimeSeries = FALSE,\n ChainLadderData = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run algo\ndata <- RemixAutoML::H2OIsolationForest(\n data,\n Features = names(data)[2L:ncol(data)],\n IDcols = c(\"Adrian\", \"IDcol_1\", \"IDcol_2\"),\n ModelID = \"Adrian\",\n SavePath = getwd(),\n Threshold = 0.95,\n MaxMem = \"28G\",\n NThreads = -1,\n NTrees = 100,\n SampleRate = (sqrt(5)-1)/2,\n MaxDepth = 8,\n MinRows = 1,\n ColSampleRate = 1,\n ColSampleRatePerLevel = 1,\n ColSampleRatePerTree = 1,\n CategoricalEncoding = c(\"AUTO\"),\n Debug = TRUE)\n\n# Remove output from data and then score\ndata[, eval(names(data)[17:ncol(data)]) := NULL]\n\n# Run algo\nOutliers <- RemixAutoML::H2OIsolationForestScoring(\n data,\n Features = names(data)[2:ncol(data)],\n IDcols = c(\"Adrian\", \"IDcol_1\", \"IDcol_2\"),\n H2OStart = TRUE,\n H2OShutdown = TRUE,\n ModelID = \"TestModel\",\n SavePath = getwd(),\n Threshold = 0.95,\n MaxMem = \"28G\",\n NThreads = -1,\n Debug = FALSE)\n```\n\n

\n\n

Function Description

\n\nH2OIsolationForecast() Anomaly detection and feature engineering using H2O Isolation Forest. A model is built, your training data is scored, and the model is saved to file for later use in scoring environments with H2OIsolationForestScoring()\n\nH2OIsolationForecastScoring() Scoring function\n\n

\n\n#### **AutoClustering()** \n\n

Code Example

\n\n```\n#########################\n# Training Setup\n#########################\n\n# Create fake data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000,\n ID = 2,\n ZIP = 0,\n AddDate = TRUE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run function\ndata <- RemixAutoML::AutoClustering(\n data,\n FeatureColumns = names(data)[2:(ncol(data)-1)],\n ModelID = \"TestModel\",\n SavePath = getwd(),\n NThreads = 8,\n MaxMemory = \"28G\",\n MaxClusters = 50,\n ClusterMetric = \"totss\",\n RunDimReduction = TRUE,\n ShrinkRate = (sqrt(5) - 1) / 2,\n Epochs = 5L,\n L2_Reg = 0.10,\n ElasticAveraging = TRUE,\n ElasticAveragingMovingRate = 0.90,\n ElasticAveragingRegularization = 0.001)\n\n#########################\n# Scoring Setup\n#########################\n\nSys.sleep(10)\n\n# Create fake data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000,\n ID = 2,\n ZIP = 0,\n AddDate = TRUE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run function\ndata <- RemixAutoML::AutoClusteringScoring(\n data,\n FeatureColumns = names(data)[2:(ncol(data)-1)],\n ModelID = \"TestModel\",\n SavePath = getwd(),\n NThreads = 8,\n MaxMemory = \"28G\",\n DimReduction = TRUE)\n```\n\n

Function Description

\n \nAutoClustering() Generates a single column and merges it onto your data. You can have an autoencoder ran to reduce the dimension size before running the KMeans grid tuning operation. If you provide a directory path, the models will be saved and can be used later in scoring enviroments. I find that I utilize clustering more often for feature engineering that unsupervised learning which is why I put the code example and description here. The function utilizes H2O under the hood with their KMeans algo for the clustering and their deep learning algo for the dimensionality reduction. \n\n

\n\n

\n\n#### **CreateCalendarVariables()**\n\n

Code Example

\n\n```\n# Create fake data with a Date column----\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.75,\n N = 25000L,\n ID = 2L,\n ZIP = 0L,\n FactorCount = 4L,\n AddDate = TRUE,\n Classification = FALSE,\n MultiClass = FALSE)\nfor(i in seq_len(20L)) {\n print(i)\n data <- data.table::rbindlist(list(data, RemixAutoML::FakeDataGenerator(\n Correlation = 0.75,\n N = 25000L,\n ID = 2L,\n ZIP = 0L,\n FactorCount = 4L,\n AddDate = TRUE,\n Classification = FALSE,\n MultiClass = FALSE)))\n}\n\n# Create calendar variables - automatically excludes the second, minute, and hour selections since\n# it is not timestamp data\nruntime <- system.time(\n data <- RemixAutoML::CreateCalendarVariables(\n data = data,\n DateCols = \"DateTime\",\n AsFactor = FALSE,\n TimeUnits = c(\"second\", \"minute\", \"hour\", \"wday\", \"mday\", \"yday\", \"week\", \"isoweek\", \"wom\", \"month\", \"quarter\", \"year\")))\nhead(data)\nprint(runtime)\n```\n\n

\n\n

Function Description

\n \nCreateCalendarVariables() This functions creates numerical columns based on the date columns you supply such as second, minute, hour, week day, day of month, day of year, week, isoweek, wom, month, quarter, and year.\n\n

\n\n#### **CreateHolidayVariable()**\n\n

Code Example

\n \n```\n# Create fake data with a Date----\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.75,\n N = 25000L,\n ID = 2L,\n ZIP = 0L,\n FactorCount = 4L,\n AddDate = TRUE,\n Classification = FALSE,\n MultiClass = FALSE)\nfor(i in seq_len(20L)) {\n print(i)\n data <- data.table::rbindlist(list(data, RemixAutoML::FakeDataGenerator(\n Correlation = 0.75,\n N = 25000L,\n ID = 2L,\n ZIP = 0L,\n FactorCount = 4L,\n AddDate = TRUE,\n Classification = FALSE,\n MultiClass = FALSE)))\n}\n# Run function and time it\nruntime <- system.time(\n data <- CreateHolidayVariables(\n data,\n DateCols = \"DateTime\",\n LookbackDays = 7,\n HolidayGroups = c(\"USPublicHolidays\",\"EasterGroup\",\"ChristmasGroup\",\"OtherEcclesticalFeasts\"),\n Holidays = NULL\n Print = FALSE))\nhead(data)\nprint(runtime)\n```\n\n

\n\n

Function Description

\n \nCreateHolidayVariable() \nThis function counts up the number of specified holidays between the current record time stamp and the previous record time stamp, by group as well if specified.\n\n

\n\n#### **DummifyDT()** \n\n

Code Example

\n\n```\n# Create fake data with 10 categorical columns\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 25000,\n ID = 2L,\n ZIP = 0,\n FactorCount = 10L,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Create dummy variables\ndata <- DummifyDT(\n data = data,\n cols = c(\"Factor_1\",\n \"Factor_2\",\n \"Factor_3\",\n \"Factor_4\",\n \"Factor_5\",\n \"Factor_6\",\n \"Factor_8\",\n \"Factor_9\",\n \"Factor_10\"),\n TopN = c(rep(3,9)),\n KeepFactorCols = TRUE,\n OneHot = FALSE,\n SaveFactorLevels = TRUE,\n SavePath = getwd(),\n ImportFactorLevels = FALSE,\n FactorLevelsList = NULL,\n ClustScore = FALSE,\n ReturnFactorLevels = FALSE)\n\n# Create Fake Data for Scoring Replication\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 25000,\n ID = 2L,\n ZIP = 0,\n FactorCount = 10L,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Scoring Version (imports csv's to generate matching levels and ordering)\ndata <- RemixAutoML::DummifyDT(\n data = data,\n cols = c(\"Factor_1\",\n \"Factor_2\",\n \"Factor_3\",\n \"Factor_4\",\n \"Factor_5\",\n \"Factor_6\",\n \"Factor_8\",\n \"Factor_9\",\n \"Factor_10\"),\n TopN = c(rep(3,9)),\n KeepFactorCols = TRUE,\n OneHot = FALSE,\n SaveFactorLevels = TRUE,\n SavePath = getwd(),\n ImportFactorLevels = TRUE,\n FactorLevelsList = NULL,\n ClustScore = FALSE,\n ReturnFactorLevels = FALSE)\n```\n\n

\n\n

Function Description

\n\nDummifyDT() This function is used in the AutoXGBoost__() suite of modeling functions to manage categorical variables in your training, validation, and test sets. This function rapidly dichotomizes categorical columns in a data.table (N+1 columns for N levels using one hot encoding or N columns for N levels otherwise). Several other arguments exist for outputting and saving factor levels. This is useful in model training, validating, and scoring processes.\n\n

\n\n#### **AutoDataPartition()**\n\n

Code Example

\n\n```\n# Create fake data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85, \n N = 1000, \n ID = 2, \n ZIP = 0, \n AddDate = FALSE, \n Classification = FALSE, \n MultiClass = FALSE)\n\n# Run data partitioning function\ndataSets <- RemixAutoML::AutoDataPartition(\n data,\n NumDataSets = 3L,\n Ratios = c(0.70,0.20,0.10),\n PartitionType = \"random\",\n StratifyColumnNames = NULL,\n TimeColumnName = NULL)\n\n# Collect data\nTrainData <- dataSets$TrainData\nValidationData <- dataSets$ValidationData\nTestData <- dataSets$TestData\n```\n\n

\n\n

Function Description

\n\nAutoDataPartition() is designed to achieve a few things that standard data partitioning processes or functions don't handle. First, you can choose to build any number of partitioned data sets beyond the standard train, validate, and test data sets. Second, you can choose between random sampling to split your data or you can choose a time-based partitioning. Third, for the random partitioning, you can specify a stratification columns in your data to stratify by in order to ensure a proper split amongst your categorical features (E.g. think MultiClass targets). Lastly, it's 100% data.table so it will run fast and with low memory overhead.\n\n

\n\n#### **ModelDataPrep()**\n\n

Code Example

\n \n```\n# Create fake data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.75,\n N = 250000L,\n ID = 2L,\n ZIP = 0L,\n FactorCount = 6L,\n AddDate = TRUE,\n AddComment = FALSE,\n TimeSeries = FALSE,\n AddDate = TRUE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Check column types\nstr(data)\n\n# RUn function\ndata <- RemixAutoML::ModelDataPrep(\n data,\n Impute = TRUE,\n CharToFactor = FALSE,\n FactorToChar = TRUE,\n IntToNumeric = TRUE,\n LogicalToBinary = FALSE,\n DateToChar = FALSE,\n RemoveDates = TRUE,\n MissFactor = \"0\",\n MissNum = -1,\n IgnoreCols = c(\"Factor_1\"))\n\n# Check column types\nstr(data)\n```\n\n

\n\n

Function Description

\n\nModelDataPrep() This function will loop through every column in your data and apply a variety of functions based on argument settings. For all columns not ignored, these tasks include:\n* Character type to Factor type converstion\n* Factor type to Character type conversion\n* Constant value imputation for numeric and categorical columns\n* Integer type to Numeric type conversion\n* Date type to Character type conversion\n* Remove date columns\n* Ignore specified columns\n\n

\n\n#### **AutoTransformationCreate()** and **AutoTransformationScore()**\n\n

Function Description

\n \nAutoTransformationCreate() is a function for automatically identifying the optimal transformations for numeric features and transforming them once identified. This function will loop through your selected transformation options (YeoJohnson, BoxCox, Asinh, Log, LogPlus1, Sqrt, along with Asin and Logit for proportion data) and find the one that produces the best fit to a normal distribution. It then generates the transformation and collects the metadata information for use in the AutoTransformationScore() function, either by returning the objects or saving them to file.\n\nAutoTransformationScore() is a the compliment function to AutoTransformationCreate(). Automatically apply or inverse the transformations you identified in AutoTransformationCreate() to other data sets. This is useful for applying transformations to your validation and test data sets for modeling, which is done automatically for you if you specify.\n\n

\n\n#### **AutoHierarchicalFourier()**\n\n

Function Description

\n \nAutoHierarchicalFourier() turns time series data into fourier series. This function can generate any number of fourier pairs the user wants (if they can actually build) and you can run it with grouped time series data. In the grouping case, fourier pairs can be created for each categorical variable along with the full interactions between specified categoricals. The process is parallelized as well to run as fast as possible.\n\n

\n\n\n

\n\n## Supervised Learning

Expand to view content

\n \n#### Regression\n\n

click to expand

\n \n#### **AutoCatBoostRegression()** GPU Capable\nAutoCatBoostRegression() utilizes the CatBoost algorithm in the below steps\n\n

Code Example

\n \n ```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 10000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run function\nTestModel <- RemixAutoML::AutoCatBoostRegression(\n\n # GPU or CPU and the number of available GPUs\n task_type = \"GPU\",\n NumGPUs = 1,\n\n # Metadata args\n ModelID = \"Test_Model_1\",\n model_path = normalizePath(\"./\"),\n metadata_path = normalizePath(\"./\"),\n SaveModelObjects = FALSE,\n SaveInfoToPDF = FALSE,\n ReturnModelObjects = TRUE,\n\n # Data args\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n Weights = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in%\n c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n PrimaryDateColumn = NULL,\n DummifyCols = FALSE,\n IDcols = c(\"IDcol_1\",\"IDcol_2\"),\n TransformNumericColumns = \"Adrian\",\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\",\n \"LogPlus1\", \"Sqrt\", \"Logit\"),\n\n # Model evaluation\n eval_metric = \"RMSE\",\n eval_metric_value = 1.5,\n loss_function = \"RMSE\",\n loss_function_value = 1.5,\n grid_eval_metric = \"r2\",\n MetricPeriods = 10L,\n NumOfParDepPlots = ncol(data)-1L-2L,\n EvalPlots = TRUE,\n\n # Grid tuning args\n PassInGrid = NULL,\n GridTune = FALSE,\n MaxModelsInGrid = 30L,\n MaxRunsWithoutNewWinner = 20L,\n MaxRunMinutes = 60*60,\n BaselineComparison = \"default\",\n\n # ML args\n langevin = FALSE,\n diffusion_temperature = 10000,\n Trees = 1000,\n Depth = 6,\n L2_Leaf_Reg = 3.0,\n RandomStrength = 1,\n BorderCount = 128,\n LearningRate = NULL,\n RSM = 1,\n BootStrapType = NULL,\n GrowPolicy = \"SymmetricTree\",\n model_size_reg = 0.5,\n feature_border_type = \"GreedyLogSum\",\n sampling_unit = \"Object\",\n subsample = NULL,\n score_function = \"Cosine\",\n min_data_in_leaf = 1,\n DebugMode = FALSE)\n\n \n\n # Output\n TestModel$Model\n TestModel$ValidationData\n TestModel$EvaluationPlot\n TestModel$EvaluationBoxPlot\n TestModel$EvaluationMetrics\n TestModel$VariableImportance\n TestModel$InteractionImportance\n TestModel$ShapValuesDT\n TestModel$VI_Plot\n TestModel$PartialDependencePlots\n TestModel$PartialDependenceBoxPlots\n TestModel$GridList\n TestModel$ColNames\n TestModel$TransformationResults\n ```\n \n

\n\n#### **AutoXGBoostRegression()** GPU Capable\nAutoXGBoostRegression() utilizes the XGBoost algorithm in the below steps \n\n

Code Example

\n \n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run function\nTestModel <- RemixAutoML::AutoXGBoostRegression(\n\n # GPU or CPU\n TreeMethod = \"hist\",\n NThreads = parallel::detectCores(),\n LossFunction = 'reg:squarederror',\n \n # Metadata args\n model_path = normalizePath(\"./\"),\n metadata_path = NULL,\n ModelID = \"Test_Model_1\",\n ReturnFactorLevels = TRUE,\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n \n # Data args\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in%\n c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n IDcols = c(\"IDcol_1\",\"IDcol_2\"),\n TransformNumericColumns = NULL,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\",\n \"LogPlus1\", \"Sqrt\", \"Logit\", \"YeoJohnson\"),\n \n # Model evaluation args\n eval_metric = \"rmse\",\n NumOfParDepPlots = 3L,\n \n # Grid tuning args\n PassInGrid = NULL,\n GridTune = FALSE,\n grid_eval_metric = \"mse\",\n BaselineComparison = \"default\",\n MaxModelsInGrid = 10L,\n MaxRunsWithoutNewWinner = 20L,\n MaxRunMinutes = 24L*60L,\n Verbose = 1L,\n \n # ML args\n Shuffles = 1L,\n Trees = 50L,\n eta = 0.05,\n max_depth = 4L,\n min_child_weight = 1.0,\n subsample = 0.55,\n colsample_bytree = 0.55)\n```\n \n

\n\n#### **AutoH2oGBMRegression()**\nAutoH2oGBMRegression() utilizes the H2O Gradient Boosting algorithm in the below steps \n\n

Code Example

\n\n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oGBMRegression(\n \n # Compute management\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1, parallel::detectCores()-2),\n H2OShutdown = TRUE,\n H2OStartUp = TRUE,\n IfSaveModel = \"mojo\",\n \n # Model evaluation\n NumOfParDepPlots = 3,\n \n # Metadata arguments:\n model_path = normalizePath(\"./\"),\n metadata_path = file.path(normalizePath(\"./\")),\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n SaveInfoToPDF = FALSE,\n \n # Data arguments\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n WeightsColumn = NULL,\n TransformNumericColumns = NULL,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\", \"LogPlus1\", \"Sqrt\", \"Logit\",\"YeoJohnson\"),\n \n # ML grid tuning args\n GridTune = FALSE,\n GridStrategy = \"Cartesian\",\n MaxRuntimeSecs = 60*60*24,\n StoppingRounds = 10,\n MaxModelsInGrid = 2,\n \n # Model args\n Trees = 50,\n LearnRate = 0.10,\n LearnRateAnnealing = 1,\n eval_metric = \"RMSE\",\n Alpha = NULL,\n Distribution = \"poisson\",\n MaxDepth = 20,\n SampleRate = 0.632,\n ColSampleRate = 1,\n ColSampleRatePerTree = 1,\n ColSampleRatePerTreeLevel = 1,\n MinRows = 1,\n NBins = 20,\n NBinsCats = 1024,\n NBinsTopLevel = 1024,\n HistogramType = \"AUTO\",\n CategoricalEncoding = \"AUTO\")\n```\n \n

\n\n#### **AutoH2oDRFRegression()**\nAutoH2oDRFRegression() utilizes the H2o Distributed Random Forest algorithm in the below steps \n\n

Code Example

\n \n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oDRFRegression(\n \n # Compute management\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1L, parallel::detectCores() - 2L),\n H2OShutdown = TRUE,\n H2OStartUp = TRUE,\n IfSaveModel = \"mojo\",\n \n # Model evaluation:\n eval_metric = \"RMSE\",\n NumOfParDepPlots = 3,\n \n # Metadata arguments:\n model_path = normalizePath(\"./\"),\n metadata_path = NULL,\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n SaveInfoToPDF = FALSE,\n \n # Data Args\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n WeightsColumn = NULL,\n TransformNumericColumns = NULL,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\", \"LogPlus1\", \"Sqrt\", \"Logit\", \"YeoJohnson\"),\n \n # Grid Tuning Args\n GridStrategy = \"Cartesian\",\n GridTune = FALSE,\n MaxModelsInGrid = 10,\n MaxRuntimeSecs = 60*60*24,\n StoppingRounds = 10,\n \n # ML Args\n Trees = 50,\n MaxDepth = 20,\n SampleRate = 0.632,\n MTries = -1,\n ColSampleRatePerTree = 1,\n ColSampleRatePerTreeLevel = 1,\n MinRows = 1,\n NBins = 20,\n NBinsCats = 1024,\n NBinsTopLevel = 1024,\n HistogramType = \"AUTO\",\n CategoricalEncoding = \"AUTO\")\n```\n \n

\n\n#### **AutoH2oGLMRegression()**\nAutoH2oGLMRegression() utilizes the H2o generalized linear model algorithm in the below steps \n\n

Code Example

\n \n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oGLMRegression(\n \n # Compute management\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1, parallel::detectCores()-2),\n H2OShutdown = TRUE,\n H2OStartUp = TRUE,\n IfSaveModel = \"mojo\",\n \n # Model evaluation:\n eval_metric = \"RMSE\",\n NumOfParDepPlots = 3,\n \n # Metadata arguments:\n model_path = NULL,\n metadata_path = NULL,\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n SaveInfoToPDF = FALSE,\n \n # Data arguments:\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n RandomColNumbers = NULL,\n InteractionColNumbers = NULL,\n WeightsColumn = NULL,\n TransformNumericColumns = NULL,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\", \"LogPlus1\", \"Sqrt\", \"Logit\", \"YeoJohnson\"),\n \n # Model args\n GridTune = FALSE,\n GridStrategy = \"Cartesian\",\n StoppingRounds = 10,\n MaxRunTimeSecs = 3600 * 24 * 7,\n MaxModelsInGrid = 10,\n Distribution = \"gaussian\",\n Link = \"identity\",\n TweedieLinkPower = NULL,\n TweedieVariancePower = NULL,\n RandomDistribution = NULL,\n RandomLink = NULL,\n Solver = \"AUTO\",\n Alpha = NULL,\n Lambda = NULL,\n LambdaSearch = FALSE,\n NLambdas = -1,\n Standardize = TRUE,\n RemoveCollinearColumns = FALSE,\n InterceptInclude = TRUE,\n NonNegativeCoefficients = FALSE)\n```\n \n

\n\n#### **AutoH2oMLRegression()**\nAutoH2oMLRegression() utilizes the H2o AutoML algorithm in the below steps \n\n

Code Example

\n \n```\n# Create some dummy correlated data with numeric and categorical features\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oMLRegression(\n\n # Compute management\n MaxMem = \"32G\",\n NThreads = max(1, parallel::detectCores()-2),\n H2OShutdown = TRUE,\n IfSaveModel = \"mojo\",\n\n # Model evaluation\n eval_metric = \"RMSE\",\n NumOfParDepPlots = 3,\n\n # Metadata arguments\n model_path = NULL,\n metadata_path = NULL,\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n\n # Data arguments\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n TransformNumericColumns = NULL,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\", \"LogPlus1\", \"Logit\", \"YeoJohnson\"),\n\n # Model args\n GridTune = FALSE,\n ExcludeAlgos = NULL,\n Trees = 50,\n MaxModelsInGrid = 10)\n```\n\n

\n \n#### **AutoH2oGAMRegression()**\nAutoH2oGLMRegression() utilizes the H2o generalized linear model algorithm in the below steps \n\n

Code Example

\n \n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Define GAM Columns to use - up to 9 are allowed\nGamCols <- names(which(unlist(lapply(data, is.numeric))))\nGamCols <- GamCols[!GamCols %in% c(\"Adrian\",\"IDcol_1\",\"IDcol_2\")]\nGamCols <- GamCols[1L:(min(9L,length(GamCols)))]\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oGAMRegression(\n \n # Compute management\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1, parallel::detectCores()-2),\n H2OShutdown = TRUE,\n H2OStartUp = TRUE,\n IfSaveModel = \"mojo\",\n \n # Model evaluation:\n eval_metric = \"RMSE\",\n NumOfParDepPlots = 3,\n \n # Metadata arguments:\n model_path = NULL,\n metadata_path = NULL,\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n SaveInfoToPDF = FALSE,\n \n # Data arguments:\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n InteractionColNumbers = NULL,\n WeightsColumn = NULL,\n GamColNames = GamCols,\n TransformNumericColumns = NULL,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\", \"LogPlus1\", \"Sqrt\", \"Logit\", \"YeoJohnson\"),\n \n # Model args\n num_knots = NULL,\n keep_gam_cols = TRUE,\n GridTune = FALSE,\n GridStrategy = \"Cartesian\",\n StoppingRounds = 10,\n MaxRunTimeSecs = 3600 * 24 * 7,\n MaxModelsInGrid = 10,\n Distribution = \"gaussian\",\n Link = \"Family_Default\",\n TweedieLinkPower = NULL,\n TweedieVariancePower = NULL,\n Solver = \"AUTO\",\n Alpha = NULL,\n Lambda = NULL,\n LambdaSearch = FALSE,\n NLambdas = -1,\n Standardize = TRUE,\n RemoveCollinearColumns = FALSE,\n InterceptInclude = TRUE,\n NonNegativeCoefficients = FALSE)\n```\n \n

\n \n#### The Auto_Regression() models handle a multitude of tasks. In order:\n1. Convert your data to data.table format for faster processing\n2. Transform your target variable using the best normalization method based on the AutoTransformationCreate() function\n3. Create train, validation, and test data, utilizing the AutoDataPartition() function, if you didn't supply those directly to the function\n4. Consoldate columns that are used for modeling and what metadata you want returned in your test data with predictions\n5. Dichotomize categorical variables (for AutoXGBoostRegression()) and save the factor levels for scoring in a way that guarentees consistency across training, validation, and test data sets, utilizing the DummifyDT() function\n6. Save the final modeling column names for reference\n7. Handles the data conversion to the appropriate modeling type, such as CatBoost, H2O, and XGBoost\n8. Multi-armed bandit hyperparameter tuning using randomized probability matching, if you choose to grid tune\n9. Loop through the grid-tuning process, building N models\n10. Collect the evaluation metrics for each grid tune run\n11. Identify the best model of the set of models built in the grid tuning search\n12. Save the hyperparameters from the winning grid tuned model\n13. Build the final model based on the best model from the grid tuning model search (I remove each model after evaluation metrics are generated in the grid tune to avoid memory overflow)\n14. Back-transform your predictions based on the best transformation used earlier in the process\n15. Collect evaluation metrics based on performance on test data (based on back-transformed data)\n16. Store the final predictions with the associated test data and other columns you want included in that set\n17. Save your transformation metadata for recreating them in a scoring process\n18. Build out and save an Evaluation Calibration Line Plot and Evaluation Calibration Box-Plot, using the EvalPlot() function\n19. Generate and save Variable Importance\n20. Generate and save Partital Dependence Calibration Line Plots and Partital Dependence Calibration Box-Plots, using the ParDepPlots() function\n21. Return all the objects generated in a named list for immediate use and evaluation\n \n

\n\n#### Binary Classification\n\n

click to expand

\n \n#### **AutoCatBoostClassifier()** GPU Capable\nAutoCatBoostClassifier() utilizes the CatBoost algorithm in the below steps\n\n

Code Example

\n\n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 10000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = TRUE,\n MultiClass = FALSE)\n\n# Run function\nTestModel <- RemixAutoML::AutoCatBoostClassifier(\n \n # GPU or CPU and the number of available GPUs\n task_type = \"GPU\",\n NumGPUs = 1,\n \n # Metadata args\n ModelID = \"Test_Model_1\",\n model_path = normalizePath(\"./\"),\n metadata_path = normalizePath(\"./\"),\n SaveModelObjects = FALSE,\n ReturnModelObjects = TRUE,\n SaveInfoToPDF = FALSE,\n \n # Data args\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\",\"IDcol_2\",\"Adrian\")],\n PrimaryDateColumn = NULL,\n ClassWeights = c(1L,1L),\n IDcols = c(\"IDcol_1\",\"IDcol_2\"),\n \n # Evaluation args\n eval_metric = \"AUC\",\n loss_function = \"Logloss\",\n grid_eval_metric = \"MCC\",\n MetricPeriods = 10L,\n NumOfParDepPlots = ncol(data)-1L-2L,\n \n # Grid tuning args\n PassInGrid = NULL,\n GridTune = TRUE,\n MaxModelsInGrid = 30L,\n MaxRunsWithoutNewWinner = 20L,\n MaxRunMinutes = 24L*60L,\n BaselineComparison = \"default\",\n \n # ML args\n Trees = seq(100L, 500L, 50L),\n Depth = seq(4L, 8L, 1L),\n LearningRate = seq(0.01,0.10,0.01),\n L2_Leaf_Reg = seq(1.0, 10.0, 1.0),\n RandomStrength = 1,\n BorderCount = 128,\n RSM = c(0.80, 0.85, 0.90, 0.95, 1.0),\n BootStrapType = c(\"Bayesian\", \"Bernoulli\", \"Poisson\", \"MVS\", \"No\"),\n GrowPolicy = c(\"SymmetricTree\", \"Depthwise\", \"Lossguide\"),\n langevin = FALSE,\n diffusion_temperature = 10000,\n model_size_reg = 0.5,\n feature_border_type = \"GreedyLogSum\",\n sampling_unit = \"Group\",\n subsample = NULL,\n score_function = \"Cosine\",\n min_data_in_leaf = 1)\n```\n\n

\n\n#### **AutoXGBoostClassifier()** GPU Capable\nAutoXGBoostClassifier() utilizes the XGBoost algorithm in the below steps\n\n

Code Example

\n \n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000L,\n ID = 2L,\n ZIP = 0L,\n AddDate = FALSE,\n Classification = TRUE,\n MultiClass = FALSE)\n\n# Run function\nTestModel <- RemixAutoML::AutoXGBoostClassifier(\n \n # GPU or CPU\n TreeMethod = \"hist\",\n NThreads = parallel::detectCores(),\n \n # Metadata args\n model_path = normalizePath(\"./\"),\n metadata_path = NULL,\n ModelID = \"Test_Model_1\",\n ReturnFactorLevels = TRUE,\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n \n # Data args\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in%\n c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n IDcols = c(\"IDcol_1\",\"IDcol_2\"),\n \n # Model evaluation\n LossFunction = 'reg:logistic',\n eval_metric = \"auc\",\n NumOfParDepPlots = 3L,\n \n # Grid tuning args\n PassInGrid = NULL,\n GridTune = FALSE,\n BaselineComparison = \"default\",\n MaxModelsInGrid = 10L,\n MaxRunsWithoutNewWinner = 20L,\n MaxRunMinutes = 24L*60L,\n Verbose = 1L,\n \n # ML args\n Shuffles = 1L,\n Trees = 50L,\n eta = 0.05,\n max_depth = 4L,\n min_child_weight = 1.0,\n subsample = 0.55,\n colsample_bytree = 0.55)\n```\n \n

\n\n#### **AutoH2oGBMClassifier()**\nAutoH2oGBMClassifier() utilizes the H2O Gradient Boosting algorithm in the below steps\n\n

Code Example

\n\n\n``` \n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000L,\n ID = 2L,\n ZIP = 0L,\n AddDate = FALSE,\n Classification = TRUE,\n MultiClass = FALSE)\n\nTestModel <- RemixAutoML::AutoH2oGBMClassifier(\n \n # Compute management\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1, parallel::detectCores()-2),\n H2OShutdown = TRUE,\n H2OStartUp = TRUE,\n IfSaveModel = \"mojo\",\n \n # Model evaluation\n NumOfParDepPlots = 3,\n \n # Metadata arguments:\n model_path = normalizePath(\"./\"),\n metadata_path = file.path(normalizePath(\"./\")),\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n SaveInfoToPDF = FALSE,\n \n # Data arguments\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n WeightsColumn = NULL,\n \n # ML grid tuning args\n GridTune = FALSE,\n GridStrategy = \"Cartesian\",\n MaxRuntimeSecs = 60*60*24,\n StoppingRounds = 10,\n MaxModelsInGrid = 2,\n \n # Model args\n Trees = 50,\n LearnRate = 0.10,\n LearnRateAnnealing = 1,\n eval_metric = \"auc\",\n Distribution = \"bernoulli\",\n MaxDepth = 20,\n SampleRate = 0.632,\n ColSampleRate = 1,\n ColSampleRatePerTree = 1,\n ColSampleRatePerTreeLevel = 1,\n MinRows = 1,\n NBins = 20,\n NBinsCats = 1024,\n NBinsTopLevel = 1024,\n HistogramType = \"AUTO\",\n CategoricalEncoding = \"AUTO\")\n```\n\n

\n\n#### **AutoH2oDRFClassifier()**\nAutoH2oDRFClassifier() utilizes the H2O Distributed Random Forest algorithm in the below steps\n\n

Code Example

\n \n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000L,\n ID = 2L,\n ZIP = 0L,\n AddDate = FALSE,\n Classification = TRUE,\n MultiClass = FALSE)\n\nTestModel <- RemixAutoML::AutoH2oDRFClassifier(\n \n # Compute management\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1L, parallel::detectCores() - 2L),\n IfSaveModel = \"mojo\",\n H2OShutdown = FALSE,\n H2OStartUp = TRUE,\n \n # Metadata arguments:\n eval_metric = \"auc\",\n NumOfParDepPlots = 3L,\n \n # Data arguments:\n model_path = normalizePath(\"./\"),\n metadata_path = NULL,\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n SaveInfoToPDF = FALSE,\n \n # Model evaluation:\n data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\", \"Adrian\")],\n WeightsColumn = NULL,\n \n # Grid Tuning Args\n GridStrategy = \"Cartesian\",\n GridTune = FALSE,\n MaxModelsInGrid = 10,\n MaxRuntimeSecs = 60*60*24,\n StoppingRounds = 10,\n \n # Model args\n Trees = 50L,\n MaxDepth = 20,\n SampleRate = 0.632,\n MTries = -1,\n ColSampleRatePerTree = 1,\n ColSampleRatePerTreeLevel = 1,\n MinRows = 1,\n NBins = 20,\n NBinsCats = 1024,\n NBinsTopLevel = 1024,\n HistogramType = \"AUTO\",\n CategoricalEncoding = \"AUTO\")\n```\n \n

\n\n#### **AutoH2oGLMClassifier()**\nAutoH2oGLMClassifier() utilizes the H2O generalized linear model algorithm in the below steps\n\n

Code Example

\n \n```\n# Create some dummy correlated data with numeric and categorical features\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000L,\n ID = 2L,\n ZIP = 0L,\n AddDate = FALSE,\n Classification = TRUE,\n MultiClass = FALSE)\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oGLMClassifier(\n \n # Compute management\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1, parallel::detectCores()-2),\n H2OShutdown = TRUE,\n H2OStartUp = TRUE,\n IfSaveModel = \"mojo\",\n \n # Model evaluation args\n eval_metric = \"auc\",\n NumOfParDepPlots = 3,\n \n # Metadata args\n model_path = NULL,\n metadata_path = NULL,\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n SaveInfoToPDF = FALSE,\n \n # Data args\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in%\n c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n RandomColNumbers = NULL,\n InteractionColNumbers = NULL,\n WeightsColumn = NULL,\n TransformNumericColumns = NULL,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\", \"LogPlus1\", \"Sqrt\", \"Logit\", \"YeoJohnson\"),\n \n # ML args\n GridTune = FALSE,\n GridStrategy = \"Cartesian\",\n StoppingRounds = 10,\n MaxRunTimeSecs = 3600 * 24 * 7,\n MaxModelsInGrid = 10,\n Distribution = \"binomial\",\n Link = \"logit\",\n RandomDistribution = NULL,\n RandomLink = NULL,\n Solver = \"AUTO\",\n Alpha = NULL,\n Lambda = NULL,\n LambdaSearch = FALSE,\n NLambdas = -1,\n Standardize = TRUE,\n RemoveCollinearColumns = FALSE,\n InterceptInclude = TRUE,\n NonNegativeCoefficients = FALSE)\n```\n \n

\n\n#### **AutoH2oMLClassifier()**\nAutoH2oMLClassifier() utilizes the H2o AutoML algorithm in the below steps \n\n

Code Example

\n\n#### **AutoH2oGAMClassifier()**\n\n

Code Example

\n \n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = TRUE,\n MultiClass = FALSE)\n\n# Define GAM Columns to use - up to 9 are allowed\nGamCols <- names(which(unlist(lapply(data, is.numeric))))\nGamCols <- GamCols[!GamCols %in% c(\"Adrian\",\"IDcol_1\",\"IDcol_2\")]\nGamCols <- GamCols[1L:(min(9L,length(GamCols)))]\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oGAMClassifier(\n\n # Compute management\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1, parallel::detectCores()-2),\n H2OShutdown = TRUE,\n H2OStartUp = TRUE,\n IfSaveModel = \"mojo\",\n\n # Model evaluation:\n eval_metric = \"auc\",\n NumOfParDepPlots = 3,\n\n # Metadata arguments:\n model_path = NULL,\n metadata_path = NULL,\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n SaveInfoToPDF = FALSE,\n\n # Data arguments:\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n WeightsColumn = NULL,\n GamColNames = GamCols,\n\n # ML args\n num_knots = NULL,\n keep_gam_cols = TRUE,\n GridTune = FALSE,\n GridStrategy = \"Cartesian\",\n StoppingRounds = 10,\n MaxRunTimeSecs = 3600 * 24 * 7,\n MaxModelsInGrid = 10,\n Distribution = \"binomial\",\n Link = \"logit\",\n Solver = \"AUTO\",\n Alpha = NULL,\n Lambda = NULL,\n LambdaSearch = FALSE,\n NLambdas = -1,\n Standardize = TRUE,\n RemoveCollinearColumns = FALSE,\n InterceptInclude = TRUE,\n NonNegativeCoefficients = FALSE)\n```\n \n

\n \n#### The Auto_Classifier() models handle a multitude of tasks. In order:\n1. Convert your data to data.table format for faster processing\n2. Create train, validation, and test data if you didn't supply those directly to the function\n3. Consoldate columns that are used for modeling and what is to be kept for data returned\n4. Dichotomize categorical variables (for AutoXGBoostRegression) and save the factor levels for scoring in a way that guarentees consistency across training, validation, and test data sets\n5. Saves the final column names for modeling to a csv for later reference\n6. Handles the data conversion to the appropriate type, based on model type (CatBoost, H2O, and XGBoost)\n7. Multi-armed bandit hyperparameter tuning using randomized probability matching, if you choose to grid tune\n8. Build the grid tuned models\n9. Collect the evaluation metrics for each grid tune run\n10. Identify the best model of the set of models built in the grid tuning setup\n11. Save the hyperparameters from the winning grid tuned model\n12. Build the final model based on the best model from the grid tuning model search\n13. Collect evaluation metrics based on performance on test data\n14. Store the final predictions with the associated test data and other columns you want included in that set\n15. Build out and save an Evaluation Calibration Line Plot\n16. Build out and save an ROC plot with the top 5 models used in grid-tuning (includes the winning model)\n17. Generate and save Variable Importance data\n18. Generate and save Partital Dependence Calibration Line Plots\n19. Return all the objects generated in a named list for immediate use\n\n

\n\n#### Multinomial Classification\n\n

click to expand

\n \n#### **AutoCatBoostMultiClass()** GPU Capable\nAutoCatBoostMultiClass() utilizes the CatBoost algorithm in the below steps\n\n

Code Example

\n\n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 10000L,\n ID = 2L,\n ZIP = 0L,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = TRUE)\n\n# Run function\nTestModel <- RemixAutoML::AutoCatBoostMultiClass(\n \n # GPU or CPU and the number of available GPUs\n task_type = \"GPU\",\n NumGPUs = 1,\n \n # Metadata args\n ModelID = \"Test_Model_1\",\n model_path = normalizePath(\"./\"),\n metadata_path = normalizePath(\"./\"),\n SaveModelObjects = FALSE,\n ReturnModelObjects = TRUE,\n \n # Data args\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n PrimaryDateColumn = NULL,\n ClassWeights = c(1L,1L,1L,1L,1L),\n IDcols = c(\"IDcol_1\",\"IDcol_2\"),\n \n # Model evaluation\n eval_metric = \"MCC\",\n loss_function = \"MultiClassOneVsAll\",\n grid_eval_metric = \"Accuracy\",\n MetricPeriods = 10L,\n \n # Grid tuning args\n PassInGrid = NULL,\n GridTune = TRUE,\n MaxModelsInGrid = 30L,\n MaxRunsWithoutNewWinner = 20L,\n MaxRunMinutes = 24L*60L,\n BaselineComparison = \"default\",\n \n # ML args\n Depth = seq(4L, 8L, 1L),\n LearningRate = seq(0.01,0.10,0.01),\n L2_Leaf_Reg = seq(1.0, 10.0, 1.0),\n RandomStrength = 1,\n BorderCount = 254,\n RSM = c(0.80, 0.85, 0.90, 0.95, 1.0),\n BootStrapType = c(\"Bayesian\", \"Bernoulli\", \"Poisson\", \"MVS\", \"No\"),\n GrowPolicy = c(\"SymmetricTree\", \"Depthwise\", \"Lossguide\"),\n langevin = FALSE,\n diffusion_temperature = 10000,\n Trees = seq(100L, 500L, 50L),\n model_size_reg = 0.5,\n feature_border_type = \"GreedyLogSum\",\n sampling_unit = \"Group\",\n subsample = NULL,\n score_function = \"Cosine\",\n min_data_in_leaf = 1)\n```\n\n

\n\n#### **AutoXGBoostMultiClass()** GPU Capable\nAutoXGBoostMultiClass() utilizes the XGBoost algorithm in the below steps\n\n

Code Example

\n\n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000L,\n ID = 2L,\n ZIP = 0L,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = TRUE)\n\n# Run function\nTestModel <- RemixAutoML::AutoXGBoostMultiClass(\n \n # GPU or CPU\n TreeMethod = \"hist\",\n NThreads = parallel::detectCores(),\n \n # Metadata args\n model_path = normalizePath(\"./\"),\n metadata_path = normalizePath(\"./\"),\n ModelID = \"Test_Model_1\",\n ReturnFactorLevels = TRUE,\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n \n # Data args\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n IDcols = c(\"IDcol_1\",\"IDcol_2\"),\n \n # Model evaluation args\n eval_metric = \"merror\",\n LossFunction = 'multi:softmax',\n grid_eval_metric = \"accuracy\",\n NumOfParDepPlots = 3L,\n \n # Grid tuning args\n PassInGrid = NULL,\n GridTune = FALSE,\n BaselineComparison = \"default\",\n MaxModelsInGrid = 10L,\n MaxRunsWithoutNewWinner = 20L,\n MaxRunMinutes = 24L*60L,\n Verbose = 1L,\n \n # ML args\n Shuffles = 1L,\n Trees = 50L,\n eta = 0.05,\n max_depth = 4L,\n min_child_weight = 1.0,\n subsample = 0.55,\n colsample_bytree = 0.55)\n```\n\n

\n\n#### **AutoH2oGBMMultiClass()**\nAutoH2oGBMMultiClass() utilizes the H2O Gradient Boosting algorithm in the below steps\n\n

Code Example

\n\n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = TRUE)\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oGBMMultiClass(\n data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n WeightsColumn = NULL,\n eval_metric = \"logloss\",\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1, parallel::detectCores()-2),\n model_path = normalizePath(\"./\"),\n metadata_path = file.path(normalizePath(\"./\")),\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n IfSaveModel = \"mojo\",\n H2OShutdown = TRUE,\n H2OStartUp = TRUE,\n\n # Model args\n GridTune = FALSE,\n GridStrategy = \"Cartesian\",\n MaxRuntimeSecs = 60*60*24,\n StoppingRounds = 10,\n MaxModelsInGrid = 2,\n Trees = 50,\n LearnRate = 0.10,\n LearnRateAnnealing = 1,\n eval_metric = \"RMSE\",\n Distribution = \"multinomial\",\n MaxDepth = 20,\n SampleRate = 0.632,\n ColSampleRate = 1,\n ColSampleRatePerTree = 1,\n ColSampleRatePerTreeLevel = 1,\n MinRows = 1,\n NBins = 20,\n NBinsCats = 1024,\n NBinsTopLevel = 1024,\n HistogramType = \"AUTO\",\n CategoricalEncoding = \"AUTO\")\n```\n\n

\n\n#### **AutoH2oDRFMultiClass()**\nAutoH2oDRFMultiClass() utilizes the H2O Distributed Random Forest algorithm in the below steps\n\n

Code Example

\n\n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000L,\n ID = 2L,\n ZIP = 0L,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = TRUE)\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oDRFMultiClass(\n data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n WeightsColumn = NULL,\n eval_metric = \"logloss\",\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1, parallel::detectCores()-2),\n model_path = normalizePath(\"./\"),\n metadata_path = file.path(normalizePath(\"./\")),\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n IfSaveModel = \"mojo\",\n H2OShutdown = FALSE,\n H2OStartUp = TRUE,\n\n # Grid Tuning Args\n GridStrategy = \"Cartesian\",\n GridTune = FALSE,\n MaxModelsInGrid = 10,\n MaxRuntimeSecs = 60*60*24,\n StoppingRounds = 10,\n\n # ML args\n Trees = 50,\n MaxDepth = 20,\n SampleRate = 0.632,\n MTries = -1,\n ColSampleRatePerTree = 1,\n ColSampleRatePerTreeLevel = 1,\n MinRows = 1,\n NBins = 20,\n NBinsCats = 1024,\n NBinsTopLevel = 1024,\n HistogramType = \"AUTO\",\n CategoricalEncoding = \"AUTO\")\n```\n\n

\n\n#### **AutoH2oGLMMultiClass()**\nAutoH2oGLMMultiClass() utilizes the H2O generalized linear model algorithm in the below steps\n\n

Code Example

\n\n```\n# Create some dummy correlated data with numeric and categorical features\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000L,\n ID = 2L,\n ZIP = 0L,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = TRUE)\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oGLMMultiClass(\n \n # Compute management\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1, parallel::detectCores()-2),\n H2OShutdown = TRUE,\n H2OStartUp = TRUE,\n IfSaveModel = \"mojo\",\n \n # Model evaluation:\n eval_metric = \"logloss\",\n NumOfParDepPlots = 3,\n \n # Metadata arguments:\n model_path = NULL,\n metadata_path = NULL,\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n SaveInfoToPDF = FALSE,\n \n # Data arguments:\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n RandomColNumbers = NULL,\n InteractionColNumbers = NULL,\n WeightsColumn = NULL,\n TransformNumericColumns = NULL,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\", \"LogPlus1\", \"Sqrt\", \"Logit\", \"YeoJohnson\"),\n \n # Model args\n GridTune = FALSE,\n GridStrategy = \"Cartesian\",\n StoppingRounds = 10,\n MaxRunTimeSecs = 3600 * 24 * 7,\n MaxModelsInGrid = 10,\n Distribution = \"multinomial\",\n Link = \"family_default\",\n RandomDistribution = NULL,\n RandomLink = NULL,\n Solver = \"AUTO\",\n Alpha = NULL,\n Lambda = NULL,\n LambdaSearch = FALSE,\n NLambdas = -1,\n Standardize = TRUE,\n RemoveCollinearColumns = FALSE,\n InterceptInclude = TRUE,\n NonNegativeCoefficients = FALSE)\n```\n\n

\n\n#### **AutoH2oMLMultiClass()**\nAutoH2oMLMultiClass() utilizes the H2o AutoML algorithm in the below steps\n\n

Code Example

\n\n```\n# Create some dummy correlated data with numeric and categorical features\ndata <- RemixAutoML::FakeDataGenerator(Correlation = 0.85, N = 1000, ID = 2, ZIP = 0, AddDate = FALSE, Classification = FALSE, MultiClass = TRUE)\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oMLMultiClass(\n data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n ExcludeAlgos = NULL,\n eval_metric = \"logloss\",\n Trees = 50,\n MaxMem = \"32G\",\n NThreads = max(1, parallel::detectCores()-2),\n MaxModelsInGrid = 10,\n model_path = normalizePath(\"./\"),\n metadata_path = file.path(normalizePath(\"./\"), \"MetaData\"),\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n IfSaveModel = \"mojo\",\n H2OShutdown = FALSE,\n HurdleModel = FALSE)\n```\n\n

\n\n#### **AutoH2oGAMMultiClass()**\n\n

Code Example

\n\n```\n# Create some dummy correlated data with numeric and categorical features\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 1000L,\n ID = 2L,\n ZIP = 0L,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = TRUE)\n\n# Define GAM Columns to use - up to 9 are allowed\nGamCols <- names(which(unlist(lapply(data, is.numeric))))\nGamCols <- GamCols[!GamCols %in% c(\"Adrian\",\"IDcol_1\",\"IDcol_2\")]\nGamCols <- GamCols[1L:(min(9L,length(GamCols)))]\n\n# Run function\nTestModel <- RemixAutoML::AutoH2oGAMMultiClass(\n data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n TargetColumnName = \"Adrian\",\n FeatureColNames = names(data)[!names(data) %in% c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n WeightsColumn = NULL,\n GamColNames = GamCols,\n eval_metric = \"logloss\",\n MaxMem = {gc();paste0(as.character(floor(as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) / 1000000)),\"G\")},\n NThreads = max(1, parallel::detectCores()-2),\n model_path = normalizePath(\"./\"),\n metadata_path = NULL,\n ModelID = \"FirstModel\",\n ReturnModelObjects = TRUE,\n SaveModelObjects = FALSE,\n IfSaveModel = \"mojo\",\n H2OShutdown = FALSE,\n H2OStartUp = TRUE,\n \n # ML args\n num_knots = NULL,\n keep_gam_cols = TRUE,\n GridTune = FALSE,\n GridStrategy = \"Cartesian\",\n StoppingRounds = 10,\n MaxRunTimeSecs = 3600 * 24 * 7,\n MaxModelsInGrid = 10,\n Distribution = \"multinomial\",\n Link = \"Family_Default\",\n Solver = \"AUTO\",\n Alpha = NULL,\n Lambda = NULL,\n LambdaSearch = FALSE,\n NLambdas = -1,\n Standardize = TRUE,\n RemoveCollinearColumns = FALSE,\n InterceptInclude = TRUE,\n NonNegativeCoefficients = FALSE)\n```\n\n

\n \n#### The Auto_MultiClass() models handle a multitude of tasks. In order:\n1. Convert your data to data.table format for faster processing\n2. Create train, validation, and test data if you didn't supply those directly to the function\n3. Consoldate columns that are used for modeling and what is to be kept for data returned\n4. Dichotomize categorical variables (for AutoXGBoostRegression) and save the factor levels for scoring in a way that guarentees consistency across training, validation, and test data sets\n5. Saves the final column names for modeling to a csv for later reference\n6. Ensures the target levels are consistent across train, validate, and test sets and save the levels to file\n7. Handles the data conversion to the appropriate type, based on model type (CatBoost, H2O, and XGBoost)\n8. Multi-armed bandit hyperparameter tuning using randomized probability matching, if you choose to grid tune\n9. Build the grid tuned models\n10. Collect the evaluation metrics for each grid tune run\n11. Identify the best model of the set of models built in the grid tuning setup\n12. Save the hyperparameters from the winning grid tuned model\n13. Build the final model based on the best model from the grid tuning model search\n14. Collect evaluation metrics based on performance on test data\n15. Store the final predictions with the associated test data and other columns you want included in that set\n16. Generate and save Variable Importance data\n17. Return all the objects generated in a named list for immediate use\n\n

\n\n#### Generalized Hurdle Models\n\n

click to expand

\n \nFirst step is to build either a binary classification model (in the case of a single bucket value, such as zero) or a multiclass model (for the case of multiple bucket values, such as zero and 10). The next step is to subset the data for the cases of: less than the first split value, in between the first and second split value, second and third split value, ..., second to last and last split value, along with greater than last split value. For each data subset, a regression model is built for predicting values in the split value ranges. The final compilation is to multiply the probabilities of being in each group times the values supplied by the regression values for each group.\n\n###### Single Partition\n* E(y|x_i) = Pr(X = 0) * 0 + Pr(X > 0) * E(X | X >= 0) \n* E(y|x_i) = Pr(X < x₁) * E(X | X < x₁) + Pr(X >= x₁) * E(X | X >= x₁)\n\n###### Multiple Partitions\n* E(y|x_i) = Pr(X = 0) * 0 + Pr(X < x₂) * E(X | X < x₂) + ... + Pr(X < x_n) * E(X | X < x_n) + Pr(X >= x_n) * E(X | X >= x_n)\n* E(y|x_i) = Pr(X < x₁) * E(X | X < x₁) + Pr(x₁ <= X < x₂) * E(X | x₁ <= X < x₂) + ... + Pr(x_n-1 <= X < x_n) * E(X | x_n-1 <= X < x_n) + Pr(X >= x_n) * E(X | X >= x_n)\n \n#### **AutoCatBoostHurdleModel()**\nAutoCatBoostHurdleModel() utilizes the CatBoost algorithm on the backend. \n\n#### **AutoXGBoostHurdleModel()**\nAutoXGBoostHurdleModel() utilizes the XGBoost algorithm on the backend. \n\n#### **AutoH2oDRFHurdleModel()**\nAutoH2oDRFHurdleModel() utilizes the H2O distributed random forest algorithm on the backend. \n\n#### **AutoH2oGBMHurdleModel()**\nAutoH2oGBMHurdleModel() utilizes the H2O gradient boosting machine algorithm on the backend. \n\n

\n\n#### Nonlinear Regression Modeling\n\n

click to expand

\n \n#### **AutoNLS()**\n\n\n\nAutoNLS() is an automated nonlinear regression modeling function. This function automatically finds the best model fit from the set of models listed below and merges predictions to source data file. Great for forecasting growth (extrapolation) when domain knowledge can guide model selection.\n* Models included:\n * Asymptotic\n * Asymptotic through origin\n * Asymptotic with offset\n * Bi-exponential\n * Four parameter logistic\n * Three parameter logistic\n * Gompertz\n * Michal Menton\n * Weibull\n * Polynomial regression or monotonic regression\n \n

\n\n

\n\n## Model Scoring

Expand to view content

\n\n

Code Example

\n\n```\n# Create some dummy correlated data\ndata <- RemixAutoML::FakeDataGenerator(\n Correlation = 0.85,\n N = 10000,\n ID = 2,\n ZIP = 0,\n AddDate = FALSE,\n Classification = FALSE,\n MultiClass = FALSE)\n\n# Train a Multiple Regression Model (two target variables)\nTestModel <- RemixAutoML::AutoCatBoostRegression(\n\n # GPU or CPU and the number of available GPUs\n task_type = \"GPU\",\n NumGPUs = 1,\n\n # Metadata arguments\n ModelID = \"Test_Model_1\",\n model_path = normalizePath(\"./\"),\n metadata_path = NULL,\n SaveModelObjects = FALSE,\n ReturnModelObjects = TRUE,\n\n # Data arguments\n data = data,\n TrainOnFull = FALSE,\n ValidationData = NULL,\n TestData = NULL,\n Weights = NULL,\n DummifyCols = FALSE,\n TargetColumnName = c(\"Adrian\",\"Independent_Variable1\"),\n FeatureColNames = names(data)[!names(data) %in%\n c(\"IDcol_1\",\"IDcol_2\",\"Adrian\")],\n PrimaryDateColumn = NULL,\n IDcols = c(\"IDcol_1\",\"IDcol_2\"),\n TransformNumericColumns = NULL,\n Methods = c(\"BoxCox\",\"Asinh\",\"Asin\",\"Log\",\"LogPlus1\",\n \"Logit\",\"YeoJohnson\"),\n\n # Model evaluation\n eval_metric = \"MultiRMSE\",\n eval_metric_value = 1.5,\n loss_function = \"MultiRMSE\",\n loss_function_value = 1.5,\n MetricPeriods = 10L,\n NumOfParDepPlots = ncol(data)-1L-2L,\n EvalPlots = TRUE,\n\n # Grid tuning\n PassInGrid = NULL,\n GridTune = FALSE,\n MaxModelsInGrid = 100L,\n MaxRunsWithoutNewWinner = 100L,\n MaxRunMinutes = 60*60,\n Shuffles = 4L,\n BaselineComparison = \"default\",\n\n # ML Args\n langevin = TRUE,\n diffusion_temperature = 10000,\n Trees = 250,\n Depth = 6,\n L2_Leaf_Reg = 3.0,\n RandomStrength = 1,\n BorderCount = 128,\n LearningRate = seq(0.01,0.10,0.01),\n RSM = c(0.80, 0.85, 0.90, 0.95, 1.0),\n BootStrapType = c(\"Bayesian\",\"Bernoulli\",\"Poisson\",\"MVS\",\"No\"),\n GrowPolicy = c(\"SymmetricTree\", \"Depthwise\", \"Lossguide\"))\n\n# Output\nTestModel$Model\nTestModel$ValidationData\nTestModel$EvaluationPlot\nTestModel$EvaluationBoxPlot\nTestModel$EvaluationMetrics\nTestModel$VariableImportance\nTestModel$InteractionImportance\nTestModel$ShapValuesDT\nTestModel$VI_Plot\nTestModel$PartialDependencePlots\nTestModel$PartialDependenceBoxPlots\nTestModel$GridList\nTestModel$ColNames\nTestModel$TransformationResults\n\n# Score a multiple regression model\nPreds <- RemixAutoML::AutoCatBoostScoring(\n TargetType = \"multiregression\",\n ScoringData = data,\n FeatureColumnNames = names(data)[!names(data) %in%\n c(\"IDcol_1\", \"IDcol_2\",\"Adrian\")],\n FactorLevelsList = TestModel$FactorLevelsList,\n IDcols = c(\"IDcol_1\",\"IDcol_2\"),\n OneHot = FALSE,\n ReturnShapValues = TRUE,\n ModelObject = TestModel$Model,\n ModelPath = NULL, #normalizePath(\"./\"),\n ModelID = \"Test_Model_1\",\n ReturnFeatures = TRUE,\n MultiClassTargetLevels = NULL,\n TransformNumeric = FALSE,\n BackTransNumeric = FALSE,\n TargetColumnName = NULL,\n TransformationObject = NULL,\n TransID = NULL,\n TransPath = NULL,\n MDP_Impute = TRUE,\n MDP_CharToFactor = TRUE,\n MDP_RemoveDates = TRUE,\n MDP_MissFactor = \"0\",\n MDP_MissNum = -1,\n RemoveModel = FALSE)\n```\n\n

\n\n\n#### **AutoCatBoostScoring()**\nAutoCatBoostScoring() is an automated scoring function that compliments the AutoCatBoost() model training functions. This function requires you to supply features for scoring. It will run ModelDataPrep() to prepare your features for catboost data conversion and scoring. It will also handle and transformations and back-transformations if you utilized that feature in the regression training case.\n\n#### **AutoXGBoostScoring()**\nAutoXGBoostScoring() is an automated scoring function that compliments the AutoXGBoost() model training functions. This function requires you to supply features for scoring. It will run ModelDataPrep() and the DummifyDT() functions to prepare your features for xgboost data conversion and scoring. It will also handle and transformations and back-transformations if you utilized that feature in the regression training case.\n\n#### **AutoH2OMLScoring()**\nAutoH2OMLScoring() is an automated scoring function that compliments the AutoH2oGBM__() and AutoH2oDRF__() model training functions. This function requires you to supply features for scoring. It will run ModelDataPrep()to prepare your features for H2O data conversion and scoring. It will also handle transformations and back-transformations if you utilized that feature in the regression training case and didn't do it yourself before hand.\n\n#### **AutoHurdleScoring()**\nAutoHurdleScoring() will score the AutoCatBoostHurdleModel() function currently. Functionality for XGBoost hurdle models will be next, followed by the H2O version.\n\n\n

\n\n## Model Evaluation

Expand to view content

\n \n#### **RemixClassificationMetrics()**\nRemixClassificationMetrics() will return all confusion matrix metrics across all possible thresholds (seq(0.01,0.99,0.01) for any Remix Auto_Classification() model. Cost sensitive thresholds are also returned.\n\n#### **ParDepCalPlots()**\nParDepCalPlots() is for visualizing the relationships of features and the reliability of the model in predicting those effects. Build a partial dependence calibration line plot, box plot or bar plot for the case of categorical variables.\n\n\n\n![ParDepCalPlots Blog](https://www.remixinstitute.com/blog/companies-are-demanding-model-interpretability-heres-how-to-do-it-right/#.XUIN1HtlCDM)\n\n#### **EvalPlot()**\nEvalPlot() Has two plot versions: calibration line plot of predicted values and actual values across range of predicted value, and calibration boxplot for seeing the accuracy and variability of predictions against actuals. \n\n\n\n#### **threshOptim()**\nthreshOptim() is great for situations with asymmetric costs across the confusion matrix. Generate a cost-sensitive optimized threshold for classification models. Just supply the costs for false positives and false negatives (can supply costs for all four outcomes too) and the function will return the optimal threshold for maximizing \"utility\". \n\n#### **RedYellowGreen()**\nRedYellowGreen() computes optimal thresholds for binary classification models where \"don't classify\" is an option. Consider a health care binary classification model that predicts whether or not a disease is present. This is certainly a case for threshOptim since the costs of false positives and false negatives can vary by a large margin. However, there is always the potential to run further analysis. The RedYellowGreen() function can compute two thresholds if you can supply a cost of \"further analysis\". Predicted values < the lower threshold are confidently classified as a negative case and predicted values > the upper threshold are confidently classified as a postive case. Predicted values in between the lower and upper thresholds are cases that should require further analysis.\n\n\n\n![RedYellowGreen Blog](https://www.remixinstitute.com/blog/the-easiest-way-to-create-thresholds-and-improve-your-classification-model/#.XUINVntlCDM)\n\n

\n\n## Panel Data Forecasting

Expand to view content

\n \n\n

Code Example: AutoCatBoostCARMA()

\n \n```\n\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n# Out-of-Sample Feature + Grid Tuning of RemixAutoML::AutoCatBoostCARMA()\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n# Set up your output file path for saving results as a .csv\nPath <- \"C:/YourPathHere\"\n\n# Run on GPU or CPU (some options in the grid tuning force usage of CPU for some runs)\nTaskType = \"GPU\"\n\n# Define number of CPU threads to allow data.table to utilize\ndata.table::setDTthreads(percent = max(1L, parallel::detectCores()-2L))\n\n# Load data\ndata <- data <- data.table::fread(\"https://www.dropbox.com/s/2str3ek4f4cheqi/walmart_train.csv?dl=1\")\n\n# Ensure series have no missing dates (also remove series with more than 25% missing values)\ndata <- RemixAutoML::TimeSeriesFill(\n data,\n DateColumnName = \"Date\",\n GroupVariables = c(\"Store\",\"Dept\"),\n TimeUnit = \"weeks\",\n FillType = \"maxmax\",\n MaxMissingPercent = 0.25,\n SimpleImpute = TRUE)\n\n# Set negative numbers to 0\ndata <- data[, Weekly_Sales := data.table::fifelse(Weekly_Sales < 0, 0, Weekly_Sales)]\n\n# Remove IsHoliday column\ndata[, IsHoliday := NULL]\n\n# Create xregs (this is the include the categorical variables instead of utilizing only the interaction of them)\nxregs <- data[, .SD, .SDcols = c(\"Date\", \"Store\", \"Dept\")]\n\n# Change data types\ndata[, \":=\" (Store = as.character(Store), Dept = as.character(Dept))]\nxregs[, \":=\" (Store = as.character(Store), Dept = as.character(Dept))]\n\n# Subset data so we have an out of time sample\ndata1 <- data.table::copy(data[, ID := 1L:.N, by = c(\"Store\",\"Dept\")][ID <= 125L][, ID := NULL])\ndata[, ID := NULL]\n\n# Define values for SplitRatios and FCWindow Args\nN1 <- data1[, .N, by = c(\"Store\",\"Dept\")][1L, N]\nN2 <- xregs[, .N, by = c(\"Store\",\"Dept\")][1L, N]\n\n# Setup Grid Tuning & Feature Tuning data.table using a cross join of vectors\nTuning <- data.table::CJ(\n TimeWeights = c(\"None\",0.999),\n MaxTimeGroups = c(\"weeks\",\"months\"),\n TargetTransformation = c(\"TRUE\",\"FALSE\"),\n Difference = c(\"TRUE\",\"FALSE\"),\n HoldoutTrain = c(6,18),\n Langevin = c(\"TRUE\",\"FALSE\"),\n NTrees = c(2500,5000),\n Depth = c(6,9),\n RandomStrength = c(0.75,1),\n L2_Leaf_Reg = c(3.0,4.0),\n RSM = c(0.75,\"NULL\"),\n GrowPolicy = c(\"SymmetricTree\",\"Lossguide\",\"Depthwise\"),\n BootStrapType = c(\"Bayesian\",\"MVS\",\"No\"))\n\n# Remove options that are not compatible with GPU (skip over this otherwise)\nTuning <- Tuning[Langevin == \"TRUE\" | (Langevin == \"FALSE\" & RSM == \"NULL\" & BootStrapType %in% c(\"Bayesian\",\"No\"))]\n\n# Randomize order of Tuning data.table\nTuning <- Tuning[order(runif(.N))]\n\n# Load grid results and remove rows that have already been tested\nif(file.exists(file.path(Path, \"Walmart_CARMA_Metrics.csv\"))) {\n Metrics <- data.table::fread(file.path(Path, \"Walmart_CARMA_Metrics.csv\"))\n temp <- data.table::rbindlist(list(Metrics,Tuning), fill = TRUE)\n temp <- unique(temp, by = c(4:(ncol(temp)-1)))\n Tuning <- temp[is.na(RunTime)][, .SD, .SDcols = names(Tuning)]\n rm(Metrics,temp)\n}\n\n# Define the total number of runs\nTotalRuns <- Tuning[,.N]\n\n# Kick off feature + grid tuning\nfor(Run in seq_len(TotalRuns)) {\n\n # Print run number\n for(zz in seq_len(100)) print(Run)\n\n # Use fresh data for each run\n xregs_new <- data.table::copy(xregs)\n data_new <- data.table::copy(data1)\n\n # Timer start\n StartTime <- Sys.time()\n\n # Run carma system\n CatBoostResults <- RemixAutoML::AutoCatBoostCARMA(\n\n # data args\n data = data_new,\n TimeWeights = if(Tuning[Run, TimeWeights] == \"None\") NULL else as.numeric(Tuning[Run, TimeWeights]),\n TargetColumnName = \"Weekly_Sales\",\n DateColumnName = \"Date\",\n HierarchGroups = NULL,\n GroupVariables = c(\"Store\",\"Dept\"),\n TimeUnit = \"weeks\",\n TimeGroups = if(Tuning[Run, MaxTimeGroups] == \"weeks\") \"weeks\" else if(Tuning[Run, MaxTimeGroups] == \"months\") c(\"weeks\",\"months\") else c(\"weeks\",\"months\",\"quarters\"),\n\n # Production args\n TrainOnFull = TRUE,\n SplitRatios = c(1 - Tuning[Run, HoldoutTrain] / N2, Tuning[Run, HoldoutTrain] / N2),\n PartitionType = \"random\",\n FC_Periods = N2-N1,\n TaskType = TaskType,\n NumGPU = 1,\n Timer = TRUE,\n DebugMode = TRUE,\n\n # Target variable transformations\n TargetTransformation = as.logical(Tuning[Run, TargetTransformation]),\n Methods = c(\"BoxCox\",\"Asinh\",\"Log\",\"LogPlus1\",\"YeoJohnson\"),\n Difference = as.logical(Tuning[Run, Difference]),\n NonNegativePred = TRUE,\n RoundPreds = FALSE,\n\n # Calendar-related features\n CalendarVariables = c(\"week\",\"wom\",\"month\",\"quarter\"),\n HolidayVariable = c(\"USPublicHolidays\"),\n HolidayLookback = NULL,\n HolidayLags = c(1,2,3),\n HolidayMovingAverages = c(2,3),\n\n # Lags, moving averages, and other rolling stats\n Lags = if(Tuning[Run, MaxTimeGroups] == \"weeks\") c(1,2,3,4,5,8,9,12,13,51,52,53) else if(Tuning[Run, MaxTimeGroups] == \"months\") list(\"weeks\" = c(1,2,3,4,5,8,9,12,13,51,52,53), \"months\" = c(1,2,6,12)) else list(\"weeks\" = c(1,2,3,4,5,8,9,12,13,51,52,53), \"months\" = c(1,2,6,12), \"quarters\" = c(1,2,3,4)),\n MA_Periods = if(Tuning[Run, MaxTimeGroups] == \"weeks\") c(2,3,4,5,8,9,12,13,51,52,53) else if(Tuning[Run, MaxTimeGroups] == \"months\") list(\"weeks\" = c(2,3,4,5,8,9,12,13,51,52,53), \"months\" = c(2,6,12)) else list(\"weeks\" = c(2,3,4,5,8,9,12,13,51,52,53), \"months\" = c(2,6,12), \"quarters\" = c(2,3,4)),\n SD_Periods = NULL,\n Skew_Periods = NULL,\n Kurt_Periods = NULL,\n Quantile_Periods = NULL,\n Quantiles_Selected = NULL,\n\n # Bonus features\n AnomalyDetection = NULL,\n XREGS = xregs_new,\n FourierTerms = 0,\n TimeTrendVariable = TRUE,\n ZeroPadSeries = NULL,\n DataTruncate = FALSE,\n\n # ML grid tuning args\n GridTune = FALSE,\n PassInGrid = NULL,\n ModelCount = 5,\n MaxRunsWithoutNewWinner = 50,\n MaxRunMinutes = 60*60,\n\n # ML evaluation output\n PDFOutputPath = NULL,\n SaveDataPath = NULL,\n NumOfParDepPlots = 0L,\n\n # ML loss functions\n EvalMetric = \"RMSE\",\n EvalMetricValue = 1,\n LossFunction = \"RMSE\",\n LossFunctionValue = 1,\n\n # ML tuning args\n NTrees = Tuning[Run, NTrees],\n Depth = Tuning[Run, Depth],\n L2_Leaf_Reg = Tuning[Run, L2_Leaf_Reg],\n LearningRate = 0.03,\n Langevin = as.logical(Tuning[Run, Langevin]),\n DiffusionTemperature = 10000,\n RandomStrength = Tuning[Run, RandomStrength],\n BorderCount = 254,\n RSM = if(Tuning[Run, RSM] == \"NULL\") NULL else as.numeric(Tuning[Run, RSM]),\n GrowPolicy = Tuning[Run, GrowPolicy],\n BootStrapType = Tuning[Run, BootStrapType],\n ModelSizeReg = 0.5,\n FeatureBorderType = \"GreedyLogSum\",\n SamplingUnit = \"Group\",\n SubSample = NULL,\n ScoreFunction = \"Cosine\",\n MinDataInLeaf = 1)\n\n # Timer End\n EndTime <- Sys.time()\n\n # Prepare data for evaluation\n Results <- CatBoostResults$Forecast\n data.table::setnames(Results, \"Weekly_Sales\", \"bla\")\n Results <- merge(Results, data, by = c(\"Store\",\"Dept\",\"Date\"), all = FALSE)\n Results <- Results[is.na(bla)][, bla := NULL]\n\n # Create totals and subtotals\n Results <- data.table::groupingsets(\n x = Results,\n j = list(Predictions = sum(Predictions), Weekly_Sales = sum(Weekly_Sales)),\n by = c(\"Date\", \"Store\", \"Dept\"),\n sets = list(c(\"Date\", \"Store\", \"Dept\"), c(\"Store\", \"Dept\"), \"Store\", \"Dept\", \"Date\"))\n \n # Fill NAs with \"Total\" for totals and subtotals\n for(cols in c(\"Store\",\"Dept\")) Results[, eval(cols) := data.table::fifelse(is.na(get(cols)), \"Total\", get(cols))]\n\n # Add error measures\n Results[, Weekly_MAE := abs(Weekly_Sales - Predictions)]\n Results[, Weekly_MAPE := Weekly_MAE / Weekly_Sales]\n\n # Weekly results\n Weekly_MAPE <- Results[, list(Weekly_MAPE = mean(Weekly_MAPE)), by = list(Store,Dept)]\n\n # Monthly results\n temp <- data.table::copy(Results)\n temp <- temp[, Date := lubridate::floor_date(Date, unit = \"months\")]\n temp <- temp[, lapply(.SD, sum), by = c(\"Date\",\"Store\",\"Dept\"), .SDcols = c(\"Predictions\", \"Weekly_Sales\")]\n temp[, Monthly_MAE := abs(Weekly_Sales - Predictions)]\n temp[, Monthly_MAPE := Monthly_MAE / Weekly_Sales]\n Monthly_MAPE <- temp[, list(Monthly_MAPE = mean(Monthly_MAPE)), by = list(Store,Dept)]\n\n # Collect metrics for Total (feel free to switch to something else or no filter at all)\n Metrics <- data.table::data.table(\n RunNumber = Run,\n Total_Weekly_MAPE = Weekly_MAPE[Store == \"Total\" & Dept == \"Total\", Weekly_MAPE],\n Total_Monthly_MAPE = Monthly_MAPE[Store == \"Total\" & Dept == \"Total\", Monthly_MAPE],\n Tuning[Run],\n RunTime = EndTime - StartTime)\n\n # Append to file (not overwrite)\n data.table::fwrite(Metrics, file = file.path(Path, \"Walmart_CARMA_Metrics.csv\"), append = TRUE)\n \n # Remove objects (clear space before new runs)\n rm(CatBoostResults, Results, temp, Weekly_MAE, Weekly_MAPE, Monthly_MAE, Monthly_MAPE)\n\n # Garbage collection because of GPU\n gc()\n}\n```\n\n

\n\n

Code Example: AutoCatBoostVectorCARMA()

\n\n \n```\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n# ML-Based Vector AutoRegression CARMA ----\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n# Load Walmart Data from Dropbox----\ndata <- data.table::fread(\n \"https://www.dropbox.com/s/2str3ek4f4cheqi/walmart_train.csv?dl=1\")\n\n# Filter out zeros\ndata <- data[Weekly_Sales != 0]\n\n# Subset for Stores / Departments With Full Series\ndata <- data[, Counts := .N, by = c(\"Store\",\"Dept\")][Counts == 143][\n , Counts := NULL]\n\n# Subset Columns (remove IsHoliday column)----\nkeep <- c(\"Store\",\"Dept\",\"Date\",\"Weekly_Sales\")\ndata <- data[, ..keep]\ndata <- data[Store %in% c(1,2)]\nxregs <- data.table::copy(data)\nxregs[, GroupVar := do.call(paste, c(.SD, sep = \" \")), .SDcols = c(\"Store\",\"Dept\")]\nxregs[, c(\"Store\",\"Dept\") := NULL]\ndata.table::setnames(xregs, \"Weekly_Sales\", \"Other\")\nxregs[, Other := jitter(Other, factor = 25)]\ndata <- data[as.Date(Date) < as.Date('2012-09-28')]\n\n# Vector CARMA testingdata[, Weekly_Profit := Weekly_Sales * 0.75]\n\n# Build forecast\nCatBoostResults <- RemixAutoML::AutoCatBoostVectorCARMA(\n\n # data args\n data = data, # TwoGroup_Data,\n TimeWeights = NULL,\n TargetColumnName = c(\"Weekly_Sales\",\"Weekly_Profit\"),\n DateColumnName = \"Date\",\n HierarchGroups = NULL,\n GroupVariables = c(\"Store\",\"Dept\"),\n TimeUnit = \"weeks\",\n TimeGroups = c(\"weeks\",\"months\"),\n\n # Production args\n TrainOnFull = TRUE,\n SplitRatios = c(1 - 10 / 138, 10 / 138),\n PartitionType = \"random\",\n FC_Periods = 4,\n Timer = TRUE,\n DebugMode = TRUE,\n\n # Target transformations\n TargetTransformation = TRUE,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\",\n \"LogPlus1\", \"Logit\", \"YeoJohnson\"),\n Difference = FALSE,\n NonNegativePred = FALSE,\n RoundPreds = FALSE,\n\n # Date features\n CalendarVariables = c(\"week\", \"month\", \"quarter\"),\n HolidayVariable = c(\"USPublicHolidays\",\n \"EasterGroup\",\n \"ChristmasGroup\",\"OtherEcclesticalFeasts\"),\n HolidayLookback = NULL,\n HolidayLags = 1,\n HolidayMovingAverages = 1:2,\n\n # Time series features\n Lags = list(\"weeks\" = seq(2L, 10L, 2L),\n \"months\" = c(1:3)),\n MA_Periods = list(\"weeks\" = seq(2L, 10L, 2L),\n \"months\" = c(2,3)),\n SD_Periods = NULL,\n Skew_Periods = NULL,\n Kurt_Periods = NULL,\n Quantile_Periods = NULL,\n Quantiles_Selected = c(\"q5\",\"q95\"),\n\n # Bonus features\n AnomalyDetection = NULL,\n XREGS = xregs,\n FourierTerms = 2,\n TimeTrendVariable = TRUE,\n ZeroPadSeries = NULL,\n DataTruncate = FALSE,\n\n # ML Args\n NumOfParDepPlots = 100L,\n EvalMetric = \"MultiRMSE\",\n EvalMetricValue = 1.5,\n LossFunction = \"MultiRMSE\",\n LossFunctionValue = 1.5,\n GridTune = FALSE,\n PassInGrid = NULL,\n ModelCount = 5,\n TaskType = \"GPU\",\n NumGPU = 1,\n MaxRunsWithoutNewWinner = 50,\n MaxRunMinutes = 60*60,\n Langevin = FALSE,\n DiffusionTemperature = 10000,\n NTrees = 2500,\n L2_Leaf_Reg = 3.0,\n RandomStrength = 1,\n BorderCount = 254,\n BootStrapType = c(\"Bayesian\", \"Bernoulli\", \"Poisson\", \"MVS\", \"No\"),\n Depth = 6)\n```\n\n

\n\n

Code Example: AutoCatBoostHurdleCARMA()

\n\n \n```\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n# Intermittent Demand CARMA ----\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n# Load Walmart Data from Dropbox----\ndata <- data.table::fread(\"https://www.dropbox.com/s/2str3ek4f4cheqi/walmart_train.csv?dl=1\")\n\n # Subset for Stores / Departments With Full Series\ndata <- data[, Counts := .N, by = c(\"Store\",\"Dept\")][\n Counts == 143][\n , Counts := NULL]\n\n# Subset Columns (remove IsHoliday column)----\nkeep <- c(\"Store\",\"Dept\",\"Date\",\"Weekly_Sales\")\ndata <- data[, ..keep]\ndata <- data[Store %in% c(1,2)]\nxregs <- data.table::copy(data)\nxregs[, GroupVar := do.call(paste, c(.SD, sep = \" \")), .SDcols = c(\"Store\",\"Dept\")]\nxregs[, c(\"Store\",\"Dept\") := NULL]\ndata.table::setnames(xregs, \"Weekly_Sales\", \"Other\")\nxregs[, Other := jitter(Other, factor = 25)]\ndata <- data[as.Date(Date) < as.Date('2012-09-28')]\n\n# Add some zeros for testing\ndata[runif(.N) < 0.25, Weekly_Sales := 0]\n\n# Build Forecast ----\nOutput <- RemixAutoML::AutoCatBoostHurdleCARMA(\n\n # data args\n AlgoType = \"catboost\",\n data = data,\n TargetColumnName = \"Weekly_Sales\",\n DateColumnName = \"Date\",\n HierarchGroups = NULL,\n GroupVariables = c(\"Store\",\"Dept\"),\n TimeUnit = \"weeks\",\n TimeGroups = c(\"weeks\",\"months\"),\n\n # Production args\n TrainOnFull = TRUE,\n SplitRatios = c(1 - 10 / 138, 10 / 138),\n PartitionType = \"random\",\n FC_Periods = 4,\n Timer = TRUE,\n DebugMode = TRUE,\n\n # Target transformations\n TargetTransformation = FALSE,\n Methods = c(\"BoxCox\",\"Asinh\",\"Asin\",\"Log\",\"LogPlus1\",\"Logit\",\"YeoJohnson\"),\n Difference = FALSE,\n NonNegativePred = FALSE,\n RoundPreds = FALSE, \n\n # Date features\n CalendarVariables = c(\"week\",\"month\",\"quarter\"),\n HolidayVariable = c(\"USPublicHolidays\",\"EasterGroup\",\"ChristmasGroup\",\"OtherEcclesticalFeasts\"),\n HolidayLookback = NULL,\n HolidayLags = 1,\n HolidayMovingAverages = 1:2,\n\n # Time series features\n Lags = list(\"weeks\" = seq(2L,10L,2L), \"months\" = c(1:3)),\n MA_Periods = list(\"weeks\" = seq(2L,10L,2L), \"months\" = c(2,3)),\n SD_Periods = NULL,\n Skew_Periods = NULL,\n Kurt_Periods = NULL,\n Quantile_Periods = NULL,\n Quantiles_Selected = NULL,\n\n # Bonus features\n AnomalyDetection = NULL,\n XREGS = xregs,\n FourierTerms = 1,\n TimeTrendVariable = TRUE,\n ZeroPadSeries = NULL,\n DataTruncate = FALSE,\n\n # ML Args\n NumOfParDepPlots = 100L,\n EvalMetric = \"RMSE\",\n GridTune = FALSE,\n PassInGrid = NULL,\n ModelCount = 5,\n TaskType = \"GPU\",\n NumGPU = 1,\n MaxRunsWithoutNewWinner = 50,\n MaxRunMinutes = 60*60,\n NTrees = 1000,\n L2_Leaf_Reg = 3.0,\n RandomStrength = 1,\n BorderCount = 254,\n BootStrapType = c(\"Bayesian\", \"Bernoulli\", \"Poisson\", \"MVS\", \"No\"),\n Depth = 6)\n```\n\n

\n\n

Code Example: AutoXGBoostCARMA()

\n\n \n```\n \n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n# XGBoost Version ----\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n# Load data\ndata <- data.table::fread(\"https://www.dropbox.com/s/2str3ek4f4cheqi/walmart_train.csv?dl=1\")\n\n# Ensure series have no missing dates (also remove series with more than 25% missing values)\ndata <- RemixAutoML::TimeSeriesFill(\n data,\n DateColumnName = \"Date\",\n GroupVariables = c(\"Store\",\"Dept\"),\n TimeUnit = \"weeks\",\n FillType = \"maxmax\",\n MaxMissingPercent = 0.25,\n SimpleImpute = TRUE)\n\n# Set negative numbers to 0\ndata <- data[, Weekly_Sales := data.table::fifelse(Weekly_Sales < 0, 0, Weekly_Sales)]\n\n# Remove IsHoliday column\ndata[, IsHoliday := NULL]\n\n# Create xregs (this is the include the categorical variables instead of utilizing only the interaction of them)\nxregs <- data[, .SD, .SDcols = c(\"Date\", \"Store\", \"Dept\")]\n\n# Change data types\ndata[, \":=\" (Store = as.character(Store), Dept = as.character(Dept))]\nxregs[, \":=\" (Store = as.character(Store), Dept = as.character(Dept))]\n\n # Build forecast\nXGBoostResults <- AutoXGBoostCARMA(\n\n # Data Artifacts\n data = data,\n NonNegativePred = FALSE,\n RoundPreds = FALSE,\n TargetColumnName = \"Weekly_Sales\",\n DateColumnName = \"Date\",\n HierarchGroups = NULL,\n GroupVariables = c(\"Store\",\"Dept\"),\n TimeUnit = \"weeks\",\n TimeGroups = c(\"weeks\",\"months\"),\n\n # Data Wrangling Features\n ZeroPadSeries = NULL,\n DataTruncate = FALSE,\n SplitRatios = c(1 - 10 / 138, 10 / 138),\n PartitionType = \"timeseries\",\n AnomalyDetection = NULL,\n\n # Productionize\n FC_Periods = 0,\n TrainOnFull = FALSE,\n NThreads = 8,\n Timer = TRUE,\n DebugMode = FALSE,\n SaveDataPath = NULL,\n PDFOutputPath = NULL,\n\n # Target Transformations\n TargetTransformation = TRUE,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\", \"LogPlus1\", \"Sqrt\", \"Logit\",\"YeoJohnson\"),\n Difference = FALSE,\n\n # Features\n Lags = list(\"weeks\" = seq(1L, 10L, 1L), \"months\" = seq(1L, 5L, 1L)),\n MA_Periods = list(\"weeks\" = seq(5L, 20L, 5L), \"months\" = seq(2L, 10L, 2L)),\n SD_Periods = NULL,\n Skew_Periods = NULL,\n Kurt_Periods = NULL,\n Quantile_Periods = NULL,\n Quantiles_Selected = c(\"q5\",\"q95\"),\n XREGS = xregs,\n FourierTerms = 4,\n CalendarVariables = c(\"week\", \"wom\", \"month\", \"quarter\"),\n HolidayVariable = c(\"USPublicHolidays\",\"EasterGroup\",\"ChristmasGroup\",\"OtherEcclesticalFeasts\"),\n HolidayLookback = NULL,\n HolidayLags = 1,\n HolidayMovingAverages = 1:2,\n TimeTrendVariable = TRUE,\n\n # ML eval args\n TreeMethod = \"hist\",\n EvalMetric = \"RMSE\",\n LossFunction = 'reg:squarederror',\n\n # ML grid tuning\n GridTune = FALSE,\n ModelCount = 5,\n MaxRunsWithoutNewWinner = 20L,\n MaxRunMinutes = 24L*60L,\n\n # ML args\n NTrees = 300,\n LearningRate = 0.3,\n MaxDepth = 9L,\n MinChildWeight = 1.0,\n SubSample = 1.0,\n ColSampleByTree = 1.0)\n```\n\n

\n\n

Code Example: AutoH2OCARMA()

\n\n \n```\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n# H2O Version ----\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n# Load data\ndata <- data.table::fread(\"https://www.dropbox.com/s/2str3ek4f4cheqi/walmart_train.csv?dl=1\")\n\n# Ensure series have no missing dates (also remove series with more than 25% missing values)\ndata <- RemixAutoML::TimeSeriesFill(\n data,\n DateColumnName = \"Date\",\n GroupVariables = c(\"Store\",\"Dept\"),\n TimeUnit = \"weeks\",\n FillType = \"maxmax\",\n MaxMissingPercent = 0.25,\n SimpleImpute = TRUE)\n\n# Set negative numbers to 0\ndata <- data[, Weekly_Sales := data.table::fifelse(Weekly_Sales < 0, 0, Weekly_Sales)]\n\n# Remove IsHoliday column\ndata[, IsHoliday := NULL]\n\n# Create xregs (this is the include the categorical variables instead of utilizing only the interaction of them)\nxregs <- data[, .SD, .SDcols = c(\"Date\", \"Store\", \"Dept\")]\n\n# Change data types\ndata[, \":=\" (Store = as.character(Store), Dept = as.character(Dept))]\nxregs[, \":=\" (Store = as.character(Store), Dept = as.character(Dept))]\n\n# Build forecast\nResults <- RemixAutoML::AutoH2OCARMA(\n\n # Data Artifacts\n AlgoType = \"drf\",\n ExcludeAlgos = NULL,\n data = data,\n TargetColumnName = \"Weekly_Sales\",\n DateColumnName = \"Date\",\n HierarchGroups = NULL,\n GroupVariables = c(\"Dept\"),\n TimeUnit = \"week\",\n TimeGroups = c(\"weeks\",\"months\"),\n\n # Data Wrangling Features\n SplitRatios = c(1 - 10 / 138, 10 / 138),\n PartitionType = \"random\",\n\n # Production args\n FC_Periods = 4L,\n TrainOnFull = FALSE,\n MaxMem = {gc();paste0(as.character(floor(max(32, as.numeric(system(\"awk '/MemFree/ {print $2}' /proc/meminfo\", intern=TRUE)) -32) / 1000000)),\"G\")},\n NThreads = parallel::detectCores(),\n PDFOutputPath = NULL,\n SaveDataPath = NULL,\n Timer = TRUE,\n DebugMode = TRUE,\n\n # Target Transformations\n TargetTransformation = FALSE,\n Methods = c(\"BoxCox\", \"Asinh\", \"Asin\", \"Log\",\n \"LogPlus1\", \"Sqrt\", \"Logit\", \"YeoJohnson\"),\n Difference = FALSE,\n NonNegativePred = FALSE,\n RoundPreds = FALSE,\n\n # Calendar features\n CalendarVariables = c(\"week\", \"wom\", \"month\", \"quarter\", \"year\"),\n HolidayVariable = c(\"USPublicHolidays\",\"EasterGroup\",\n \"ChristmasGroup\",\"OtherEcclesticalFeasts\"),\n HolidayLookback = NULL,\n HolidayLags = 1:7,\n HolidayMovingAverages = 2:7,\n TimeTrendVariable = TRUE,\n\n # Time series features\n Lags = list(\"weeks\" = c(1:4), \"months\" = c(1:3)),\n MA_Periods = list(\"weeks\" = c(2:8), \"months\" = c(6:12)),\n SD_Periods = NULL,\n Skew_Periods = NULL,\n Kurt_Periods = NULL,\n Quantile_Periods = NULL,\n Quantiles_Selected = NULL,\n\n # Bonus Features\n XREGS = NULL,\n FourierTerms = 2L,\n AnomalyDetection = NULL,\n ZeroPadSeries = NULL,\n DataTruncate = FALSE,\n\n # ML evaluation args\n EvalMetric = \"RMSE\",\n NumOfParDepPlots = 0L,\n\n # ML grid tuning args\n GridTune = FALSE,\n GridStrategy = \"Cartesian\",\n ModelCount = 5,\n MaxRuntimeSecs = 60*60*24,\n StoppingRounds = 10,\n\n # ML Args\n NTrees = 1000L,\n MaxDepth = 20,\n SampleRate = 0.632,\n MTries = -1,\n ColSampleRatePerTree = 1,\n ColSampleRatePerTreeLevel = 1,\n MinRows = 1,\n NBins = 20,\n NBinsCats = 1024,\n NBinsTopLevel = 1024,\n HistogramType = \"AUTO\",\n CategoricalEncoding = \"AUTO\",\n RandomColNumbers = NULL,\n InteractionColNumbers = NULL,\n WeightsColumn = NULL,\n\n # ML args\n Distribution = \"gaussian\",\n Link = \"identity\",\n RandomDistribution = NULL,\n RandomLink = NULL,\n Solver = \"AUTO\",\n Alpha = NULL,\n Lambda = NULL,\n LambdaSearch = FALSE,\n NLambdas = -1,\n Standardize = TRUE,\n RemoveCollinearColumns = FALSE,\n InterceptInclude = TRUE,\n NonNegativeCoefficients = FALSE)\n\n```\n\n

\n\n

\n\nAutoCatBoostVectorCARMA For Panel Data with multiple series to forecast. An example would be, predicting revenue and transactions across a large number of stores over time.\n\nAutoHurdleCARMA() utilizes the AutoCatBoostHurdleModel() function internally in order to model zeros that naturally show up in intermittent demand data sets.\n\nAutoCatBoostCARMA() utilizes the CatBoost alorithm\n\nAutoXGBoostCARMA() utilizes the XGBoost alorithm\n\nAutoH2OCARMA() utilizes H2O Algorithms: RandomForest, GBM, GLM, AutoML, and GAM\n\n

Model Highlights

\n \n##### The CARMA suite utilizes several features to ensure proper models are built to generate the best possible out-of-sample forecasts.\n\n###### **Feature engineering:** I use a time trend, calendar variables, holiday counts, differencing, along with fourier pairs and lags / rolling statistics (mean, sd, skewness, kurtosis, quantiles) and they can be generated by categorical variables and their interactions plus for various time-based aggregations. Internally, the CARMA functions utilize several RemixAutoML functions, all written using data.table for fast and memory efficient processing: \n * AutoLagRollStats() - creates lags and moving average features (also creates lags and moving averages off of time between records)\n * AutoLagRollStatsScoring() - creates lags and moving average features for a single record (along with the time between vars)\n * CreateCalendarVariables() - creates numeric features identifying various time units based on date columns\n * CreateHolidayVariables() - creates count features based on the specified holiday groups you want to track and the date columns you supply\n * AutoHierarchicalFourier() - creates fourier pairs, by group, in paralell, for group variables and their interactions\n * DifferenceData() - differencing of the target variable for single series and panel data\n\n###### **Optimal transformations:** the target variable along with the associated lags and moving average features were transformed. This is really useful for regression models with categorical features that have associated target values that significantly differ from each other. The transformation options that are tested (using a Pearson test for normality) include: \n * YeoJohnson\n * BoxCox\n * Log\n * LogPlus1\n * Sqrt\n * arcsinh\n * Identity\n * arcsin(sqrt(x)): proportion data only\n * logit(x): proportion data only\n\n###### The functions used to create these and generate them for scoring models come from RemixAutoML:\n* AutoTransformationCreate()\n* AutoTransformationScore()\n\n###### **Models:** there are four CARMA functions and each use a different algorithm for the model fitting. The models used to fit the time series data come from RemixAutoML and include: \n* AutoCatBoostRegression()\n* AutoXGBoostRegression()\n* AutoH2oDRFRegression()\n* AutoH2oGBMRegression()\n* AutoH2oGLMRegression()\n* AutoH2oGAMRegression()\n* AutoH2oAutoMLRegression()\n\n###### **GPU:** With the CatBoost and XGBoost functions, you can build the models utilizing GPU (I run them with a GeForce 1080ti) which results in an average 10x speedup in model training time (compared to running on CPU with 8 threads).\n\n###### **Data partitioning:** for creating the training, validation, and test data, the CARMA functions utilize the AutoDataPartition() function and utilizes the \"timeseries\" option for the PartitionType argument which ensures that the train data reflects the furthest points back in time, followed by the validation data, and then the test data which is the most recent in time.\n\n###### **Forecasting:** Once the regression model is built, the forecast process replicates the ARIMA process. Once a single step-ahead forecast is made, the lags and moving average features are updated based on the predicted values from scoring the model. Next, the rest of the other features are updated. Then the next forecast step is made, rinse and repeat for remaining forecasting steps. This process utilizes the RemixAutoML functions:\n* AutoCatBoostScoring()\n* AutoXGBoostScoring()\n* AutoH2oMLScoring()\n\n### Intermittent Demand Forecasting Functions\n\n#### **TimeSeriesFill()**\nTimeSeriesFill() is a function that will zero pad (currently only zero pad) a time series data set (not transactional data). There are four ways to use this function:\nChoose from:\n * maxmax - Fill from the absolute min date to the absolute max date (single series and panel data)\n * minmax - Fill from the max date of the min set to the absolute max date (panel data)\n * maxmin - Fill from the absolute min date to the min of the max dates (panel data)\n * minmin - Fill from the max date of the min dates to the min date of the max dates (panel data)\n\n#### **ContinuousTimeDataGenerator()**\nContinuousTimeDataGenerator() is for frequency and size data sets. This function generates count and size data sets for intermittent demand forecasting, using the methods in this package.\n\n#### **AutoCatBoostSizeFreqDist()**\nAutoCatBoostSizeFreqDist() is for building size and frequency predictive distributions via quantile regressions. Size (or severity) and frequency (or count) quantile regressions are build and you supply the actual percentiles you want predicted. Use this with the ID_SingleLevelGibbsSampler() function to simulate from the joint distribution.\n\n#### **AutoH2oGBMSizeFreqDist()**\nAutoH2oGBMSizeFreqDist() is for building size and frequency predictive distributions via quantile regressions. Size (or severity) and frequency (or count) quantile regressions are build and you supply the actual percentiles you want predicted. Use this with the ID_SingleLevelGibbsSampler() function to simulate from the joint distribution.\n\n#### **AutoCatBoostFreqSizeScoring()**\nAutoCatBoostFreqSizeScoring() is for scoring the models build with AutoCatBoostSizeFreqDist(). It will return the predicted values for every quantile model for both distributions for 1 to the max forecast periods you provided to build the scoring data. \n\n#### **AutoH2oGBMFreqSizeScoring()**\nAutoH2oGBMFreqSizeScoring() is for scoring the models build with AutoH2oGBMSizeFreqDist(). It will return the predicted values for every quantile model for both distributions for 1 to the max forecast periods you provided to build the scoring data. \n\n

\n\n

\n\n\n## Time Series Forecasting

Expand to view content

\n \n### **AutoBanditSarima()**\n\n

Code Example

\n \n```\n# Build model\ndata <- RemixAutoML::FakeDataGenerator(Correlation = 0.82, TimeSeries = TRUE, TimeSeriesTimeAgg = \"1min\")\n\n# Run system\nOutput <- RemixAutoML::AutoBanditSarima(\n data = data,\n SaveFile = NULL,\n ByDataType = FALSE,\n TargetVariableName = \"Weekly_Sales\",\n DateColumnName = \"Date\",\n TimeAggLevel = \"1min\",\n EvaluationMetric = \"MAE\",\n NumHoldOutPeriods = 12L,\n NumFCPeriods = 16L,\n MaxLags = 10L,\n MaxSeasonalLags = 0L,\n MaxMovingAverages = 3L,\n MaxSeasonalMovingAverages = 0L,\n MaxFourierPairs = 2L,\n TrainWeighting = 0.50,\n MaxConsecutiveFails = 50L,\n MaxNumberModels = 100L,\n MaxRunTimeMinutes = 10L,\n NumberCores = 12,\n DebugMode = FALSE)\n\n# View output\nOutput$ForecastPlot\nOutput$ErrorLagMA2x2\nOutput$Forecast\nOutput$PerformanceGrid\n```\n\n

\n\nAutoBanditSarima() is the newest weapon in the time series arsenal. This is the highest performing single series time series model in the package. The entire arima parameter space is divided up into blocks that are increasing in complexity of parameter settings. The multi-armed bandit will determine which parameter block to sample from more frequently based on which one is performing better than the others. The underlying bandit algorithm is the randomized probability matching algorithm found in the **bandit** package. I had to write a slight variation of it to allow for tweaking the number of intervals used in computing the integrals that result in the probabilities used for sampling. The evaluation is different from what exists today - you need to specify a weighting to use so that both the training metrics and validation metrics are used in calculating the best model. The user can specify 0% or 100% to go with just the one measure of their choice as well. The function returns a list with data.table of the forecasts and prediction inverals and the other item in the list is the Performance Grid results so you can see how every model tested performed.\n\n### **AutoBanditNNet()**\nSame as AutoBanditArima except it uses the forecast::nnetar model behind the scenes.\n\n### **AutoTBATS()**\nAutoTBATS uses forecast::tbats behind the scenes. It just runs through all the parameter settings and builds each model and returns the same list as the other two above.\n\n### **AutoETS()**\nAutoETS uses forecast::ets behind the scenes. It just runs through all the parameter settings and builds each model and returns the same list as the other two above.\n\n### **AutoArfima()**\nAutoArfima uses forecast::arfima behind the scenes. It just runs through all the parameter settings and builds each model and returns the same list as the other two above.\n\n### **AutoTS()**\nAutoTS() \n\n

Model Highlights

\n\n* Save model and xregs to file if a path is supplied\n* Returns a list containing \n * A data.table object with a date column and the forecasted values\n * The model evaluation results\n * The champion model for later use if desired\n * The name of the champion model\n * A time series ggplot with historical values and forecasted values with optional 80% and 95% prediction intervals\n* The models tested internally include:\n * DSHW: Double Seasonal Holt-Winters\n * ARFIMA: Auto Regressive Fractional Integrated Moving Average\n * ARIMA: Auto Regressive Integrated Moving Average with specified max lags, seasonal lags, moving averages, and seasonal moving averages\n * ETS: Additive and Multiplicative Exponential Smoothing and Holt-Winters\n * NNetar: Auto Regressive Neural Network models automatically compares models with 1 lag or 1 seasonal lag compared to models with up to N lags and N seasonal lags\n * TBATS: Exponential smoothing state space model with Box-Cox transformation, ARMA errors, Trend and Seasonal components\n * TSLM: Time Series Linear Model - builds a linear model with trend and season components extracted from the data\n\nFor each of the models tested internally, several aspects should be noted:\n* Optimal Box-Cox transformations are used in every run where data is strictly positive. The optimal transformation could also be \"no transformation\". \n* Four different treatments are tested for each model:\n * user-specified time frequency + no historical series smoothing & imputation\n * model-based time frequency + no historical smoothing and imputation\n * user-specified time frequency + historical series smoothing & imputation\n * model-based time frequency + historical smoothing & imputation\n\n* You can specify MaxFourierPairs to test out if adding Fourier term regressors can increase forecast accuracy. The Fourier terms will be applied to the ARIMA and NNetar models only.\n* For the ARIMA, ARFIMA, and TBATS, any number of lags and moving averages along with up to 1 seasonal lags and seasonal moving averages can be used (selection based on a stepwise procedure)\n* For the Double Seasonal Holt-Winters model, alpha, beta, gamma, omega, and phi are determined using least-squares and the forecasts are adjusted using an AR(1) model for the errors\n* The Exponential Smoothing State-Space model runs through an automatic selection of the error type, trend type, and season type, with the options being \"none\", \"additive\", and \"multiplicative\", along with testing of damped vs. non-damped trend (either additive or multiplicative), and alpha, beta, and phi are estimated\n* The neural network is setup to test out every combination of lags and seasonal lags and the model with the best holdout score is selected\n* The TBATS model utilizes any number of lags and moving averages for the errors, damped trend vs. non-damped trend are tested, trend vs. non-trend are also tested, and the model utilizes parallel processing for efficient run times\n* The TSLM model utilizes a simple time trend and season depending on the frequency of the data\n\n

\n\n

\n\n## Recommender Systems

Expand to view content

\n \n#### **AutoRecomDataCreate()**\nAutoRecomDataCreate() automatically creates your binary ratings matix from transaction data\n\n#### **AutoRecommender()**\nAutoRecommender() automated collaborative filtering modeling where each model below competes against one another for top performance\n * RandomItems\n * PopularItems\n * UserBasedCF \n * ItemBasedCF\n * AssociationRules\n \n#### **AutoRecommenderScoring()**\nAutoRecommenderScoring() automatically score a recommender model from AutoRecommender()\n\n#### **AutoMarketBasketModel()**\nAutoMarketBasketModel() is a function that runs a market basket analysis automatically. It will convert your data, run the algorithm, and generate the recommended items. On top of that, it includes additional significance values not provided by the source pacakge. \n \n

\n\n## Unsupervised Learning

Expand to view content

\n \n#### **ResidualOutliers()**\nResidualOutliers() Generate residual outliers from time series modeling. (Cross with Feature Engineering) Utilize tsoutliers to indicate outliers within a time series data set\n\n#### **GenTSAnomVars()**\nGenTSAnomVars() generates time series anomaly variables. (Cross with Feature Engineering) Create indicator variables (high, low) along with cumulative anomaly rates (high, low) based on control limits methodology over a max of two grouping variables and a date variable (effectively a rolling GLM).\n\n\n\n

\n\n## Database Management

Expand to view content

\n\n#### **AutoDataDictionary()**\nAutoDataDictionary() will pull back data dictionary data from a sql server data warehouse and run queries to pull in data to R. There are several data dictionary types that can be returned, such as returning every table that exists along with every column with metadata information. Another good one is to pull back all tables and their counterparts that can be used in joins, along with the joining sql.\n\n#### **SQL_Server_DBConnection()**\nSQL_Server_DBConnection() Create a connect with sql server\n\n#### **SQL_Query_Push()**\nSQL_Query_Push() Push data to a sql server warehouse\n\n#### **SQL_Query()**\nSQL_Query() Query a sql server table\n\n#### **SQL_ClearTable()**\nSQL_ClearTable() Deletes all rows of a sql server table\n\n#### **SQL_DropTable()**\nSQL_DropTable() Removes a sql server table\n\n#### **SQL_SaveTable()**\nSQL_SaveTable() Write a sql server table\n\n#### **SQL_UpdateTable()**\nSQL_UpdateTable() Update a sql server table\n\n#### **SQL_Server_BulkPull()**\nSQL_Server_BulkPull() Query a sql server table using bulk copy process\n\n#### **SQL_Server_BulkPush()**\nSQL_Server_BulkPush() Write to a sql server table using bulk copy process\n\n

\n\n\n## Utilities, EDA, and Misc.

Expand to view content

\n \n#### **AutoWordFreq()** \nAutoWordFreq() creates a word frequency data.table and a word cloud\n\n\n\n#### **ProblematicFeatures()**\nProblematicFeatures() identifies columns that have either little to no variance, categorical variables with extremely high cardinality, too many NA's, too many zeros, or too high of a skew.\n\n#### **RemixTheme()** \nRemixTheme() is a specific font, set of colors, and style for plots.\n\n#### **ChartTheme()** \nChartTheme() is a specific font, set of colors, and style for plots.\n\n#### **multiplot()** \nmultiplot() is useful for displaying multiple plots in a single pane. I've never had luck using grid so I just use this instead.\n\n#### **FakeDataGenerator()**\nFakeDataGenerator() I use this to create fake data for the examples in the function help files\n\n

","jobInfo":{"package":"RemixAutoML","version":"V0.4.9","parsingStatus":"success","parserVersion":1,"parsedAt":"2021-09-02T00:30:41+0000"}}

Description

Usage

Arguments

See Also