## formatR - Required to format R code in the markdown ----

if (require("languageserver")) {
  require("languageserver")
} else {
  install.packages("languageserver", dependencies = TRUE,
                   repos = "https://cloud.r-project.org")
}

# Introduction ----
# Resampling methods are techniques that can be used to improve the performance
# and reliability of machine learning algorithms. They work by creating
# multiple training sets from the original training set. The model is then
# trained on each training set, and the results are averaged. This helps to
# reduce overfitting and improve the model's generalization performance.

# Resampling methods include:
## Splitting the dataset into train and test sets ----
## Bootstrapping (sampling with replacement) ----
## Basic k-fold cross validation ----
## Repeated cross validation ----
## Leave One Out Cross-Validation (LOOCV) ----

# STEP 1. Install and Load the Required Packages ----
## mlbench ----
if (require("mlbench")) {
  require("mlbench")
} else {
  install.packages("mlbench", dependencies = TRUE,
                   repos = "https://cloud.r-project.org")
}

## caret ----
if (require("caret")) {
  require("caret")
} else {
  install.packages("caret", dependencies = TRUE,
                   repos = "https://cloud.r-project.org")
}

## kernlab ----
if (require("kernlab")) {
  require("kernlab")
} else {
  install.packages("kernlab", dependencies = TRUE,
                   repos = "https://cloud.r-project.org")
}

## randomForest ----
if (require("randomForest")) {
  require("randomForest")
} else {
  install.packages("randomForest", dependencies = TRUE,
                   repos = "https://cloud.r-project.org")
}

knitr::opts_chunk$set(
    eval = TRUE,
    echo = TRUE,
    warning = FALSE,
    collapse = FALSE,
    tidy = TRUE
)

# 1 Descriptive Statistics ----

# Install renv:
if (!is.element("renv", installed.packages()[, 1])) {
    install.packages("renv", dependencies = TRUE)
}
require("renv")

# Use renv::init() to initialize renv in a new or existing project.

# The prompt received after executing renv::init() is as shown below: This
# project already has a lockfile. What would you like to do?

# 1: Restore the project from the lockfile.  2: Discard the lockfile and
# re-initialize the project.  3: Activate the project without snapshotting or
# installing any packages.  4: Abort project initialization.

# Select option 1 to restore the project from the lockfile


# This will set up a project library, containing all the packages you are
# currently using. The packages (and all the metadata needed to reinstall them)
# are recorded into a lockfile, renv.lock, and a .Rprofile ensures that the
# library is used every time you open that project.

# This can also be configured using the RStudio GUI when you click the project
# file, e.g., 'BBT4206-R.Rproj' in the case of this project. Then navigate to
# the 'Environments' tab and select 'Use renv with this project'.

# As you continue to work on your project, you can install and upgrade
# packages, using either: install.packages() and update.packages or
# renv::install() and renv::update()

# You can also clean up a project by removing unused packages using the
# following command: renv::clean()

# After you have confirmed that your code works as expected, use
# renv::snapshot() to record the packages and their sources in the lockfile.

# Later, if you need to share your code with someone else or run your code on a
# new machine, your collaborator (or you) can call renv::restore() to reinstall
# the specific package versions recorded in the lockfile.

# Execute the following code to reinstall the specific package versions
# recorded in the lockfile:

# One of the packages required to use R in VS Code is the 'languageserver'
# package. It can be installed manually as follows if you are not using the
# renv::restore() command.
if (!is.element("languageserver", installed.packages()[, 1])) {
    install.packages("languageserver", dependencies = TRUE)
}
require("languageserver")

# Loading Datasets ---- STEP 2: Load datasets ----

library(readr)
loans <- read_csv("C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/data/loans_imputed.csv")

View(loans)

# Dimensions ---- STEP 3. Preview the Loaded Datasets ---- Dimensions refer to
# the number of observations (rows) and the number of
# attributes/variables/features (columns). Execute the following commands to
# display the dimensions of your datasets:

dim(loans)

# Data Types ---- STEP 4. Identify the Data Types ---- Knowing the data types
# will help you to identify the most appropriate visualization types and
# algorithms that can be applied. It can also help you to identify the need to
# convert from categorical data (factors) to integers or vice versa where
# necessary. Execute the following command to identify the data types:
sapply(loans, class)

# Descriptive Statistics ----

# We will first understand the data before using it to design prediction models
# and to make generalizable inferences.

# 1. Measures of frequency (e.g., count, percent)

# 2. Measures of central tendency (e.g., mean, median, mode) Further reading:
# https://www.scribbr.com/statistics/central-tendency/

# 3. Measures of distribution/dispersion/spread/scatter/variability (e.g.,
# range, quartiles, interquartile range, standard deviation, variance,
# kurtosis, skewness) Further reading:
# https://www.scribbr.com/statistics/variability/ Further reading:
# https://digitaschools.com/descriptive-statistics-skewness-and-kurtosis/
# Further reading: https://www.scribbr.com/statistics/skewness/

# 4. Measures of relationship (e.g., covariance, correlation, ANOVA)

# Further reading: https://www.k2analytics.co.in/covariance-and-correlation/
# Further reading: https://www.scribbr.com/statistics/one-way-anova/ Further
# reading: https://www.scribbr.com/statistics/two-way-anova/

# Understanding your data can lead to: (i)\t Data cleaning: Removing bad data
# or imputing missing data.  (ii)\tData transformation: Reduce the skewness by
# applying the same function to all the observations.  (iii)\tData modelling:
# You may notice properties of the data such as distributions or data types
# that suggest the use (or not) of specific algorithms.

## Measures of Frequency ----

### STEP 5. Identify the number of instances that belong to each class. ---- It
### is more sensible to count categorical variables (factors or dimensions)
### than numeric variables, e.g., counting the number of male and female
### participants instead of counting the frequency of each participant’s
### height.
loans_freq <- loans$Education
cbind(frequency = table(loans_freq), percentage = prop.table(table(loans_freq)) *
    100)

## Measures of Central Tendency ---- STEP 6. Calculate the mode ----
## Unfortunately, R does not have an in-built function for calculating the
## mode.  We, therefore, must manually create a function that can calculate the
## mode.

loans_Education_mode <- names(table(loans$Education))[which(table(loans$Education) ==
    max(table(loans$Education)))]
print(loans_Education_mode)

## Measures of Distribution/Dispersion/Spread/Scatter/Variability ----

### STEP 7. Measure the distribution of the data for each variable ----
summary(loans)

### STEP 8. Measure the standard deviation of each variable ---- Measuring the
### variability in the dataset is important because the amount of variability
### determines how well you can generalize results from the sample dataset to a
### new observation in the population.

# Low variability is ideal because it means that you can better predict
# information about the population based on sample data. High variability means
# that the values are less consistent, thus making it harder to make
# predictions.

# The format “dataset[rows, columns]” can be used to specify the exact rows and
# columns to be considered. “dataset[, columns]” implies all rows will be
# considered. Specifying “Loans[, -4]” implies all the columns except column
# number 4. This can also be stated as “Loans[,
# c(1,2,3,5,6,7,8,9,10,11,12,13,14)]”. This allows us to calculate the standard
# deviation of only columns that are numeric, thus leaving out the columns
# termed as “factors” (categorical) or those that have a string data type.

# check data types
str(loans)

sapply(loans[, 9], sd)

sapply(loans[, c(6, 7, 8, 9, 10)], sd)

# The data type should be double (not numeric) so that it can be calculated.


### STEP 9. Measure the kurtosis of each variable ---- The Kurtosis informs you
### of how often outliers occur in the results.

# There are different formulas for calculating kurtosis.  Specifying “type = 2”
# allows us to use the 2nd formula which is the same kurtosis formula used in
# SPSS and SAS. More details about any function can be obtained by searching
# the R help knowledge base. The knowledge base says:

# In “type = 2” (used in SPSS and SAS): 1.\tKurtosis < 3 implies a low number
# of outliers 2.\tKurtosis = 3 implies a medium number of outliers 3.\tKurtosis
# > 3 implies a high number of outliers

if (!is.element("e1071", installed.packages()[, 1])) {
    install.packages("e1071", dependencies = TRUE)
}
require("e1071")

sapply(loans[, 10], kurtosis, type = 2)

### STEP 10. Measure the skewness of each variable ----

# The skewness informs you of the asymmetry of the distribution of results.
# Similar to kurtosis, there are several ways of computing the skewness.  Using
# “type = 2” can be interpreted as:

# 1.\tSkewness between -0.4 and 0.4 (inclusive) implies that there is no skew
# in the distribution of results; the distribution of results is symmetrical;
# it is a normal distribution.  2.\tSkewness above 0.4 implies a positive skew;
# a right-skewed distribution.  3.\tSkewness below -0.4 implies a negative
# skew; a left-skewed distribution.

sapply(loans[, 10], skewness, type = 2)

# Note, executing: skewness(loans$Dependents, type=2) computes the skewness for
# one variable called “Dependents” in theloans dataset. However, executing the
# following enables you to compute the skewness for all the variables in the
# “loans” dataset except variable number 12:


## Measures of Relationship ----

## STEP 11. Measure the covariance between variables ---- Note that the
## covariance and the correlation are computed for numeric values only, not
## categorical values.
loans_cov <- cov(loans[, 6:10])
View(loans_cov)

## STEP 12. Measure the correlation between variables ----
loans_cor <- cor(loans[, 6:10])
View(loans_cor)


# Inferential Statistics ---- Read the following article:
# https://www.scribbr.com/statistics/inferential-statistics/ Statistical tests
# (either for comparison, correlation, or regression) can be used to conduct
# *hypothesis testing*.

## Parametric versus Non-Parametric Statistical Tests ---- If all the 3 points
## below are true, then use parametric tests, else use non-parametric tests.
## (i)\t the population that the sample comes from follows a normal
## distribution of scores (ii) the sample size is large enough to represent the
## population (iii) the variances of each group being compared are similar

