In this Reproducible Finance note, we will review and walk through the R code for importing price data from CSV, coercing it to monthly returns data, and then running a Fama French (FF) factor model on the data. That will also necessitate importing and wrangling the FF data before running the model and visualizing the results. The goal of this note is to introduce some useful and reuseable R code that can serve as a starting point for more complex analysis.
First, let’s load up our packages that we will need for the project. If you are unfamiliar with R, packages are an important part of the ecosystem. They can contain useful and intuitive functions that save us from having to write our functions in base R.
We will be using the following packages.
library(tidyverse)
library(tidyquant)
library(broom)
library(tibbletime)
With our packages loaded, we need to import some data. We will be working with the following SPDR sector ETFs.
We could import price data on those ETFs from a source like Factset or Bloomberg, but to make this fully reproducible, I have saved the price data as a CSV file that can be downloaded.
To import the data into our working environment, we will use the read_csv() function and download directly the website where I stored this data.
sector_prices_2000_2018 <-
read_csv("https://colorado.rstudio.com/rsc/content/2138/sector_prices_2000_2018.csv") %>%
select(-X1) %>%
group_by(sector)
Next let’s use the slice() function to glance at the first price observation for each of the sectors, to confirm that the data looks how we were expecting it to look. Note that the first date is December 29, 1999. I set that as the start date because we eventually want to capture the monthly return of January 2000 and we will index that off of the last day of December 1999.
sector_prices_2000_2018 %>%
slice(1)
The ultimate goal is to regress the monthly sector returns on the the Fama French factors, so let’s coerce this daily price data to monthly price data.
For that task, we use as_period(period = "month", side = "end"), which will convert our data to monthly, indexed at the end of each month.
With our data converted to monthly, we can calculate monthly returns using mutate(monthly_return = log(adjClose) - log(lag(adjClose). The mutate() function adds a new column to the data and we set the name of the new column to be monthly_returns. We calculate monthly returns as th log of the adjusted close on the final day of the current month, minus the log of the adjusted close on the final day of the previous month. This is for illustration purposes - your team might choose to use a price other than adjusted close and different date periodicities.
sector_monthly_returns_2000_2018 <-
sector_prices_2000_2018 %>%
as_tbl_time(index = date) %>%
as_period(period = "month", side = "end") %>%
mutate(monthly_return = log(adjClose) - log(lag(adjClose))) %>%
na.omit()
sector_monthly_returns_2000_2018 %>%
slice(1)
We now have monthly returns for our sectors, starting in January of 2000.
Next we need to import Fama French factor data and, luckily, FF make their factor data available on their website.
Have a look at the website where the factor data is available.
http://mba.tuck.dartmouth.edu/pages/faculty/ken.french/data_library.html
The data are packaged as zip files so we will need to do a bit more than call read_csv().
We will use the tempfile() function from base R to create a variable called temp, and will store the zipped file there.
Then we invoke download.file() and pass it the URL address of the zip, which is “http://mba.tuck.dartmouth.edu/pages/faculty/ken.french/ftp/Global_5_Factors_CSV.zip”.
temp <- tempfile()
download.file(
"http://mba.tuck.dartmouth.edu/pages/faculty/ken.french/ftp/Global_5_Factors_CSV.zip",
temp,
quiet = TRUE)
Next we unzip that data with the unz() function read and the csv file using read_csv().
Global_5_Factors <-
read_csv(unz(temp, "Global_5_Factors.csv"), skip =6) %>%
rename(date = X1)
That loads the data into our environment but we need to do some wrangling to get this raw data into a format that we can join with our monthly returns data.
Have a look at the date column.
Global_5_Factors %>%
select(date) %>%
head(2)
We want to join this data to our monthly returns using the date column, and that means we want the factor date to be in the same format as our monthly returns, but it’s currently in a character string with the format 1990007 instead of 1990-07-31.
We can call mutate(date = ymd(parse_date_time(date, "%Y%m"))) to make this transformation.
Global_5_Factors %>%
mutate(date = ymd(parse_date_time(date, "%Y%m"))) %>%
head()
That worked well for the date column, but note that all our factor columns have been read in as character strings and we want them to be numeric, and we also want to coerce our date to be indexed at the end of the month, not at the beginning. Here’s the code flow to make those transformations.
Global_5_Factors_for_join <-
Global_5_Factors %>%
mutate(date = ymd(parse_date_time(date, "%Y%m"))) %>%
mutate_at(vars(-date), as.numeric) %>%
mutate_if(is.numeric, funs(. / 100)) %>%
as_tbl_time(index = date) %>%
mutate(date = ceiling_date(date, unit = "month") - days(1)) %>%
rename(MKT = `Mkt-RF`)
Global_5_Factors_for_join %>%
head()
The data frame looks good now, but that was quite a bit of work to add a nicely formatted date, indexed to the end of the month and with numeric instead of character data in the other columns. Now is a good time to note that manipulating and cleaning dates is a crucial and often time-consuming part of financial data work, especially when a project involves mashing together disparate data sets. The more comfortable and efficient we can get at transforming and aligning dates, the more quickly we can start to work with new and interesting data sources.
We now have the Fama French factors going back to 1990 and the next task is to regress our sector monthly returns on those factors. Let’s use left_join() to combine our sector monthly returns data with our factors data, and use the by = "date" argument so that only the factor and returns observations with the same dates will remain in the data frame.
sector_factor_data_joined <-
sector_monthly_returns_2000_2018 %>%
left_join(Global_5_Factors_for_join, by = "date")
sector_factor_data_joined %>%
select(-ticker, -adjClose) %>%
slice(1)
Our data is now in a nicely structured data frame, with our sector names in one column, our sector returns in a separate column, and each of the Fama French factors in a separate column. From here, we want to run our factor analysis, which we do by regressing our monthly returns on the 5 factors.
For this exercise, let’s run the regression on just the Financials sectors by first calling filter(sector == Financials). If you wish to reproduce this work but run the regression on a different sector, you can change the code to filter(sector == your sector of choice).
After filtering, we use do(model = lm(monthly_return ~ Mkt + SMB + HML + RMW + CMA)) to run our regression.
sector_factor_data_joined %>%
filter(sector == "Financials") %>%
do(model = lm(monthly_return ~ MKT + SMB + HML + RMW + CMA,
data = .))
That worked, but the results of our 5-factor regression are stored as an S3 object, which can be hard to access. To clean up the results, and add confidence intervals for our beta estimates, we call tidy(model, conf.int = T, conf.level = .95) and rename a couple of columns for convenience.
ff_results <-
sector_factor_data_joined %>%
filter(sector == "Financials") %>%
do(model = lm(monthly_return ~ MKT + SMB + HML + RMW + CMA,
data = .)) %>%
tidy(model, conf.int = T, conf.level = .95) %>%
rename(coefficient = estimate, factor = term)
ff_results
Let’s finish our work with a chart, showing the coefficient estimates and confidence intervals for our factors. We will use ggplot() to build this charting mapping our factor names to the x-axis and our coefficients to the y-axis with aes(x = factor, y = coefficient). Let’s place a point for each coefficient by calling geom_point() and add confidence intervals with geom_errorbar().
ff_results %>%
filter(factor != "(Intercept)") %>%
ggplot(aes(x = factor,
y = coefficient,
shape = factor,
color = factor)) +
geom_point() +
geom_errorbar(aes(ymin = conf.low,
ymax = conf.high)) +
labs(title = "FF 5-Factor Betas with Conf Intervals",
x = "",
y = "coefficients",
caption = "data source: Fama-French website") +
theme_minimal() +
theme(plot.title = element_text(hjust = 0.5),
plot.caption = element_text(hjust = 0))
We can glance at this and quickly see that the MKT and HML factors have positive coefficients near 1, whereas both RMW and SMB have negative coefficients.
Remember that we ran the regression on the Financials sector but we have monthly returns for several more ETFs. We could expand this work by filtering on a different sector or by adding more factors to the data frame before running the regression. We could also convert our regression model to a rolling regression, to see where we might have missed any significant regime or market shifts, and then visualize our rolling factor coefficients.
We hope that this short note provided some useful R code and some data wrangling functions that might save some time when different date formats confront you. Thanks for reading.
---
title: "Sector Factor Note"
output:
  html_notebook: default
---


```{r setup, include = FALSE, message=FALSE, warning=FALSE}
knitr::opts_chunk$set(message=FALSE, warning=FALSE, comment = NA)
library(tidyverse)
library(broom)
library(tibbletime)
library(tidyquant)
```

In this Reproducible Finance note, we will review and walk through the R code for importing price data from CSV, coercing it to monthly returns data, and then running a Fama French (FF) factor model on the data. That will also necessitate importing and wrangling the FF data before running the model and visualizing the results. The goal of this note is to introduce some useful and reuseable R code that can serve as a starting point for more complex analysis.  

First, let's load up our packages that we will need for the project. If you are unfamiliar with R, packages are an important part of the ecosystem. They can contain useful and intuitive functions that save us from having to write our functions in base R. 

We will be using the following packages.

```{r, eval=FALSE}
library(tidyverse)
library(tidyquant)
library(broom)
library(tibbletime)
```

With our packages loaded, we need to import some data. We will be working with the following SPDR sector ETFs.

```{r, echo = FALSE}

etf_ticker_sector <- tibble(
  ticker = c("XLY", "XLP", "XLE",	
          "XLF", "XLV",	"XLI", "XLB", 
          "XLK", "XLU",  "SPY"),	
  sector = c("Consumer Discretionary", "Consumer Staples", "Energy", 
          "Financials", "Health Care", "Industrials", "Materials", 
          "Information Technology", "Utilities", "Market")
)

etf_ticker_sector
```

We could import price data on those ETFs from a source like Factset or Bloomberg, but to make this fully reproducible, I have saved the price data as a CSV file that can be downloaded.

To import the data into our working environment, we will use the `read_csv()` function and download directly the website where I stored this data.


```{r}
sector_prices_2000_2018 <- 
read_csv("https://colorado.rstudio.com/rsc/content/2138/sector_prices_2000_2018.csv") %>% 
select(-X1) %>% 
group_by(sector)
```

Next let's use the `slice()` function to glance at the first price observation for each of the sectors, to confirm that the data looks how we were expecting it to look. Note that the first date is December 29, 1999. I set that as the start date because we eventually want to capture the monthly return of January 2000 and we will index that off of the last day of December 1999.

```{r}
sector_prices_2000_2018 %>% 
  slice(1)
```


The ultimate goal is to regress the monthly sector returns on the the Fama French factors, so let's coerce this daily price data to monthly price data.  

For that task, we use `as_period(period = "month", side = "end")`, which will convert our data to monthly, indexed at the end of each month.  

With our data converted to monthly, we can calculate monthly returns using `mutate(monthly_return = log(adjClose) - log(lag(adjClose)`. The `mutate()` function adds a new column to the data and we set the name of the new column to be `monthly_returns`. We calculate monthly returns as th log of the adjusted close on the final day of the current month, minus the log of the adjusted close on the final day of the previous month. This is for illustration purposes - your team might choose to use a price other than adjusted close and different date periodicities.

```{r}
sector_monthly_returns_2000_2018 <-
sector_prices_2000_2018 %>% 
  as_tbl_time(index = date) %>% 
  as_period(period = "month", side = "end") %>% 
  mutate(monthly_return = log(adjClose) - log(lag(adjClose))) %>% 
  na.omit() 

sector_monthly_returns_2000_2018 %>% 
  slice(1)
```

We now have monthly returns for our sectors, starting in January of 2000.

Next we need to import Fama French factor data and, luckily, FF make their factor data available on their website.

Have a look at the website where the factor data is available.

http://mba.tuck.dartmouth.edu/pages/faculty/ken.french/data_library.html

The data are packaged as zip files so we will need to do a bit more than call `read_csv()`.

We will use the `tempfile()` function from base R to create a variable called `temp`, and will store the zipped file there.

Then we invoke `download.file()` and pass it the URL address of the zip, which is “http://mba.tuck.dartmouth.edu/pages/faculty/ken.french/ftp/Global_5_Factors_CSV.zip”.

```{r}
temp <- tempfile()

download.file(
  "http://mba.tuck.dartmouth.edu/pages/faculty/ken.french/ftp/Global_5_Factors_CSV.zip",
  temp, 
  quiet = TRUE)
```

Next we unzip that data with the `unz()` function read and the csv file using `read_csv()`.

```{r}
Global_5_Factors <- 
  read_csv(unz(temp, "Global_5_Factors.csv"), skip =6) %>%
  rename(date = X1)
```

That loads the data into our environment but we need to do some wrangling to get this raw data into a format that we can join with our monthly returns data. 

Have a look at the date column.

```{r}
Global_5_Factors %>% 
  select(date) %>% 
  head(2)
```

We want to join this data to our monthly returns using the date column, and that means we want the factor date to be in the same format as our monthly returns, but it's currently in a character string with the format `1990007` instead of `1990-07-31`. 

We can call `mutate(date = ymd(parse_date_time(date, "%Y%m")))` to make this transformation. 

```{r}
 
  Global_5_Factors %>%
  mutate(date = ymd(parse_date_time(date, "%Y%m"))) %>% 
  head()
```

That worked well for the date column, but note that all our factor columns have been read in as character strings and we want them to be numeric, and we also want to coerce our date to be indexed at the end of the month, not at the beginning. Here's the code flow to make those transformations.

```{r}
Global_5_Factors_for_join <- 
  Global_5_Factors %>%
  mutate(date = ymd(parse_date_time(date, "%Y%m"))) %>% 
  mutate_at(vars(-date), as.numeric) %>% 
  mutate_if(is.numeric, funs(. / 100)) %>% 
  as_tbl_time(index = date) %>%
  mutate(date = ceiling_date(date, unit = "month") - days(1)) %>% 
  rename(MKT = `Mkt-RF`)

Global_5_Factors_for_join %>% 
  head()
```

The data frame looks good now, but that was quite a bit of work to add a nicely formatted date, indexed to the end of the month and with numeric instead of character data in the other columns.  Now is a good time to note that manipulating and cleaning dates is a crucial and often time-consuming part of financial data work, especially when a project involves mashing together disparate data sets.  The more comfortable and efficient we can get at transforming and aligning dates, the more quickly we can start to work with new and interesting data sources.  

We now have the Fama French factors going back to 1990 and the next task is to regress our sector monthly returns on those factors. Let's use `left_join()` to combine our sector monthly returns data with our factors data, and use the `by = "date"` argument so that only the factor and returns observations with the same dates will remain in the data frame. 

```{r}
sector_factor_data_joined <- 
sector_monthly_returns_2000_2018 %>% 
  left_join(Global_5_Factors_for_join, by = "date") 

sector_factor_data_joined %>% 
  select(-ticker, -adjClose) %>% 
  slice(1)
```

Our data is now in a nicely structured data frame, with our sector names in one column, our sector returns in a separate column, and each of the Fama French factors in a separate column. From here, we want to run our factor analysis, which we do by regressing our monthly returns on the 5 factors. 

For this exercise, let's run the regression on just the `Financials` sectors by first calling `filter(sector == Financials)`. If you wish to reproduce this work but run the regression on a different sector, you can change the code to `filter(sector == your sector of choice)`.

After filtering, we use `do(model = lm(monthly_return ~ Mkt + SMB + HML + RMW + CMA))` to run our regression. 


```{r}

sector_factor_data_joined %>% 
  filter(sector == "Financials") %>% 
  do(model = lm(monthly_return ~ MKT + SMB + HML + RMW + CMA, 
                data = .))
```

That worked, but the results of our 5-factor regression are stored as an `S3` object, which can be hard to access. To clean up the results, and add confidence intervals for our beta estimates, we call `tidy(model, conf.int = T, conf.level = .95)` and rename a couple of columns for convenience.

```{r}
ff_results <-
sector_factor_data_joined %>% 
  filter(sector == "Financials") %>% 
  do(model = lm(monthly_return ~ MKT + SMB + HML + RMW + CMA, 
                data = .)) %>% 
  tidy(model, conf.int = T, conf.level = .95) %>% 
  rename(coefficient = estimate, factor = term)

ff_results
```

Let's finish our work with a chart, showing the coefficient estimates and confidence intervals for our factors. We will use `ggplot()` to build this charting mapping our factor names to the x-axis and our coefficients to the y-axis with `aes(x = factor, y = coefficient)`. Let's place a point for each coefficient by calling `geom_point()` and add confidence intervals with `geom_errorbar()`.

```{r}
ff_results %>% 
filter(factor != "(Intercept)") %>% 
  ggplot(aes(x = factor, 
             y = coefficient, 
             shape = factor, 
             color = factor)) + 
  geom_point() +
  geom_errorbar(aes(ymin = conf.low, 
                    ymax = conf.high)) +
  labs(title = "FF 5-Factor Betas with Conf Intervals",
       x = "",
       y = "coefficients",
       caption = "data source: Fama-French website") +
  theme_minimal() +
  theme(plot.title = element_text(hjust = 0.5),
        plot.caption  = element_text(hjust = 0))
```

We can glance at this and quickly see that the MKT and HML factors have positive coefficients near 1, whereas both RMW and SMB have negative coefficients.  

Remember that we ran the regression on the `Financials` sector but we have monthly returns for several more ETFs. We could expand this work by filtering on a different sector or by adding more factors to the data frame before running the regression. We could also convert our regression model to a rolling regression, to see where we might have missed any significant regime or market shifts, and then visualize our rolling factor coefficients.

We hope that this short note provided some useful R code and some data wrangling functions that might save some time when different date formats confront you. Thanks for reading. 
