loops_and_parallel.Rmd

---
title: "How to write loops correctly and other stories"
author: "Maria Novosolov"
date: "`r format(Sys.Date(),'%d-%m-%Y')`"
output:
  xaringan::moon_reader:
    lib_dir: libs
    css: ["default", "custom-fonts.css"]
    chakra: "libs/remark-latest.min.js"
    nature:
      highlightStyle: github
      highlightLines: true
      ratio: '16:9'
---

```{r setup, include=FALSE}
options(htmltools.dir.version = FALSE)
library(tidyverse)
library(pbapply)
library(foreach)
data("starwars")
```

# General comments about the upcoming semester

* Emphasis on reading and writing code correctly

* More interactive - you do the work, we are just here to help

* Community participation
    - Slack
    - Code camp

---
class: inverse, center, middle

# Iterating over data in R

---

# Why bother?

* What, you're really going to write out every line?

<img src="http://cdn3.whatculture.com/images/2015/04/Simpsons-Milestone-600x300.jpg" width=60%>

---

## Three main methods:

* `for` and `while` loops

* `*apply` function family

* `map` function in `tidyverse`

---

class: inverse, center, middle

# `for` loops

---

# Basic ingrediants of a `for` loop


.pull-left[
A `for` loop has:
1. Sequence
2. Body
3. Output

It will at least have (1) and (2)
]

.pull-right[
<img src="https://cdn.datamentor.io/wp-content/uploads/2017/11/r-for-loop.jpg" width=60%>
]

---

### `for` loop syntax

```{r}
for(i in 1:10){ #sequence
  print(i)      #body
}
```

---

### Alternative for sequence

Use `seq_along()` as an idiot proof alternative to `1:length(df)` because it will not work if the vector your iterating over is of length zero

```{r}
#random dataframe to play with
df<- tibble(a = rnorm(10), b = rnorm(10),
            c = rnorm(10), d = rnorm(10))
#print the names of the columns in df
for(i in seq_along(df)){
  print(names(df[i]))
}
```

---

# An R syntax detour

What is the difference between `df[i]` and `df[[i]]`?

--
.pull-left[
```{r}
i=1
df[i]
```
]

.pull-right[
```{r}
df[[i]]
```

]

---
class: exercise, center, middle

# Practice time!

Write a for loop that calculates the mean of each column in `mtcars`
Bonus: calculate mean only for the continuous columns

---

In many cases we would like to save the output so we'll add the output

**Remember!** Initiating the output with a known length will save you computing time

If you don't know the length of the output it is worth saving the output into a list and then flattening it out using `unlist` (for vectors) or `dplyr::bind_rows()` (for dataframe rows)
---

# Let's save the mean for each column of mtcars into a vector
```{r}
col_mean<- vector(mode = "double",length = (length(mtcars)-1))
for(i in seq_along(mtcars)){
  if(is.numeric(mtcars[[i]])==T){
    col_mean[i]<- mean(mtcars[[i]],na.rm=T)
  }
}
print(col_mean)
```

---
In the previous case I knew how many numeric columns there are. But what if we don't know?

```{r}
#create a list with a length as the number of columns in mtcars
col_mean<- vector(mode = "list",length = length(mtcars))
for(i in seq_along(mtcars)){
  if(is.numeric(mtcars[[i]])==T){
    #note that tho save into a list you use double brackets 
    col_mean[[i]]<- mean(mtcars[[i]],na.rm=T)
  }
}
unlist(col_mean)
```

---
# Recipe to successful `for` loop writing

1. Write down the general objective for the loop including the data that will be used

**For example:** Find all the characters in the starwars data that are older than X, and add the word "old" to their name.

2. Write in words each of the steps you will be taking to accomplish your objective

3. Write the code that fulfills each step

4. Test the loop on the first iteration
---

# Some more advice

* If the loop is complicated then start with a simplified loop and build on top of it

* If you think you need to write a loop within the loop try and find a way to use `*apply` or write a function that will execute the inner loop. 

* If you think you'll be using the loop more than once embed the loop into a function. To read more about functions, check out: https://github.com/globedatasci-ku/functions
---

# Some more advice

* Make comments and documentation for all your code

.center[
<img src="https://img.libquotes.com/pic-quotes/v2/damian-conway-quote-lbx2j9r.jpg" width=60%>
]
---
class: exercise, center, middle

# Let's practice!

I want you to think of an objective that can be used in a loop and then write the steps that you will take to get this objective

---

class: center, middle

# Come present your loop architecture!

---

class: exercise, center, middle

# More practice!

Write the code that fulfills each step of your loop and test that it runs

---

class: inverse, center, middle

# `while` loops

---

# When to use and general advice

* Use only when you do not know the number of iterations something will take

* Careful!! Writing the `while` loop wrong can lead to infinity

<img src="img/while_loop2.png" width=40%>

---

# `while` loop syntax

.pull-left[
```{r}
#initiate a counter
i=1
#start the while loop
while(i < 10){
  #do something
  print(i)
  #increase the counter
  i = i+1
}
```
]

.pull-right[
<img src="https://cdn.datamentor.io/wp-content/uploads/2017/11/r-while-loop.jpg" width=60%>
]
---

class: exercise, center, middle

# Practice time!