## Statistical tests for comparison ---- (i)\t t Test: parametric; compares
## means; uses 2 samples.  (ii)\tANOVA: parametric; compares means; can use
## more than 3 samples.  (iii)\tMood’s median: non-parametric; compares
## medians; can use more than 2 samples.  (iv)\tWilcoxon signed-rank:
## non-parametric; compares distributions; uses 2 samples.  (v)\t Wilcoxon
## rank-sum (Mann-Whitney U): non-parametric; compares sums of rankings; uses 2
## samples.  (vi)\tKruskal-Wallis H: non-parametric; compares mean rankings;
## can use more than 3 samples.

## Statistical tests for correlation ---- (i)\t Pearson’s r: parametric;
## expects interval/ratio variables.  (ii)\tSpearman’s r: non-parametric;
## expects ordinal/interval/ratio variables.  (iii)\tChi square test of
## independence: non-parametric; nominal/ordinal variables.

## Statistical tests for regression ---- (i)\t Simple linear regression:
## predictor is 1 interval/ratio variable; outcome is 1 interval/ratio
## variable.  (ii)\tMultiple linear regression: predictor can be more than 2
## interval/ratio variables; outcome is 1 interval/ratio variable.
## (iii)\tLogistic regression: predictor is 1 variable (any type); outcome is 1
## binary variable.  (iv)\tNominal regression: predictor can be more than 1
## variable; outcome is 1 nominal variable.  (v)\t Ordinal regression:
## predictor can be more than 1 variable; outcome is 1 ordinal variable.


# Qualitative Data Analysis ---- This can be done through either thematic
# analysis: https://www.scribbr.com/methodology/thematic-analysis/ or critical
# discourse analysis: https://www.scribbr.com/methodology/discourse-analysis/

# Basic Visualization for Understanding the Dataset ----

# Note: If you are using R Studio, ensure that the 'Plots' window on the bottom
# right of R Studio has enough space to display the chart.

# The fastest way to improve your understanding of the dataset is to visualize
# it. Visualization can help you to spot outliers and give you an idea of
# possible data transformations you can apply. The basic visualizations to
# understand your dataset can be univariate visualizations (helps you to
# understand a single attribute) or multivariate visualizations (helps you to
# understand the interaction between attributes). Packages used to create
# visualizations include: (i)\t Graphics package: Used to quickly create basic
# plots of data. This is the most appropriate to quickly understand the dataset
# before conducting further analysis.  (ii) Lattice package: Used to create
# more visually appealing plots of data.  (iii) ggplot2 package: Used to create
# even more visually appealing plots of data that can then be used to present
# the analysis results to the intended users. Given its complexity, it is not
# necessary to use ggplot2 to have a basic understanding of the dataset prior
# to further analysis.

# Note that the goal at this point is to understand your data, not to create
# visually appealing plots that are publicly shared. The visually appealing
# plots will be created much later after the best prediction model has been
# chosen.

## Univariate Plots ---- STEP 13. Create Histograms for Each Numeric Attribute
## ---- Histograms help in determining whether an attribute has a Gaussian
## distribution. They can also be used to identify the presence of outliers.

# Execute the following code to create histograms for the “loans” dataset:
# Assuming your dataset is named 'loans' (replace with the actual name of your
# dataset)
data_types <- sapply(loans, class)
print(data_types)

# Execute the following code to create one histogram for attribute 4 (the only
# numeric column was “final crop yield (in bushels per acre)”) in the “: The
# code below converts column number 4 into unlisted and numeric data first so
# that a histogram can be plotted. Further reading:
# https://www.programmingr.com/r-error-messages/x-must-be-numeric-error-in-r-histogram/
# )

Loans_status <- as.numeric(unlist(loans[, 9]))
hist(Loans_status, main = names(loans)[9])

### STEP 14. Create Box and Whisker Plots for Each Numeric Attribute ---- Box
### and whisker plots are useful in understanding the distribution of data.
### Further reading: https://www.scribbr.com/statistics/interquartile-range/

# Execute the following code to create box and whisker plots for the “”
# dataset: This considers the first 3 attributes which are numeric. The fourth
# attribute in the dataset is of the type “factor”, i.e., categorical.

par(mar = c(3, 3, 2, 1))

par(mfrow = c(6, 7))
for (i in 6:7) {
    boxplot(loans[, i], main = names(loans)[i])
}

# This considers the 5th to the 14th attributes which are numeric.  The fourth
# attribute in the dataset is of the type “factor”, i.e., categorical


boxplot(loans[, 6], main = names(loans)[6])
boxplot(loans[, 7], main = names(loans)[7])
boxplot(loans[, 8], main = names(loans)[8])
boxplot(loans[, 9], main = names(loans)[9])
boxplot(loans[, 10], main = names(loans)[10])


### STEP 15. Create Bar Plots for Each Categorical Attribute ---- Categorical
### attributes (factors) can also be visualized. This is done using a bar chart
### to give an idea of the proportion of instances that belong to each
### category.


barplot(table(loans[, 12]), main = names(loans)[12])

# Execute the following to create a bar plot for the categorical attributes 1
# to 11 in the “loans” dataset:

par(mfrow = c(1, 11))

for (i in 1:11) {
    barplot(table(loans[, i]), main = names(loans)[i])
}

### STEP 16. Create a Missingness Map to Identify Missing Data ---- Some
### machine learning algorithms cannot handle missing data. A missingness map
### (also known as a missing plot) can be used to get an idea of the amount
### missing data in the dataset. The x-axis of the missingness map shows the
### attributes of the dataset whereas the y-axis shows the instances in the
### dataset.  Horizontal lines indicate missing data for an instance whereas
### vertical lines indicate missing data for an attribute. The missingness map
### requires the “Amelia” package.

# Execute the following to create a map to identify the missing data in each
# dataset:
if (!is.element("Amelia", installed.packages()[, 1])) {
    install.packages("Amelia", dependencies = TRUE)
}
require("Amelia")

missmap(loans, col = c("red", "grey"), legend = TRUE)

# As shown in the results, the datasets that was loaded in this lab has no
# missing data.

## Multivariate Plots ----

### STEP 17. Create a Correlation Plot ---- Correlation plots can be used to
### get an idea of which attributes change together. The function “corrplot()”
### found in the package “corrplot” is required to perform this. The larger the
### dot in the correlation plot, the larger the correlation. Blue represents a
### positive correlation whereas red represents a negative correlation.

# Execute the following to create correlation plots for 3 of the datasets
# loaded in STEP 2 to STEP 4:
if (!is.element("corrplot", installed.packages()[, 1])) {
    install.packages("corrplot", dependencies = TRUE)
}
require("corrplot")

corrplot(cor(loans[, 6:10]), method = "circle")


# Alternatively, the 'ggcorrplot::ggcorrplot()' function can be used to plot a
# more visually appealing plot.  The code below shows how to install a package
# in R:
if (!is.element("ggcorrplot", installed.packages()[, 1])) {
    install.packages("ggcorrplot", dependencies = TRUE)
}
require("ggcorrplot")

ggcorrplot(cor(loans[, 6:10]))


# Alternatively, the ggcorrplot package can be used to make the plots more
# appealing:
ggplot(loans, aes(x = Dependents, y = Education, shape = Status, color = Status)) +
    geom_point() + geom_smooth(method = lm)

### STEP 18. Create Multivariate Box and Whisker Plots by Class ---- This
### applies to datasets where the target (dependent) variable is categorical.
### Execute the following code:
if (!is.element("caret", installed.packages()[, 1])) {
    install.packages("caret", dependencies = TRUE)
}
require("caret")
featurePlot(x = loans[, 1:12], y = loans[, 12], plot = "box")

# References ---- Bevans, R. (2023a). ANOVA in R | A Complete Step-by-Step
# Guide with Examples. Scribbr. Retrieved August 24, 2023, from
# https://www.scribbr.com/statistics/anova-in-r/ ----

## Bevans, R. (2023b). Sample Crop Data Dataset for ANOVA (Version 1)
## [Dataset]. Scribbr.
## https://www.scribbr.com/wp-content/uploads//2020/03/crop.data_.anova_.zip
## ----

## Fisher, R. A. (1988). Iris [Dataset]. UCI Machine Learning Repository.
## https://archive.ics.uci.edu/dataset/53/iris ----

## National Institute of Diabetes and Digestive and Kidney Diseases. (1999).
## Pima Indians Diabetes Dataset [Dataset]. UCI Machine Learning Repository.
## https://www.kaggle.com/datasets/uciml/ ----

## StatLib CMU. (1997). Boston Housing [Dataset]. StatLib Carnegie Mellon
## University. http://lib.stat.cmu.edu/datasets/boston_corrected.txt ----

# 2: Inferential Statistics ----

# STEP 1. Install and use renv ---- **Initialization: Install and use renv ----
# The renv package helps you create reproducible environments for your



# As you continue to work on your project, you can install and upgrade
# packages, using either: install.packages() and update.packages or
# renv::install() and renv::update()

# You can also clean up a project by removing unused packages using the
# following command: renv::clean()

# After you have confirmed that your code works as expected, use
# renv::snapshot() to record the packages and their sources in the lockfile.

# One of the packages required to use R in VS Code is the 'languageserver'
# package. It can be installed manually as follows if you are not using the
# renv::restore() command.
if (!is.element("languageserver", installed.packages()[, 1])) {
    install.packages("languageserver", dependencies = TRUE)
}
require("languageserver")

# Loading Datasets ---- STEP 2: Load datasets ----

library(readr)
loans <- read_csv("C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/data/loans_imputed.csv")

View(loans)

