A2-MachineLearningTasks.qmd

---
output: html_document
editor_options:
  chunk_output_type: console
---

# Introduction to ML

ML is about building an algorithm that can perform a certain tasks. The general steps in an ML are:

1.  Get some data
2.  Establish something that should be done with such data (= task)
3.  Find an algorithm that can perform the task
4.  Operationalize the goal by an error metric (=loss) that is to be minimized
5.  Train the algorithm to achieve a small loss on the data
6.  Test the performance of the algorithm

::: callout-note
## Example

1.  data = airquality
2.  predict Ozone
3.  algorithm = lm
4.  loss = residual sum of squares
5.  m = lm(Ozone \~ ., data = airquality)
6.  could predict(m) to data or hold-out
:::

Our task in the course will now be to better understand

-   What are tasks that we can tackle?
-   What algorithm exist and how can they be set up / tuned / modified
-   How to define the loss and wow to best train the algorithms?
-   How to do the performance evaluation

## ML Tasks

There are three types of machine learning tasks:

-   Supervised learning
-   Unsupervised learning
-   Reinforcement learning

**Supervised learning**, you train algorithms to predict something (classes or values = regression) from some other data (= features), and you provide it with correct examples of the execution of the task (called training data). A linear regression is an example of supervised learning.

**Unsupervised learning**, on the other hand, is when you provide the features, but no examples of the correct execution of the task. Clustering techniques are examples of unsupervised learning

**Reinforcement learning** is a technique that mimics a game-like situation. The algorithm finds a solution through trial and error, receiving either rewards or penalties for each action. As in games, the goal is to maximize the rewards. We will talk more about this technique on the last day of the course.