Convert the `mtcars` for loop from the examples above into a while loop

---
.center[
#**REMEMBER!**


Use a while loop as your last resort or if you are really certain of why you are using it
]
---


class: inverse, center, middle

# `*apply` function family


---

# General guidelines

* Allows you to do row-wise/column-wise operations (`apply()`)

* Can be used to iterate over a list (`lapply()`)

* Can be used in parallel (`mcapply()`)

---
--- 

# `apply()` Examples

### General syntax:

apply(data,margin,function,specific variables of the function)

margins: 1 = row wise; 2 = col wise

```{r}
#subset the starwars dat to have only height and mass
sub_sw<- starwars[,2:3]
# calculate the mean for each of them
apply(sub_sw,2,mean,na.rm=T)
```

---
# adding a progress bar (`pbapply()`)

Similar to apply but adds a progress bar (can't see in the slide format)

```{r message=TRUE, warning=TRUE}
pbapply(sub_sw,2,mean,na.rm=T)
```

---
class: exercise, center, middle
# Time to practice!

Convert part of your loop to use an apply function

---

# `lapply()` Example

general syntax: 
lapply(list, function)

* Returns a list

```{r}
lapply(starwars$films,length)
```

---


# With progress bar

```{r}
pblapply(starwars$films,length)
```

---
class: exercise, center, middle

# Time to practice!

create a list from the continuous variables in your data and use `lapply` to calculate the mean of the continuous variables

---
class: inverse, center, middle

# Loops in Parallel

---

# `foreach` package

* `foreach` is a parallel equivalent to `lapply` function

* Let's you run your analysis faster

* A more flexible version of `mcapply()`

* Needs some understanding whether your analysis is independent 

---

# General sytax

In its base `foreach` works like `lapply`

```{r}
foreach(i = 1:3) %do% {
  sqrt(i)
}
```

---

# To make it into a vector

```{r}
foreach(i = 1:3,.combine ='c') %do% {
  sqrt(i)
}
```

---

# or

```{r}
#save the results into a variable
res<- foreach(i = 1:3) %do% {
  sqrt(i)
}

#use do.call to combine it
do.call('c', res)
```

---

# An R syntax detour - the `do.call()` function

* Takes a function and gives it a list of arguments
* What, you mean like `lapply()`?
    - Nope, do.call can collapse lists into a *single vector*
    - `lapply` always returns a list.
* Also useful for collapsing lists using `rbind` and `cbind`

---

# An R syntax detour - the `do.call()` function

```{r}
lapply(starwars$films[8:10], 
       c)
```

```{r}
do.call(c, 
        starwars$films[8:10])
```

---
class: center, middle

# Let's put things in parallel

---
# General idea and guidelines

* Use the several cores in your computer to run your analysis in parallel

* Make sure that the iterations are independent of each other

* Parallel works a bit different between Windows and Mac. If you want to read more about it: https://psu-psychology.github.io/r-bootcamp-2018/talks/parallel_r.html

---

# Run `foreach` in parallel

* replace `%do%` with `%dopar%`

* Register a parallel back end - with one of the packages `doParallel`, `doMC`, or `doMPI`

---

# Easy example on registering clusters

```{r}
# define the numer of cores you're going to use
cl <- parallel::makeCluster(2)

# register them
doParallel::registerDoParallel(cl)

# run the loop in parallel
foreach(i = 1:3, .combine = 'c') %dopar% {
  sqrt(i)
}
parallel::stopCluster(cl)
```

---

# Lets compare `lapply` to `foreach`

.pull-left[
```{r}
head(
  unlist(
    lapply(starwars$films,
              length)))
```
]

.pull-right[
```{r}
# define the number of cores you're going to use
cl <- parallel::makeCluster(2)

# register them
doParallel::registerDoParallel(cl)

# run the loop in parallel
head(
  foreach(i = seq_along(starwars$films),
          .combine = 'c') %dopar% {
  length(starwars$films[[i]])
})
parallel::stopCluster(cl)
```
]

---
### If you want to dive deeper into working with `foreach`check out this blog post

https://privefl.github.io/blog/a-guide-to-parallelism-in-r/

---
class: exercise, center, middle

# Let's practice!

Convert the `mtcars` for loop to a foreach loop. Bonus, make it run in parallel
---

## Non-parallel version
```{r}
foreach(i = seq_along(mtcars),.combine = 'c') %do% {
            if(is.numeric(mtcars[[i]])==T){
              mean(mtcars[[i]],na.rm=T)
            }
}
```

# parallel version
```{r}

# define the number of cores you're going to use
cl <- parallel::makeCluster(2)

# register them
doParallel::registerDoParallel(cl)
foreach(i = seq_along(mtcars),.combine = 'c') %dopar% {
            if(is.numeric(mtcars[[i]])==T){
              mean(mtcars[[i]],na.rm=T)
            }
}

parallel::stopCluster(cl)
```

---

# `pblapply` a parallel lapply version


```{r}
#define the number of clusters and register the cluster
cl <- parallel::makeCluster(2)
doParallel::registerDoParallel(cl)
#subset the mtcars to have only continuous columns
mtcars2<- mtcars[,1:8]

#run pbapply
pbapply(mtcars2,2,mean,cl=cl)
#stop the cluster
parallel::stopCluster(cl)
```