## Step 1; Perform ANOVA on the “loans_imputed_dataset” dataset ---- ANOVA
## (Analysis of Variance) is a statistical test used to estimate how a
## quantitative dependent variable changes according to the levels of one or
## more categorical independent variables.

# The null hypothesis (H0) of the ANOVA is that “there is no difference in
# means”, and the alternative hypothesis (Ha) is that “the means are different
# from one another”.

# We can use the “aov()” function in R to calculate the test statistic for
# ANOVA. The test statistic is in turn used to calculate the p-value of your
# results. A p-value is a number that describes how likely you are to have
# found a particular set of observations if the null hypothesis were true. The
# smaller the p-value, the more likely you are to reject the null-hypothesis.

# The “crop_dataset” sample dataset loaded in STEP 4 contains observations from
# an imaginary study of the effects of fertilizer type and planting density on
# crop yield. In other words:

# Dependent variable:\tStatus


# One-Way ANOVA can be used to test the effect of the 3 types of Property Areas
# on Credit History whereas, Two-Way ANOVA can be used to test the effect of
# the 3 types of fertilizer and the 2 types of planting density on crop yield.
summary(loans$Status)

summary(loans$Gender)

loans_dataset_one_way_anova <- aov(CreditHistory ~ PropertyArea, data = loans)
summary(loans_dataset_one_way_anova)

# This shows the result of each variable and the residual. The residual refers
# to all the variation that is not explained by the independent variable. The
# list below is a description of each column in the result:

# 1.  Df column: Displays the degrees of freedom for the independent variable
# (the number of levels (categories) in the variable minus 1), and the degrees
# of freedom for the residuals (the total number of observations minus the
# number of variables being estimated + 1, i.e., (df(Residuals)=n-(k+1)).

# 2.\tSum Sq column: Displays the sum of squares (a.k.a. the total variation
# between the group means and the overall mean). It is better to have a lower
# Sum Sq value for residuals.

# 3.  Mean Sq column: The mean of the sum of squares, calculated by dividing
# the sum of squares by the degrees of freedom for each parameter.

# 4.\tF value column: The test statistic from the F test. This is the mean
# square of each independent variable divided by the mean square of the
# residuals. The larger the F value, the more likely it is that the variation
# caused by the independent variable is real and not due to chance.

# 5.\tPr(>F) column: The p-value of the F statistic. This shows how likely it
# is that the F value calculated from the test would have occurred if the null
# hypothesis of “no difference among group means” were true.

# The three asterisk symbols (***) implies that the p-value is less than 0.001.
# P<0.001 can be interpreted as “the type of fertilizer used has an impact on
# the final crop yield”.

# We can also have a situation where the Credit History depends not only on the
# type of Property Area used but also on the Dependents. A two-way ANOVA can
# then be used to confirm this. Execute the following for a two-way ANOVA (two
# independent variables):

loans_dataset_additive_two_way_anova <- aov(CreditHistory ~ PropertyArea + Dependents,
    data = loans)
summary(loans_dataset_additive_two_way_anova)

# Specifying an asterisk (*) instead of a plus (+) between the two independent
# variables (fertilizer * density) implies that they have an interaction effect
# rather than an additive effect.

# For example, an interaction effect would be that the fertilizer uptake by
# plants is affected by how close the plants are planted (density). An additive
# effect would be that the fertilizer uptake by plants is NOT affected by how
# close the plants are planted (density).

# Execute the following to perform a two-way ANOVA with the assumption that
# Credit History and Dependents have an interaction effect:

loans_dataset_interactive_two_way_anova <- aov(CreditHistory ~ PropertyArea * Dependents,
    data = loans)
summary(loans_dataset_interactive_two_way_anova)

# This can be interpreted as follows: The additive two-way ANOVA shows that the
# Credit History is affected by both the Property Area and the Dependents
# (P<0.001 for both independent variables).  The interactive two-way ANOVA also
# shows that the Credit History is affected by both the Property Area and the
# Dependents (P<0.001 for both independent variables).


# Qualitative Data Analysis ---- This can be done through either thematic
# analysis: https://www.scribbr.com/methodology/thematic-analysis/ or critical
# discourse analysis: https://www.scribbr.com/methodology/discourse-analysis/

# Basic Visualization for Understanding the Dataset ----

# Note: If you are using R Studio, ensure that the 'Plots' window on the bottom
# right of R Studio has enough space to display the chart.

# The fastest way to improve your understanding of the dataset is to visualize
# it. Visualization can help you to spot outliers and give you an idea of
# possible data transformations you can apply. The basic visualizations to
# understand your dataset can be univariate visualizations (helps you to
# understand a single attribute) or multivariate visualizations (helps you to
# understand the interaction between attributes). Packages used to create
# visualizations include: (i)\t Graphics package: Used to quickly create basic
# plots of data. This is the most appropriate to quickly understand the dataset
# before conducting further analysis.  (ii) Lattice package: Used to create
# more visually appealing plots of data.  (iii) ggplot2 package: Used to create
# even more visually appealing plots of data that can then be used to present
# the analysis results to the intended users. Given its complexity, it is not
# necessary to use ggplot2 to have a basic understanding of the dataset prior
# to further analysis.

# *****************************************************************************
# 3: Basic Visualization ----


# One of the packages required to use R in VS Code is the 'languageserver'
# package. It can be installed manually as follows if you are not using the
# renv::restore() command.
if (!is.element("languageserver", installed.packages()[, 1])) {
    install.packages("languageserver", dependencies = TRUE)
}
require("languageserver")

# Loading Datasets ---- STEP 2: Load datasets ----

library(readr)
loans <- read_csv("C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/data/loans_imputed.csv")

View(loans)

## Univariate Plots ---- STEP 1. Create Histograms for Each Numeric Attribute
## ---- Histograms help in determining whether an attribute has a Gaussian
## distribution. They can also be used to identify the presence of outliers.

# Execute the following code to create histograms for the “loans” dataset:
# Assuming your dataset is named 'loans' (replace with the actual name of your
# dataset)
data_types <- sapply(loans, class)
print(data_types)

# Execute the following code to create one histogram for attribute 4 (the only
# numeric column was “final crop yield (in bushels per acre)”) in the “: The
# code below converts column number 4 into unlisted and numeric data first so
# that a histogram can be plotted. Further reading:
# https://www.programmingr.com/r-error-messages/x-must-be-numeric-error-in-r-histogram/
# )


# Loans_status <- as.numeric(unlist(loans[, 6:7])) hist(Loans_status, main =
# names(loans)[, 6:7])



### STEP 2. Create Box and Whisker Plots for Each Numeric Attribute ---- Box
### and whisker plots are useful in understanding the distribution of data.
### Further reading: https://www.scribbr.com/statistics/interquartile-range/

class(loans)

summary(loans)

colnames(loans)

par(mar = c(3, 3, 2, 1))

par(mfrow = c(6, 7))
for (i in 6:7) {
    boxplot(loans[, i], main = names(loans)[i])
}

# This considers the 6th to the 7th attributes which are numeric.  The fourth
# attribute in the dataset is of the type “factor”, i.e., categorical

boxplot(loans[, 6], main = names(loans)[6])
boxplot(loans[, 7], main = names(loans)[7])
boxplot(loans[, 8], main = names(loans)[8])
boxplot(loans[, 9], main = names(loans)[9])
boxplot(loans[, 10], main = names(loans)[10])



### STEP 3. Create Bar Plots for Each Categorical Attribute ---- Categorical
### attributes (factors) can also be visualized. This is done using a bar chart
### to give an idea of the proportion of instances that belong to each
### category.


barplot(table(loans[, 10]), main = names(loans)[10])

# Execute the following to create a bar plot for the categorical attributes 1
# to 11 in the “loans” dataset:
par(mar = c(3, 3, 2, 1))

par(mfrow = c(1, 5))

for (i in 1:5) {
    barplot(table(loans[, i]), main = names(loans)[i])
}

### STEP 4. Create a Missingness Map to Identify Missing Data ---- Some machine
### learning algorithms cannot handle missing data. A missingness map (also
### known as a missing plot) can be used to get an idea of the amount missing
### data in the dataset. The x-axis of the missingness map shows the attributes
### of the dataset whereas the y-axis shows the instances in the dataset.
### Horizontal lines indicate missing data for an instance whereas vertical
### lines indicate missing data for an attribute. The missingness map requires
### the “Amelia” package.

# Execute the following to create a map to identify the missing data in each
# dataset:
if (!is.element("Amelia", installed.packages()[, 1])) {
    install.packages("Amelia", dependencies = TRUE)
}
require("Amelia")

missmap(loans, col = c("red", "grey"), legend = TRUE)

# As shown in the results, the datasets that was loaded in this lab has no
# missing data.

## Multivariate Plots ----

### STEP 5. Create a Correlation Plot ---- Correlation plots can be used to get
### an idea of which attributes change together. The function “corrplot()”
### found in the package “corrplot” is required to perform this. The larger the
### dot in the correlation plot, the larger the correlation. Blue represents a
### positive correlation whereas red represents a negative correlation.

# Execute the following to create correlation plots for 3 of the datasets
# loaded in STEP 2 to STEP 4:
if (!is.element("corrplot", installed.packages()[, 1])) {
    install.packages("corrplot", dependencies = TRUE)
}
require("corrplot")
corrplot(cor(loans[, 6:10]), method = "circle")


# Alternatively, the 'ggcorrplot::ggcorrplot()' function can be used to plot a
# more visually appealing plot.  The code below shows how to install a package
# in R:
if (!is.element("ggcorrplot", installed.packages()[, 1])) {
    install.packages("ggcorrplot", dependencies = TRUE)
}
require("ggcorrplot")
ggcorrplot(cor(loans[, 6:10]))