For now, we will focus on the first two tasks, supervised and unsupervised learning ([here](https://www.youtube.com/watch?v=1AVrWvRvfxs) a YouTube video explaining again the difference).

### Test questions

::: {.webex-check .webex-box}
In ML, predictors (or the explaining variables) are often called features: `r webexercises::torf(TRUE)`

In supervised learning the response (y) and the features (x) are known: `r webexercises::torf(TRUE)`

In unsupervised learning, only the features are known: `r webexercises::torf(TRUE)`

In reinforcement learning an agent (ML model) is trained by interacting with an environment: `r webexercises::torf(TRUE)`

```{r}
#| results: asis
#| echo: false
opts <- c(
   answer = "Both books can be downloaded for free.",
   "Higher model complexity is always better for predicting."
)

cat("Have a look at the two textbooks on ML (Elements of statistical learning and introduction to statistical learning) in our further readings at the end of the GRIPS course - which of the following statements is true?", longmcq(opts))
```
:::

## Unsupervised Learning {#sec-unsupervised}

In unsupervised learning, we want to identify patterns in data without having any examples (supervision) about what the correct patterns / classes are. As an example, consider the iris data set. Here, we have 150 observations of 4 floral traits:

```{r chunk-chapter3-1-iris-plot, fig.width=10, fig.height=4, fig.cap="Trait distributions of iris dataset"}
iris = datasets::iris
colors = hcl.colors(3)
traits = as.matrix(iris[,1:4])
species = iris$Species
image(y = 1:4, x = 1:length(species) , z = traits,
      ylab = "Floral trait", xlab = "Individual")
segments(50.5, 0, 50.5, 5, col = "black", lwd = 2)
segments(100.5, 0, 100.5, 5, col = "black", lwd = 2)
```

The observations are from 3 species and indeed those species tend to have different traits, meaning that the observations form 3 clusters.


```{r chunk-chapter3-2"}
pairs(traits, pch = as.integer(species), col = colors[as.integer(species)])
```

However, imagine we don't know what species are, what is basically the situation in which people in the antique have been. The people just noted that some plants have different flowers than others, and decided to give them different names. This kind of process is what unsupervised learning does.

### K-means Clustering

An example for an unsupervised learning algorithm is k-means clustering, one of the simplest and most popular unsupervised machine learning algorithms (see more on this in section "distance based algorithms").

To start with the algorithm, you first have to specify the number of clusters (for our example the number of species). Each cluster has a centroid, which is the assumed or real location representing the center of the cluster (for our example this would be how an average plant of a specific species would look like). The algorithm starts by randomly putting centroids somewhere. Afterwards each data point is assigned to the respective cluster that raises the overall in-cluster sum of squares (variance) related to the distance to the centroid least of all. After the algorithm has placed all data points into a cluster the centroids get updated. By iterating this procedure until the assignment doesn't change any longer, the algorithm can find the (locally) optimal centroids and the data points belonging to this cluster. Note that results might differ according to the initial positions of the centroids. Thus several (locally) optimal solutions might be found.

The "k" in K-means refers to the number of clusters and the 'means' refers to averaging the data-points to find the centroids.

A typical pipeline for using k-means clustering looks the same as for other algorithms. After having visualized the data, we fit a model, visualize the results and have a look at the performance by use of the confusion matrix. By setting a fixed seed, we can ensure that results are reproducible.

```{r chunk_chapter3_9}
set.seed(123)

#Reminder: traits = as.matrix(iris[,1:4]).

kc = kmeans(traits, 3)
print(kc)
```

*Visualizing the results.* Color codes true species identity, symbol shows cluster result.

```{r chunk_chapter3_10}
plot(iris[c("Sepal.Length", "Sepal.Width")],
     col =  colors[as.integer(species)], pch = kc$cluster)
points(kc$centers[, c("Sepal.Length", "Sepal.Width")],
       col = colors, pch = 1:3, cex = 3)
```

We see that there are are some discrepancies. Confusion matrix:

```{r chunk_chapter3_11}
table(iris$Species, kc$cluster)
```

If you want to animate the clustering process, you could run

```{r chunk_chapter3_12, eval=F}
library(animation)

saveGIF(kmeans.ani(x = traits[,1:2], col = colors),
        interval = 1, ani.width = 800, ani.height = 800)
```

**Elbow technique** to determine the probably best suited number of clusters:

```{r chunk_chapter3_13}
set.seed(123)

getSumSq = function(k){ kmeans(traits, k, nstart = 25)$tot.withinss }

#Perform algorithm for different cluster sizes and retrieve variance.
iris.kmeans1to10 = sapply(1:10, getSumSq)
plot(1:10, iris.kmeans1to10, type = "b", pch = 19, frame = FALSE,
     xlab = "Number of clusters K",
     ylab = "Total within-clusters sum of squares",
     col = c("black", "red", rep("black", 8)))
```

Often, one is interested in sparse models. Furthermore, higher k than necessary tends to overfitting. At the kink in the picture, the sum of squares dropped enough and k is still low enough. But keep in mind, this is only a rule of thumb and might be wrong in some special cases.

## Supervised Learning

The two most prominent branches of supervised learning are regression and classification. The basic distinction between the two is that classification is about predicting a categorical variable, and regression is about predicting a continuous variable. 

### Regression

The random forest (RF) algorithm is possibly the most widely used machine learning algorithm and can be used for regression and classification. We will talk more about the algorithm later.

For the moment, we want to go through a typical workflow for a supervised regression: First, we visualize the data. Next, we fit the model and lastly we visualize the results. We will again use the iris data set that we used before. The goal is now to predict Sepal.Length based on the information about the other variables (including species).

Fitting the model:

```{r chunk_chapter3_26, results='hide', message=FALSE, warning=FALSE}
library(randomForest)
set.seed(123)
```

Sepal.Length is a numerical variable:

```{r}
str(iris)
hist(iris$Sepal.Length)
```

The randomForest can be used similar to a linear regression model, we can specify the features using the formula syntax (`~.` means that all other variables should be used as features):

```{r chunk_chapter3_27}
m1 = randomForest(Sepal.Length ~ ., data = iris)   # ~.: Against all others.
print(m1)
```

::: column-margin

In statistics we would use a linear regression model:

```{r}
mLM = lm(Sepal.Length~., data = iris)
```

:::

As many other ML algorithms, the RF is not interpretable, so we don't get coefficients that connect the variables to the response. But, at least we get the variable importance which is similar to an anova, telling us which variables were the most important ones:

```{r}
varImpPlot(m1)
```

::: column-margin

Our liner model would report linear effects, however, the lm cannot keep up with the flexibility of a random forest!

```{r}
coef(mLM)
```

:::

And the finally, we can use the model to make predictions using the predict method:

```{r chunk_chapter3_28}
plot(predict(m1), iris$Sepal.Length, xlab = "Predicted", ylab = "Observed")
abline(0, 1)
```

To understand the structure of a random forest in more detail, we can use a package from GitHub.

```{r chunk_chapter3_29, message=FALSE, warning=FALSE}
#| fig-width: 12
#| fig-height: 6
reprtree:::plot.getTree(m1, iris)
```

Here, one of the regression trees is shown.

### Classification

With the random forest, we can also do classification. The steps are the same as for regression tasks, but we can additionally see how well it performed by looking at the confusion matrix. Each row of this matrix contains the instances in a predicted class and each column represents the instances in the actual class. Thus the diagonals are the correctly predicted classes and the off-diagonal elements are the falsely classified elements.

Species is a factor with three levels:

```{r}
str(iris)
```

Fitting the model (syntax is the same as for the regression task):

```{r chunk_chapter3_30}
set.seed(123)
library(randomForest)
m1 = randomForest(Species ~ ., data = iris)
print(m1)

varImpPlot(m1)
```

Predictions:

```{r}
head(predict(m1))
```

Confusion matrix:

```{r}
table(predict(m1), as.integer(iris$Species))
```

Our model made a few errors.

Visualizing results ecologically:

```{r chunk_chapter3_32}
plot(iris$Petal.Width, iris$Petal.Length, col = iris$Species, main = "Observed")
plot(iris$Petal.Width, iris$Petal.Length, col = predict(m1), main = "Predicted")
```

Visualizing one of the fitted models:

```{r chunk_chapter3_31, message=FALSE, warning=FALSE}
#| fig-width: 8
#| fig-height: 6
reprtree:::plot.getTree(m1, iris)
```

Confusion matrix:

```{r chunk_chapter3_34, results='hide'}
knitr::kable(table(predict(m1), iris$Species))
```


## Exercise - Supervised Learning

```{r}
#| results: asis
#| echo: false
opts <- c(
   answer = "Species.",
   "Sepal.Width."
)

cat("Using a random forest on the iris dataset, which parameter would be more important (remember there is a function to check this) to predict Petal.Width?", webexercises::longmcq(opts))
```

::: callout-warning
#### Task: First deep neural network

Deep neural networks are currently the state of the art in unsupervised learning. Their ability to model different types of data (e.g. graphs, images) is one of the reasons for their rise in recent years. However, their use beyond tabular data (tabular data == features have specific meanings) requires extensive (programming) knowledge of the underlying deep learning frameworks (e.g. TensorFlow or PyTorch), which we will teach you in two days. For tabular data, we can use packages like cito, which work similarly to regression functions like lm and allow us to train deep neural networks in one line of code.

A demonstration with the iris dataset:

```{r, results='hide'}
library(cito)

# always scale your features when using DNNs
iris_scaled = iris
iris_scaled[,1:4] = scale(iris_scaled[,1:4])

# the default architecture is 3 hidden layers, each with 10 hidden nodes (we will talk on Wednesday more about the architecture)
# Similar to a lm/glm we have to specify the response/loss family, for multi-target (3 species) we use the softmax loss function
model = dnn(Species~., lr = 0.1,data = iris_scaled, loss = "softmax", verbose = FALSE)
```

DNNs are not interpretable, i.e. no coefficients (slopes) that tell us how the features affect the response, however, similar to the RF, we can calculate a 'variable importance' which is similar to an anova:

```{r}
summary(model)
```

Predictions

```{r}
head(predict(model, type = "response"))
```

We get three columns, one for each species, and they are probabilities.

```{r}
plot(iris$Sepal.Length, iris$Sepal.Width, col = apply(predict(model, type = "response"), 1, which.max))
```

Performance:

```{r}
table(apply(predict(model), 1, which.max), as.integer(iris$Species))
```

**Task:**

-   predict `Sepal.Length` instead of `Species` (classification -\> regression)
-   Use the 'mse' loss function
-   Plot predicted vs observed

:::

`r hide("Click here to see the solution")`

Regression:

losses such as "mse" (mean squared error) or the "msa" (mean absolute error) are used for regression tasks

```{r, results='hide'}
model = dnn(Sepal.Length~., lr = 0.1,data = iris_scaled, loss = "mse")
```

```{r}
summary(model)
```

```{r}
plot(iris_scaled$Sepal.Length, predict(model))
```

Calculate $R^2$:

```{r}
cor(iris_scaled$Sepal.Length, predict(model))**2
```

`r unhide()`