# Alternatively, the ggcorrplot package can be used to make the plots more
# appealing:
ggplot(loans, aes(x = Dependents, y = Education, shape = Status, color = Status)) +
    geom_point() + geom_smooth(method = lm)

### STEP 6. Create Multivariate Box and Whisker Plots by Class ---- This
### applies to datasets where the target (dependent) variable is categorical.
### Execute the following code:
if (!is.element("caret", installed.packages()[, 1])) {
    install.packages("caret", dependencies = TRUE)
}
require("caret")
featurePlot(x = loans[, 1:12], y = loans[, 12], plot = "box")

# References ---- Bevans, R. (2023a). ANOVA in R | A Complete Step-by-Step
# Guide with Examples. Scribbr. Retrieved August 24, 2023, from
# https://www.scribbr.com/statistics/anova-in-r/ ----

## Bevans, R. (2023b). Sample Crop Data Dataset for ANOVA (Version 1)
## [Dataset]. Scribbr.
## https://www.scribbr.com/wp-content/uploads//2020/03/crop.data_.anova_.zip
## ----

## Fisher, R. A. (1988). Iris [Dataset]. UCI Machine Learning Repository.
## https://archive.ics.uci.edu/dataset/53/iris ----

## National Institute of Diabetes and Digestive and Kidney Diseases. (1999).
## Pima Indians Diabetes Dataset [Dataset]. UCI Machine Learning Repository.
## https://www.kaggle.com/datasets/uciml/ ----

## StatLib CMU. (1997). Boston Housing [Dataset]. StatLib Carnegie Mellon
## University. http://lib.stat.cmu.edu/datasets/boston_corrected.txt ----


# Upload *the link* to 'Lab-Submission-Markdown.md' (not .Rmd) markdown file
# hosted on Github (do not upload the .Rmd or .md markdown files) through the
# submission link provided on eLearning.

# 5: Data Imputation ----

# This can also be configured using the RStudio GUI when you click the project
# file, e.g., 'BBT4206-R.Rproj' in the case of this project. Then navigate to
# the 'Environments' tab and select 'Use renv with this project'.

# As you continue to work on your project, you can install and upgrade
# packages, using either: install.packages() and update.packages or
# renv::install() and renv::update()

# You can also clean up a project by removing unused packages using the
# following command: renv::clean()

# After you have confirmed that your code works as expected, use
# renv::snapshot(), AT THE END, to record the packages and their sources in the
# lockfile.

# Later, if you need to share your code with someone else or run your code on a
# new machine, your collaborator (or you) can call renv::restore() to reinstall
# the specific package versions recorded in the lockfile.

# [OPTIONAL] Execute the following code to reinstall the specific package
# versions recorded in the lockfile (restart R after executing the command):
# renv::restore()

# [OPTIONAL] If you get several errors setting up renv and you prefer not to
# use it, then you can deactivate it using the following command (restart R
# after executing the command): renv::deactivate()

# If renv::restore() did not install the 'languageserver' package (required to
# use R for VS Code), then it can be installed manually as follows (restart R
# after executing the command):

if (!is.element("languageserver", installed.packages()[, 1])) {
    install.packages("languageserver", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("languageserver")

# Introduction ---- Data imputation, also known as missing data imputation, is
# a technique used in data analysis and statistics to fill in missing values in
# a dataset.  Missing data can occur due to various reasons, such as equipment
# malfunction, human error, or non-response in surveys.

# Imputing missing data is important because many statistical analysis methods
# and Machine Learning algorithms require complete datasets to produce accurate
# and reliable results. By filling in the missing values, data imputation helps
# to preserve the integrity and usefulness of the dataset.

## Data Imputation Methods ----

### 1. Mean/Median Imputation ----

# This method involves replacing missing values with the mean or median value
# of the available data for that variable. It is a simple and quick approach
# but does not consider any relationships between variables.

# Unlike the recorded values, mean-imputed values do not include natural
# variance. Therefore, they are less “scattered” and would technically minimize
# the standard error in a linear regression. We would perceive our estimates to
# be more accurate than they actually are in real-life.

### 2. Regression Imputation ---- In this approach, missing values are
### estimated by regressing the variable with missing values on other variables
### that are known. The estimated values are then used to fill in the missing
### values.

### 3. Multiple Imputation ---- Multiple imputation involves creating several
### plausible imputations for each missing value based on statistical models
### that capture the relationships between variables. This technique recognizes
### the uncertainty associated with imputing missing values.

### 4. Machine Learning-Based Imputation ---- Machine learning algorithms can
### be used to predict missing values based on the patterns and relationships
### present in the available data. Techniques such as K-Nearest Neighbours
### (KNN) imputation or decision tree-based imputation can be employed.

### 5. Hot Deck Imputation ---- This method involves finding similar cases
### (referred to as donors) that have complete data and using their values to
### impute missing values in other cases (referred to as recipients).

### 6. Multiple Imputation by Chained Equations (MICE) ---- MICE is flexible
### and can handle different variable types at once (e.g., continuous, binary,
### ordinal etc.). For each variable containing missing values, we can use the
### remaining information in the data to train a model that predicts what could
### have been recorded to fill in the blanks.  To account for the statistical
### uncertainty in the imputations, the MICE procedure goes through several
### rounds and computes replacements for missing values in each round. As the
### name suggests, we thus fill in the missing values multiple times and create
### several complete datasets before we pool the results to arrive at more
### realistic results.

## Types of Missing Data ---- 1. Missing Not At Random (MNAR) ---- Locations of
## missing values in the dataset depend on the missing values themselves. For
## example, students submitting a course evaluation tend to report positive or
## neutral responses and skip questions that will result in a negative
## response. Such students may systematically leave the following question
## blank because they are uncomfortable giving a bad rating for their lecturer:
## “Classes started and ended on time”.

### 2. Missing At Random (MAR) ---- Locations of missing values in the dataset
### depend on some other observed data. In the case of course evaluations,
### students who are not certain about a response may feel unable to give
### accurate responses on a numeric scale, for example, the question 'I
### developed my oral and writing skills ' may be difficult to measure on a
### scale of 1-5. Subsequently, if such questions are optional, they rarely get
### a response because it depends on another unobserved mechanism: in this
### case, the individual need for more precise self-assessments.

### 3. Missing Completely At Random (MCAR) ---- In this case, the locations of
### missing values in the dataset are purely random and they do not depend on
### any other data.

# In all the above cases, removing the entire response because one question has
# missing data may distort the results.

# If the data are MAR or MNAR, imputing missing values is advisable.

# STEP 1. Install and Load the Required Packages ---- The following packages
# should be installed and loaded before proceeding to the subsequent steps.

## NHANES ---- The dataset we will use (for educational purposes) is the US
## National Health and Nutrition Examination Study (NHANES) dataset created
## from 1999 to 2004.

# Documentation of NHANES: https://cran.r-project.org/package=NHANES or
# https://cran.r-project.org/web/packages/NHANES/NHANES.pdf or
# http://www.cdc.gov/nchs/nhanes.htm

# This requires the 'NHANES' package available in R

if (!is.element("NHANES", installed.packages()[, 1])) {
    install.packages("NHANES", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("NHANES")

## dplyr ----
if (!is.element("dplyr", installed.packages()[, 1])) {
    install.packages("dplyr", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("dplyr")

## naniar ---- Documentation: https://cran.r-project.org/package=naniar or
## https://www.rdocumentation.org/packages/naniar/versions/1.0.0
if (!is.element("naniar", installed.packages()[, 1])) {
    install.packages("naniar", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("naniar")

## ggplot2 ---- We require the 'ggplot2' package to create more appealing
## visualizations
if (!is.element("ggplot2", installed.packages()[, 1])) {
    install.packages("ggplot2", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("ggplot2")

## MICE ---- We use the MICE package to perform data imputation
if (!is.element("mice", installed.packages()[, 1])) {
    install.packages("mice", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("mice")

## Amelia ----
if (!is.element("Amelia", installed.packages()[, 1])) {
    install.packages("Amelia", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("Amelia")

# STEP 2. We Load the dataset ----
library(readr)
loans <- read_csv("C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/data/Loans.csv")

View(loans)

# STEP 3. Confirm the 'missingness' in the Dataset before Imputation ---- Are
# there missing values in the dataset?
any_na(loans)

# How many?
n_miss(loans)

# What is the percentage of missing data in the entire dataset?
prop_miss(loans)

# How many missing values does each variable have?
loans %>%
    is.na() %>%
    colSums()

# What is the number and percentage of missing values grouped by each variable?
miss_var_summary(loans)

# What is the number and percentage of missing values grouped by each
# observation?
miss_case_summary(loans)

# Which variables contain the most missing values?
gg_miss_var(loans)

# Where are missing values located (the shaded regions in the plot)?
vis_miss(loans) + theme(axis.text.x = element_text(angle = 80))

# Which combinations of variables are missing together?
gg_miss_upset(loans)

# Create a heatmap of 'missingness' broken down by 'SelfEmployed' First,
# confirm that the 'SelfEmployed' variable is a categorical variable
data_types <- sapply(loans, class)
print(data_types)

is.factor(loans$SelfEmployed)

# Second, create the visualization
gg_miss_fct(loans, fct = SelfEmployed)

# We can also create a heatmap of 'missingness' broken down by 'Dependents'
# First, confirm that the 'Dependents' variable is a categorical variable
is.factor(loans$Dependents)

# Second, create the visualization
gg_miss_fct(loans, fct = Dependents)

# 5b: Data Imputation ----

# This can also be configured using the RStudio GUI when you click the project
# file, e.g., 'BBT4206-R.Rproj' in the case of this project. Then navigate to
# the 'Environments' tab and select 'Use renv with this project'.

# As you continue to work on your project, you can install and upgrade
# packages, using either: install.packages() and update.packages or
# renv::install() and renv::update()

# You can also clean up a project by removing unused packages using the
# following command: renv::clean()

# After you have confirmed that your code works as expected, use
# renv::snapshot(), AT THE END, to record the packages and their sources in the
# lockfile.

# Later, if you need to share your code with someone else or run your code on a
# new machine, your collaborator (or you) can call renv::restore() to reinstall
# the specific package versions recorded in the lockfile.

# [OPTIONAL] Execute the following code to reinstall the specific package
# versions recorded in the lockfile (restart R after executing the command):
# renv::restore()

# [OPTIONAL] If you get several errors setting up renv and you prefer not to
# use it, then you can deactivate it using the following command (restart R
# after executing the command): renv::deactivate()

# If renv::restore() did not install the 'languageserver' package (required to
# use R for VS Code), then it can be installed manually as follows (restart R
# after executing the command):

if (!is.element("languageserver", installed.packages()[, 1])) {
    install.packages("languageserver", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("languageserver")

# Introduction ---- Data imputation, also known as missing data imputation, is
# a technique used in data analysis and statistics to fill in missing values in
# a dataset.  Missing data can occur due to various reasons, such as equipment
# malfunction, human error, or non-response in surveys.

# Imputing missing data is important because many statistical analysis methods
# and Machine Learning algorithms require complete datasets to produce accurate
# and reliable results. By filling in the missing values, data imputation helps
# to preserve the integrity and usefulness of the dataset.

## Data Imputation Methods ----

### 1. Mean/Median Imputation ----

# This method involves replacing missing values with the mean or median value
# of the available data for that variable. It is a simple and quick approach
# but does not consider any relationships between variables.

# Unlike the recorded values, mean-imputed values do not include natural
# variance. Therefore, they are less “scattered” and would technically minimize
# the standard error in a linear regression. We would perceive our estimates to
# be more accurate than they actually are in real-life.

### 2. Regression Imputation ---- In this approach, missing values are
### estimated by regressing the variable with missing values on other variables
### that are known. The estimated values are then used to fill in the missing
### values.

### 3. Multiple Imputation ---- Multiple imputation involves creating several
### plausible imputations for each missing value based on statistical models
### that capture the relationships between variables. This technique recognizes
### the uncertainty associated with imputing missing values.

### 4. Machine Learning-Based Imputation ---- Machine learning algorithms can
### be used to predict missing values based on the patterns and relationships
### present in the available data. Techniques such as K-Nearest Neighbours
### (KNN) imputation or decision tree-based imputation can be employed.

### 5. Hot Deck Imputation ---- This method involves finding similar cases
### (referred to as donors) that have complete data and using their values to
### impute missing values in other cases (referred to as recipients).

### 6. Multiple Imputation by Chained Equations (MICE) ---- MICE is flexible
### and can handle different variable types at once (e.g., continuous, binary,
### ordinal etc.). For each variable containing missing values, we can use the
### remaining information in the data to train a model that predicts what could
### have been recorded to fill in the blanks.  To account for the statistical
### uncertainty in the imputations, the MICE procedure goes through several
### rounds and computes replacements for missing values in each round. As the
### name suggests, we thus fill in the missing values multiple times and create
### several complete datasets before we pool the results to arrive at more
### realistic results.

## Types of Missing Data ---- 1. Missing Not At Random (MNAR) ---- Locations of
## missing values in the dataset depend on the missing values themselves. For
## example, students submitting a course evaluation tend to report positive or
## neutral responses and skip questions that will result in a negative
## response. Such students may systematically leave the following question
## blank because they are uncomfortable giving a bad rating for their lecturer:
## “Classes started and ended on time”.

### 2. Missing At Random (MAR) ---- Locations of missing values in the dataset
### depend on some other observed data. In the case of course evaluations,
### students who are not certain about a response may feel unable to give
### accurate responses on a numeric scale, for example, the question 'I
### developed my oral and writing skills ' may be difficult to measure on a
### scale of 1-5. Subsequently, if such questions are optional, they rarely get
### a response because it depends on another unobserved mechanism: in this
### case, the individual need for more precise self-assessments.

### 3. Missing Completely At Random (MCAR) ---- In this case, the locations of
### missing values in the dataset are purely random and they do not depend on
### any other data.

# In all the above cases, removing the entire response because one question has
# missing data may distort the results.

# If the data are MAR or MNAR, imputing missing values is advisable.

# STEP 1. Install and Load the Required Packages ---- The following packages
# should be installed and loaded before proceeding to the subsequent steps.

## NHANES ---- The dataset we will use (for educational purposes) is the US
## National Health and Nutrition Examination Study (NHANES) dataset created
## from 1999 to 2004.

# Documentation of NHANES: https://cran.r-project.org/package=NHANES or
# https://cran.r-project.org/web/packages/NHANES/NHANES.pdf or
# http://www.cdc.gov/nchs/nhanes.htm

# This requires the 'NHANES' package available in R

if (!is.element("NHANES", installed.packages()[, 1])) {
    install.packages("NHANES", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("NHANES")

## dplyr ----
if (!is.element("dplyr", installed.packages()[, 1])) {
    install.packages("dplyr", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("dplyr")

## naniar ---- Documentation: https://cran.r-project.org/package=naniar or
## https://www.rdocumentation.org/packages/naniar/versions/1.0.0
if (!is.element("naniar", installed.packages()[, 1])) {
    install.packages("naniar", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("naniar")

## ggplot2 ---- We require the 'ggplot2' package to create more appealing
## visualizations
if (!is.element("ggplot2", installed.packages()[, 1])) {
    install.packages("ggplot2", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("ggplot2")

## MICE ---- We use the MICE package to perform data imputation
if (!is.element("mice", installed.packages()[, 1])) {
    install.packages("mice", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("mice")

## Amelia ----
if (!is.element("Amelia", installed.packages()[, 1])) {
    install.packages("Amelia", dependencies = TRUE, repos = "https://cloud.r-project.org")
}
require("Amelia")

# STEP 2. We Load the dataset ----
library(readr)
loans <- read_csv("C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/data/Loans.csv")

View(loans)

# We can use the dplyr::mutate() function inside the dplyr package to add new
# variables that are functions of existing variables


# We finally begin to make use of Multivariate Imputation by Chained Equations
# (MICE). We use 11 multiple imputations.

# To arrive at good predictions for each variable containing missing values, we
# save the variables that are at least 'somewhat correlated' (r > 0.3).
somewhat_correlated_variables <- quickpred(loans, mincor = 0.3)

# m = 11 Specifies that the imputation (filling in the missing data) will be
# performed 11 times (multiple times) to create several complete datasets
# before we pool the results to arrive at a more realistic final result. The
# larger the value of 'm' and the larger the dataset, the longer the data
# imputation will take.  seed = 7 Specifies that number 7 will be used to
# offset the random number generator used by mice. This is so that we get the
# same results each time we run MICE.  meth = 'pmm' Specifies the imputation
# method. 'pmm' stands for 'Predictive Mean Matching' and it can be used for
# numeric data.  Other methods include: 1. 'logreg': logistic regression
# imputation; used for binary categorical data 2. 'polyreg': Polytomous
# Regression Imputation for unordered categorical data with more than 2
# categories, and 3. 'polr': Proportional Odds model for ordered categorical
# data with more than 2 categories.


loans_mice <- mice(loans, m = 20, method = "pmm", seed = 7, predictorMatrix = somewhat_correlated_variables)

# One can then train a model to predict MAP using BMI and PhysActiveDays or to
# identify the p-Value and confidence intervals between MAP and BMI and
# PhysActiveDays


## Impute the missing data ---- We then create imputed data for the final
## dataset using the mice::complete() function in the mice package to fill in
## the missing data.
loans_imputed <- mice::complete(loans_mice, 1)

# STEP 5. Confirm the 'missingness' in the Imputed Dataset ---- A textual
# confirmation that the dataset has no more missing values in any feature:
miss_var_summary(loans_imputed)

# A visual confirmation that the dataset has no more missing values in any
# feature:
Amelia::missmap(loans_imputed)

######################### Are there missing values in the dataset?
any_na(loans_imputed)

# How many?
n_miss(loans_imputed)

# What is the percentage of missing data in the entire dataset?
prop_miss(loans_imputed)

# How many missing values does each variable have?
loans_imputed %>%
    is.na() %>%
    colSums()

# What is the number and percentage of missing values grouped by each variable?
miss_var_summary(loans_imputed)

# What is the number and percentage of missing values grouped by each
# observation?
miss_case_summary(loans_imputed)

# Which variables contain the most missing values?
gg_miss_var(loans_imputed)

# We require the 'ggplot2' package to create more appealing visualizations

# Where are missing values located (the shaded regions in the plot)?
vis_miss(loans_imputed) + theme(axis.text.x = element_text(angle = 80))

# Which combinations of variables are missing together?

# Note: The following command should give you an error stating that at least 2
# variables should have missing data for the plot to be created.
# gg_miss_upset(loans_imputed)

# 7. Hyper Parameter Tuning and Ensemble Methods ----


# After you have confirmed that your code works as expected, use
# renv::snapshot(), AT THE END, to record the packages and their sources in the
# lockfile.

# Later, if you need to share your code with someone else or run your code on a
# new machine, your collaborator (or you) can call renv::restore() to reinstall
# the specific package versions recorded in the lockfile.

# [OPTIONAL] Execute the following code to reinstall the specific package
# versions recorded in the lockfile (restart R after executing the command):
# renv::restore()

# [OPTIONAL] If you get several errors setting up renv and you prefer not to
# use it, then you can deactivate it using the following command (restart R
# after executing the command): renv::deactivate()

# If renv::restore() did not install the 'languageserver' package (required to
# use R for VS Code), then it can be installed manually as follows (restart R
# after executing the command):

if (require("languageserver")) {
    require("languageserver")
} else {
    install.packages("languageserver", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

# Introduction ---- In addition to hyperparameter tuning, you can also combine
# the predictions of multiple different models together. This is called an
# 'ensemble prediction'.

## Ensemble Methods ---- (1) Bagging (Bootstrap Aggregation) ---- Building
## multiple models (typically models of the same type) from different
## subsamples of the training dataset.

### (2) Boosting ---- Building multiple models (typically models of the same
### type) each of which learns to fix the prediction errors of a prior model in
### the chain.

### (3) Stacking ---- Building multiple models (typically models of differing
### types) and a supervised model that learns how to best combine the
### predictions of the primary models.

# STEP 1. Install and Load the Required Packages ---- mlbench ----
if (require("mlbench")) {
    require("mlbench")
} else {
    install.packages("mlbench", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## caret ----
if (require("caret")) {
    require("caret")
} else {
    install.packages("caret", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## caretEnsemble ----
if (require("caretEnsemble")) {
    require("caretEnsemble")
} else {
    install.packages("caretEnsemble", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## C50 ----
if (require("C50")) {
    require("C50")
} else {
    install.packages("C50", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## adabag ----
if (require("adabag")) {
    require("adabag")
} else {
    install.packages("adabag", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## randomForest ----
if (require("randomForest")) {
    require("randomForest")
} else {
    install.packages("randomForest", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## mlbench ----
if (require("mlbench")) {
    require("mlbench")
} else {
    install.packages("mlbench", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## caret ----
if (require("caret")) {
    require("caret")
} else {
    install.packages("caret", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## RRF ----
if (require("RRF")) {
    require("RRF")
} else {
    install.packages("RRF", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

if (!requireNamespace("gbm", quietly = TRUE)) {
    install.packages("gbm")
}


# STEP 2. Load the Dataset ----
library(readr)
loans <- read_csv("C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/data/loans_imputed.csv")

View(loans)


# 1. Bagging ---- Two popular bagging algorithms are: 1. Bagged CART 2. Random
# Forest

# Example of Bagging algorithms
train_control <- trainControl(method = "repeatedcv", number = 10, repeats = 3)
seed <- 7
metric <- "Accuracy"

## 2.a. Bagged CART ----
set.seed(seed)
loans_model_bagged_cart <- train(Status ~ ., data = loans, method = "treebag", metric = metric,
    trControl = train_control)

## 2.b. Random Forest ----
set.seed(seed)
loans_model_rf <- train(Status ~ ., data = loans, method = "rf", metric = metric,
    trControl = train_control)

# Summarize results
bagging_results <- resamples(list(`Bagged Decision Tree` = loans_model_bagged_cart,
    `Random Forest` = loans_model_rf))

summary(bagging_results)

dotplot(bagging_results)

# 2. Boosting ---- Three popular boosting algorithms are: 1. AdaBoost.M1 2.
# C5.0 3. Stochastic Gradient Boosting

# Example of Boosting Algorithms
train_control <- trainControl(method = "cv", number = 5)
seed <- 7
metric <- "Accuracy"

## 1.a. Boosting with C5.0 ---- C5.0
set.seed(seed)
loans_model_c50 <- train(Status ~ ., data = loans, method = "C5.0", metric = metric,
    trControl = train_control)

## 1.b. Boosting with Stochastic Gradient Boosting ----
set.seed(seed)
loans_model_gbm <- train(Status ~ ., data = loans, method = "gbm", metric = metric,
    trControl = train_control, verbose = FALSE)


# 3. Stacking ---- The 'caretEnsemble' package allows you to combine the
# predictions of multiple caret models.

## caretEnsemble::caretStack() ---- Given a list of caret models, the
## 'caretStack()' function (in the 'caretEnsemble' package) can be used to
## specify a higher-order model to learn how to best combine together the
## predictions of sub-models.

## caretEnsemble::caretList() ---- The 'caretList()' function provided by the
## 'caretEnsemble' package can be used to create a list of standard caret
## models.

# Example of Stacking algorithms
train_control <- trainControl(method = "repeatedcv", number = 10, repeats = 3, savePredictions = TRUE,
    classProbs = TRUE)
set.seed(seed)

algorithm_list <- c("glm", "lda", "rpart", "knn", "svmRadial")
models <- caretList(Status ~ ., data = loans, trControl = train_control, methodList = algorithm_list)

# Summarize results before stacking
results <- resamples(models)
summary(results)

dotplot(results)

# The predictions made by the sub-models that are combined using stacking
# should have a low-correlation (for diversity amongst the sub-models, i.e.,
# different sub-models are accurate in different ways). If the predictions for
# the sub-models were highly correlated (> 0.75) then they would be making the
# same or very similar predictions most of the time reducing the benefit of
# combining the predictions.

# correlation between results
modelCor(results)

splom(results)

## 3.a. Stack using glm ----
stack_control <- trainControl(method = "repeatedcv", number = 10, repeats = 3, savePredictions = TRUE,
    classProbs = TRUE)
set.seed(seed)
loans_model_stack_glm <- caretStack(models, method = "glm", metric = "Accuracy",
    trControl = stack_control)
print(loans_model_stack_glm)

## 3.b. Stack using random forest ----
set.seed(seed)
loans_model_stack_rf <- caretStack(models, method = "rf", metric = "Accuracy", trControl = stack_control)
print(loans_model_stack_rf)

# 4 Hyperparameter Tuning ----

# Introduction ---- Hyperparameter tuning involves identifying and applying the
# best combination of algorithm parameters. Only the algorithm parameters that
# have a significant effect on the model's performance are available for
# tuning.


# STEP 3. Train the Model ---- The default random forest algorithm exposes the
# 'mtry' parameter to be tuned.

## The 'mtry' parameter ---- Number of variables randomly sampled as candidates
## at each split.

# This can be confirmed from here:
# https://topepo.github.io/caret/available-models.html or by executing the
# following command: names(getModelInfo())

# We start by identifying the accuracy by using the recommended defaults for
# each parameter, i.e., mtry=floor(sqrt(ncol(sonar_independent_variables))) or
# mtry=7

seed <- 7
metric <- "Accuracy"

train_control <- trainControl(method = "repeatedcv", number = 10, repeats = 3)
set.seed(seed)
mtry <- sqrt(ncol(loans))
tunegrid <- expand.grid(.mtry = mtry)
loans_model_default_rf <- train(Status ~ ., data = loans, method = "rf", metric = metric,
    tuneGrid = tunegrid, trControl = train_control)
print(loans_model_default_rf)

# STEP 4. Apply a 'Random Search' to identify the best parameter value ---- A
# random search is good if we are unsure of what the value might be and we want
# to overcome any biases we may have for setting the parameter value (like the
# suggested 'mtry' equation above).

train_control <- trainControl(method = "repeatedcv", number = 10, repeats = 3, search = "random")
set.seed(seed)
mtry <- sqrt(ncol(loans))

loans_model_random_search_rf <- train(Status ~ ., data = loans, method = "rf", metric = metric,
    tuneLength = 12, trControl = train_control)

print(loans_model_random_search_rf)

plot(loans_model_random_search_rf)

# STEP 5. Apply a 'Grid Search' to identify the best parameter value ---- Each
# axis of the grid is an algorithm parameter, and points on the grid are
# specific combinations of parameters.

train_control <- trainControl(method = "repeatedcv", number = 10, repeats = 3, search = "grid")
set.seed(seed)

getModelInfo("RRFglobal")

# The Regularized Random Forest algorithm exposes the 'coefReg' parameter in
# addition to the 'mtry' parameter for tuning.  The 'mtry' parameter ----
# Number of variables randomly sampled as candidates at each split.

## The 'coefReg' parameter ---- It stands for coefficient(s) of regularization.
## A smaller coefficient may lead to a smaller feature subset, i.e., there are
## fewer variables with non-zero importance scores. coefReg must be either a
## single value (all variables have the same coefficient) or a numeric vector
## of length equal to the number of predictor variables. default: 0.8

tunegrid <- expand.grid(.mtry = c(1:10), .coefReg = seq(from = 0.1, to = 1, by = 0.1))

loans_model_grid_search_rrf_global <- train(Status ~ ., data = loans, method = "RRFglobal",
    metric = metric, tuneGrid = tunegrid, trControl = train_control)
print(loans_model_grid_search_rrf_global)

plot(loans_model_grid_search_rrf_global)

# STEP 6. Apply a 'Manual Search' to identify the best parameter value ----
# Manual Search The 'mtry' parameter ---- Number of variables randomly sampled
# as candidates at each split.

## The 'ntree' parameter ---- Number of trees to grow. It is limited by the
## amount of compute time available.

# We randomly search for a value for the mtry parameter but we manually search
# for a value for the ntree parameter.

train_control <- trainControl(method = "repeatedcv", number = 10, repeats = 3, search = "random")

tunegrid <- expand.grid(.mtry = c(1:5))

modellist <- list()
for (ntree in c(500, 800, 1000)) {
    set.seed(seed)
    loans_model_manual_search_rf <- train(Status ~ ., data = loans, method = "rf",
        metric = metric, tuneGrid = tunegrid, trControl = train_control, ntree = ntree)
    key <- toString(ntree)
    modellist[[key]] <- loans_model_manual_search_rf
}

# Lastly, we compare results to find which parameters gave the highest accuracy
print(modellist)

results <- resamples(modellist)
summary(results)

dotplot(results)

# [OPTIONAL] **Deinitialization: Create a snapshot of the R environment ----
# Lastly, as a follow-up to the initialization step, record the packages
# installed and their sources in the lockfile so that other team-members can
# use renv::restore() to re-install the same package version in their local
# machine during their initialization step.  renv::snapshot() [OPTIONAL]
# **Deinitialization: Create a snapshot of the R environment ---- Lastly, as a
# follow-up to the initialization step, record the packages installed and their
# sources in the lockfile so that other team-members can use renv::restore() to
# re-install the same package version in their local machine during their
# initialization step.  renv::snapshot()

# *****************************************************************************
# 8: Consolidation ----

# This will set up a project library, containing all the packages you are
# currently using. The packages (and all the metadata needed to reinstall them)
# are recorded into a lockfile, renv.lock, and a .Rprofile ensures that the
# library is used every time you open the project.

# Consider a library as the location where packages are stored.  Execute the
# following command to list all the libraries available in your computer:
.libPaths()

# One of the libraries should be a folder inside the project if you are using
# renv

# Then execute the following command to see which packages are available in
# each library:
lapply(.libPaths(), list.files)

# This can also be configured using the RStudio GUI when you click the project
# file, e.g., 'BBT4206-R.Rproj' in the case of this project. Then navigate to
# the 'Environments' tab and select 'Use renv with this project'.

# As you continue to work on your project, you can install and upgrade
# packages, using either: install.packages() and update.packages or
# renv::install() and renv::update()

# You can also clean up a project by removing unused packages using the
# following command: renv::clean()

# After you have confirmed that your code works as expected, use
# renv::snapshot(), AT THE END, to record the packages and their sources in the
# lockfile.

# Later, if you need to share your code with someone else or run your code on a
# new machine, your collaborator (or you) can call renv::restore() to reinstall
# the specific package versions recorded in the lockfile.

# [OPTIONAL] Execute the following code to reinstall the specific package
# versions recorded in the lockfile (restart R after executing the command):
# renv::restore()

# [OPTIONAL] If you get several errors setting up renv and you prefer not to
# use it, then you can deactivate it using the following command (restart R
# after executing the command): renv::deactivate()

# If renv::restore() did not install the 'languageserver' package (required to
# use R for VS Code), then it can be installed manually as follows (restart R
# after executing the command):

if (require("languageserver")) {
    require("languageserver")
} else {
    install.packages("languageserver", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

# Introduction ---- What do you do after you have designed a model that is
# accurate enough to use?  This is a critical question whose answer enables the
# gap between research and practice to be addressed.

# It is possible to discover the key internal representation of a model found
# by an algorithm (e.g., the coefficients in a linear model) and use them in a
# new implementation of the prediction algorithm in another program developed
# using a programming language other than R.

# This is easier to do for simpler algorithms that use a simple representation,
# e.g., a linear model, than for algorithms that use more complex
# representations.

# 'caret' provides access to 'the best' model from a training run in the
# 'finalModel' variable.  The 'predict()' function in the 'caret' package
# automatically uses the 'finalModel' to make predictions on a new dataset. The
# data provided as the 'new dataset' can be stored in a separate file and
# loaded as a data frame.

# STEP 1. Install and Load the Required Packages ---- caret ----
if (require("caret")) {
    require("caret")
} else {
    install.packages("caret", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## mlbench ----
if (require("mlbench")) {
    require("mlbench")
} else {
    install.packages("mlbench", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## plumber ----
if (require("plumber")) {
    require("plumber")
} else {
    install.packages("plumber", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

# STEP 2. Load the Dataset ----

library(readr)
loans_imputed <- read_csv("C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/data/loans_imputed.csv")

View(loans_imputed)
# STEP 3. Train the Model ---- create an 80%/20% data split for training and
# testing datasets respectively
set.seed(9)
train_index <- createDataPartition(loans_imputed$Status, p = 0.8, list = FALSE)
loans_imputed_training <- loans_imputed[train_index, ]
loans_imputed_testing <- loans_imputed[-train_index, ]

set.seed(9)
train_control <- trainControl(method = "cv", number = 10)
loans_imputed_model_lda <- train(Status ~ ., data = loans_imputed_training, method = "lda",
    metric = "Accuracy", trControl = train_control)

# We print a summary of what caret has done
print(loans_imputed_model_lda)

# We then print the details of the model that has been created
print(loans_imputed_model_lda$finalModel)

# STEP 4. Test the Model ---- We can test the model
set.seed(9)

# Define the levels you expect in the Status variable
expected_levels <- c("Y", "N")

# Convert the Status variable to a factor with the defined levels
loans_imputed_testing[, 1:12]$Status <- factor(loans_imputed_testing[, 1:12]$Status,
    levels = expected_levels)

predictions <- predict(loans_imputed_model_lda, newdata = loans_imputed_testing)
confusionMatrix(predictions, loans_imputed_testing$Status)

print(loans_imputed_testing)

print(predictions)

# STEP 5. Save and Load your Model ---- Saving a model into a file allows you
# to load it later and use it to make predictions. Saved models can be loaded
# by calling the `readRDS()` function

saveRDS(loans_imputed_model_lda, "C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/models/saved_loans_model_lda.rds")
# The saved model can then be loaded later as follows:
loaded_loans_imputed_model_lda <- readRDS("C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/models/saved_loans_model_lda.rds")
print(loaded_loans_imputed_model_lda)

predictions_with_loaded_model <- predict(loaded_loans_imputed_model_lda, newdata = loans_imputed_testing)
confusionMatrix(predictions_with_loaded_model, loans_imputed_testing$Status)

# STEP 6. Creating Functions in R ----

# Plumber requires functions, an example of the syntax for creating a function
# in R is:

name_of_function <- function(arg) {
    # Do something with the argument called `arg`
}

# STEP 7. Make Predictions on New Data using the Saved Model ---- We can also
# create and use our own data frame as follows:
to_be_predicted <- # Create a data frame with appropriate values and types to_be_predicted
to_be_predicted <- # Create a data frame with appropriate values and types <- #
to_be_predicted <- # Create a data frame with appropriate values and types Create
to_be_predicted <- # Create a data frame with appropriate values and types a
to_be_predicted <- # Create a data frame with appropriate values and types data
to_be_predicted <- # Create a data frame with appropriate values and types frame
to_be_predicted <- # Create a data frame with appropriate values and types with
to_be_predicted <- # Create a data frame with appropriate values and types appropriate
to_be_predicted <- # Create a data frame with appropriate values and types values
to_be_predicted <- # Create a data frame with appropriate values and types and
to_be_predicted <- # Create a data frame with appropriate values and types types
to_be_predicted <- data.frame(Gender = "Male", Married = "No", Dependents = "0",
    Education = "Graduate", SelfEmployed = "Yes", ApplicantIncome = 4583, CoapplicantIncome = 1508,
    LoanAmount = 12841, LoanAmountTerm = 360, CreditHistory = 1, PropertyArea = "Urban")

# Use factor() to set factor levels if needed
to_be_predicted$Gender <- factor(to_be_predicted$Gender, levels = levels(loaded_loans_imputed_model_lda$Gender))
to_be_predicted$Married <- factor(to_be_predicted$Married, levels = levels(loaded_loans_imputed_model_lda$Married))
to_be_predicted$Education <- factor(to_be_predicted$Education, levels = levels(loaded_loans_imputed_model_lda$Education))
to_be_predicted$SelfEmployed <- factor(to_be_predicted$SelfEmployed, levels = levels(loaded_loans_imputed_model_lda$SelfEmployed))
to_be_predicted$PropertyArea <- factor(to_be_predicted$PropertyArea, levels = levels(loaded_loans_imputed_model_lda$PropertyArea))
# to_be_predicted$Dependents <- factor(to_be_predicted$Dependents, levels =
# levels(loaded_loans_imputed_model_lda$Dependents))

# Make predictions
predictions <- predict(loaded_loans_imputed_model_lda, newdata = to_be_predicted)
print(predictions)

# We then use the data frame to make predictions
predict(loaded_loans_imputed_model_lda, newdata = to_be_predicted)

# STEP 8. Make predictions using the model through a function ---- An
# alternative is to create a function and then use the function to make
# predictions

predict_status <- function(arg_Gender, arg_Married, arg_Dependents, arg_Education,
    arg_SelfEmployed, arg_ApplicantIncome, arg_CoapplicantIncome, arg_LoanAmount,
    arg_LoanAmountTerm, arg_CreditHistory, arg_PropertyArea) {
    # Create a data frame using the arguments
    to_be_predicted <- data.frame(Gender = arg_Gender, Married = arg_Married, Dependents = arg_Dependents,
        Education = arg_Education, SelfEmployed = arg_SelfEmployed, ApplicantIncome = arg_ApplicantIncome,
        CoapplicantIncome = arg_CoapplicantIncome, LoanAmount = arg_LoanAmount, LoanAmountTerm = arg_LoanAmountTerm,
        CreditHistory = arg_CreditHistory, PropertyArea = arg_PropertyArea)

    # Make a prediction based on the data frame
    predict(loaded_loans_imputed_model_lda, to_be_predicted)
}


# We can now call the function predict_diabetes() instead of calling the
# predict() function directly

# Assuming Dependents should be a factor

predict_status("Male", "No", "0", "Graduate", "Yes", 4583, 1508, 12841, 360, 1, "Urban")

# [OPTIONAL] **Deinitialization: Create a snapshot of the R environment ----
# Lastly, as a follow-up to the initialization step, record the packages
# installed and their sources in the lockfile so that other team-members can
# use renv::restore() to re-install the same package version in their local
# machine during their initialization step.  renv::snapshot()

# 8b. API ----

# This will set up a project library, containing all the packages you are
# currently using. The packages (and all the metadata needed to reinstall them)
# are recorded into a lockfile, renv.lock, and a .Rprofile ensures that the
# library is used every time you open the project.

# Consider a library as the location where packages are stored.  Execute the
# following command to list all the libraries available in your computer:
.libPaths()

# One of the libraries should be a folder inside the project if you are using
# renv

# Then execute the following command to see which packages are available in
# each library:
lapply(.libPaths(), list.files)

# This can also be configured using the RStudio GUI when you click the project
# file, e.g., 'BBT4206-R.Rproj' in the case of this project. Then navigate to
# the 'Environments' tab and select 'Use renv with this project'.

# As you continue to work on your project, you can install and upgrade
# packages, using either: install.packages() and update.packages or
# renv::install() and renv::update()

# You can also clean up a project by removing unused packages using the
# following command: renv::clean()

# After you have confirmed that your code works as expected, use
# renv::snapshot(), AT THE END, to record the packages and their sources in the
# lockfile.

# Later, if you need to share your code with someone else or run your code on a
# new machine, your collaborator (or you) can call renv::restore() to reinstall
# the specific package versions recorded in the lockfile.

# [OPTIONAL] Execute the following code to reinstall the specific package
# versions recorded in the lockfile (restart R after executing the command):
# renv::restore()

# [OPTIONAL] If you get several errors setting up renv and you prefer not to
# use it, then you can deactivate it using the following command (restart R
# after executing the command): renv::deactivate()

# If renv::restore() did not install the 'languageserver' package (required to
# use R for VS Code), then it can be installed manually as follows (restart R
# after executing the command):

if (require("languageserver")) {
    require("languageserver")
} else {
    install.packages("languageserver", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

# Introduction ----

# We can create an API to access the model from outside R using a package
# called Plumber.

# STEP 1. Install and Load the Required Packages ---- plumber ----
if (require("plumber")) {
    require("plumber")
} else {
    install.packages("plumber", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

## caret ----
if (require("caret")) {
    require("caret")
} else {
    install.packages("caret", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

# Create a REST API using Plumber ---- REST API stands for Representational
# State Transfer Application Programming Interface. It is an architectural
# style and a set of guidelines for building web services that provide
# interoperability between different systems on the internet. RESTful APIs are
# widely used for creating and consuming web services.

## Principles of REST API ----

### 1. Stateless ---- The server does not store any client state between
### requests. Each request from the client contains all the necessary
### information for the server to understand and process the request.

### 2. Client-Server Architecture ---- The client and server are separate
### entities that communicate over the Internet. The client sends requests to
### the server, and the server processes those requests and sends back
### responses.

### 3. Uniform Interface ---- REST APIs use a uniform and consistent set of
### interfaces and protocols. The most common interfaces are based on the HTTP
### protocol, such as GET (retrieve a resource), POST (create a new resource),
### PUT (update a resource), DELETE (remove a resource), etc.

### 4. Resource-Oriented ---- REST APIs are based on the concept of resources,
### which are identified by unique URIs (Uniform Resource Identifiers). Clients
### interact with these resources by sending requests to their corresponding
### URIs.

### 5. Representation of Resources ---- Resources in a REST API can be
### represented in various formats, such as JSON (JavaScript Object Notation),
### XML (eXtensible Markup Language), YAML (YAML Ain't Markup Language) or
### plain text. The server sends the representation of a resource in the
### response to the client.


# REST APIs are widely used for building web services that can be consumed by
# various client applications, such as web browsers, mobile apps, or other
# servers. They provide a scalable and flexible approach to designing APIs that
# can evolve over time. Developers can use RESTful principles to create APIs
# that are easy to understand, use, and integrate into different systems.

# When working with a REST API, clients typically send HTTP requests to
# specific endpoints (URLs) provided by the server, and the server responds
# with the requested data or performs the requested actions. The communication
# between client and server is based on the HTTP protocol, making REST APIs
# widely supported and accessible across different platforms and programming
# languages.

# In summary, a REST API is a set of rules and conventions for building web
# services that follow the principles of REST. It provides a standardized and
# scalable way for systems to communicate and exchange data over the internet.

# This requires the 'plumber' package that was installed and loaded earlier in
# STEP 1. The commenting below makes R recognize the code as the definition of
# an API, i.e., #* comments.

loaded_loans_imputed_model_lda <- readRDS("C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/models/saved_loans_model_lda.rds")

# * @apiTitle Loan Approval Status Prediction Model API

# * @apiDescription Used to predict whether a client will be given a loan or
# not.

# * @param arg_Gender The clients Gender(Male or Female) * @param arg_Married
# The clients Marital status(Yes or No) * @param arg_Dependents The number of
# Dependents the client has(0,1,2 or 3+) * @param arg_Education The clients
# education status(Graduate or NotGraduate) * @param arg_SelfEmployed The
# clients employment status(Yes or No) * @param arg_ApplicantIncome The
# Applicants monthly income * @param arg_CoapplicantIncome The Coapplicants
# monthly income if applicable * @param arg_LoanAmount The Loan amount(in Ksh)
# * @param arg_LoanAmountTerm The Loan term (in days) * @param
# arg_CreditHistory The clients credit history (0 being less than 350, 1 being
# more thatn 500) * @param arg_PropertyArea The clients property area (Urban,
# SemiUrban, Rural)

# * @get /Status

predict_status <- function(arg_Gender, arg_Married, arg_Dependents, arg_Education,
    arg_SelfEmployed, arg_ApplicantIncome, arg_CoapplicantIncome, arg_LoanAmount,
    arg_LoanAmountTerm, arg_CreditHistory, arg_PropertyArea) {
    # Create a data frame using the arguments
    to_be_predicted <- data.frame(Gender = as.factor(arg_Gender), Married = as.factor(arg_Married),
        Dependents = as.factor(arg_Dependents), Education = as.factor(arg_Education),
        SelfEmployed = as.factor(arg_SelfEmployed), ApplicantIncome = as.numeric(arg_ApplicantIncome),
        CoapplicantIncome = as.numeric(arg_CoapplicantIncome), LoanAmount = as.numeric(arg_LoanAmount),
        LoanAmountTerm = as.numeric(arg_LoanAmountTerm), CreditHistory = as.numeric(arg_CreditHistory),
        PropertyArea = as.factor(arg_PropertyArea))
    # Make a prediction based on the data frame
    predict(loaded_loans_imputed_model_lda, to_be_predicted)
}

# [OPTIONAL] **Deinitialization: Create a snapshot of the R environment ----
# Lastly, as a follow-up to the initialization step, record the packages
# installed and their sources in the lockfile so that other team-members can
# use renv::restore() to re-install the same package version in their local
# machine during their initialization step.  renv::snapshot()

# *****************************************************************************
# Lab 11: Plumber API ----

# **[OPTIONAL] Initialization: Install and use renv ---- The R Environment
# ('renv') package helps you create reproducible environments for your R
# projects. This is helpful when working in teams because it makes your R
# projects more isolated, portable and reproducible.


# Once installed, you can then use renv::init() to initialize renv in a new
# project.

# The prompt received after executing renv::init() is as shown below: This
# project already has a lockfile. What would you like to do?

# 1: Restore the project from the lockfile.  2: Discard the lockfile and
# re-initialize the project.  3: Activate the project without snapshotting or
# installing any packages.  4: Abort project initialization.

# This will set up a project library, containing all the packages you are
# currently using. The packages (and all the metadata needed to reinstall them)
# are recorded into a lockfile, renv.lock, and a .Rprofile ensures that the
# library is used every time you open the project.

# Consider a library as the location where packages are stored.  Execute the
# following command to list all the libraries available in your computer:
.libPaths()

# One of the libraries should be a folder inside the project if you are using
# renv

# Then execute the following command to see which packages are available in
# each library:
lapply(.libPaths(), list.files)

# This can also be configured using the RStudio GUI when you click the project
# file, e.g., 'BBT4206-R.Rproj' in the case of this project. Then navigate to
# the 'Environments' tab and select 'Use renv with this project'.

# As you continue to work on your project, you can install and upgrade
# packages, using either: install.packages() and update.packages or
# renv::install() and renv::update()

# You can also clean up a project by removing unused packages using the
# following command: renv::clean()

# After you have confirmed that your code works as expected, use
# renv::snapshot(), AT THE END, to record the packages and their sources in the
# lockfile.

# Later, if you need to share your code with someone else or run your code on a
# new machine, your collaborator (or you) can call renv::restore() to reinstall
# the specific package versions recorded in the lockfile.

# [OPTIONAL] Execute the following code to reinstall the specific package
# versions recorded in the lockfile (restart R after executing the command):
# renv::restore()

# [OPTIONAL] If you get several errors setting up renv and you prefer not to
# use it, then you can deactivate it using the following command (restart R
# after executing the command): renv::deactivate()

# If renv::restore() did not install the 'languageserver' package (required to
# use R for VS Code), then it can be installed manually as follows (restart R
# after executing the command):

if (require("languageserver")) {
    require("languageserver")
} else {
    install.packages("languageserver", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

# STEP 1. Install and load the required packages ---- plumber ----
if (require("plumber")) {
    require("plumber")
} else {
    install.packages("plumber", dependencies = TRUE, repos = "https://cloud.r-project.org")
}

# STEP 2. Process a Plumber API ---- This allows us to process a plumber API
api <- plumber::plumb("C:/Users/Cris/github-classroom/BI-Loan-Appraisal-Project/8- Consolidation-b.R")

# STEP 3. Run the API on a specific port ---- Specify a constant localhost port
# to use api$run(host = '127.0.0.2', port = 5026)

# STEP 4. Test the API ---- We test the API using the following values: for the
# arguments: pregnant, glucose, pressure, triceps, insulin, mass, pedigree, age
# 6, 148, 72, 35, 0, 33.6, 0.627, and 50 respectively should be 'positive' 1,
# 85, 66, 29, 0, 26.6, 0.351, and 31 respectively should be 'negative'

# [OPTIONAL] **Deinitialization: Create a snapshot of the R environment ----
# Lastly, as a follow-up to the initialization step, record the packages
# installed and their sources in the lockfile so that other team-members can
# use renv::restore() to re-install the same package version in their local
# machine during their initialization step.  renv::snapshot()