Sharpe Ratio on R Views

IPO Exploration

Mon, 21 Oct 2019 00:00:00 +0000

Inspired by recent headlines like “Fear Overtakes Greed in IPO Market after WeWork Debacle” and “This Year’s IPO Class is Least Profitable since the Tech Bubble”, today we’ll explore historical IPO data, and next time we’ll look at the the performance of IPO-driven portfolios constructed during the ten-year period from 2004 to 2014. I’ll admit, I’ve often wondered how a portfolio that allocated money to new IPOs each year might perform since this has to be an ultimate example of a few headline-gobbling whales dominating the collective consciousness. We hear a lot about a few IPOs each year, but there are dozens about which we hear nothing.

Here are the packages we’ll be using today.

library(tidyverse)
library(tidyquant)
library(dplyr)
library(plotly)
library(riingo)
library(roll)
library(tictoc)

Let’s get all the companies listed on the NASDAQ, NYSE, and AMEX exchanges and their IPO dates. That’s not every company that IPO’d in those years, of course, but we’ll go with it as a convenience for today’s purposes. Fortunately, the tq_exchange() function from tidyquant makes it painless to grab this data.

nasdaq <-
  tq_exchange("NASDAQ")

amex  <- 
  tq_exchange("AMEX")

nyse <- 
  tq_exchange("NYSE")

Big-time warning alert: not only have we missed companies that IPO’d and are not listed on those exchanges, we have also missed companies that IPO’d and have ceased to exist, i.e., the companies that went bust, i.e., the very companies that would absolutely scare the heck out of us before we invested in things like recent IPOs. You would need to correct for major survivor bias should you choose to explore this for actual trading. As we’ll see next time, even without those dead companies, portfolios built upon these IPOs are very risky. And, while we’re on the caveat theme, nothing in this post is financial advice in any way.

Back to the exciting part, the code!

Notice how we pulled in data from three different data sources, but our objects have the same column structures. That’s due to some nice work from the tidyquant authors, and it makes our lives easier in the next step, wherein we use bind_rows() to combine the data into one object.

After binding these data together, we select(symbol, company, ipo.year, sector) to isolate a few columns of interest. We will also filter out any tickers with ipo.year equal to NA with filter(!is.na(ipo.year)).

company_ipo_sector <-
  nasdaq %>% 
  bind_rows(amex) %>% 
  bind_rows(nyse) %>% 
  select(symbol, company, ipo.year, sector) %>% 
  filter(!is.na(ipo.year))


company_ipo_sector %>% 
  head()

# A tibble: 6 x 4
  symbol company                                ipo.year sector           
  <chr>  <chr>                                     <dbl> <chr>            
1 TXG    10x Genomics, Inc.                         2019 Capital Goods    
2 YI     111, Inc.                                  2018 Health Care      
3 PIH    1347 Property Insurance Holdings, Inc.     2014 Finance          
4 FLWS   1-800 FLOWERS.COM, Inc.                    1999 Consumer Services
5 BCOW   1895 Bancorp of Wisconsin, Inc.            2019 Finance          
6 VNET   21Vianet Group, Inc.                       2011 Technology

Before we start implementing and testing portfolio strategies in next week’s post, let’s spend today on some exploration of this data set. We have the sector and IPO year of each sector, and a good place to start is visualizing the number of IPOs by year. The key here is to call count(ipo.year), which will do exactly what we hope: give us a count of the number of IPOs by year

company_ipo_sector %>% 
  group_by(ipo.year) %>%
  count(ipo.year) %>% 
  tail()

# A tibble: 6 x 2
# Groups:   ipo.year [6]
  ipo.year     n
     <dbl> <int>
1     2014   258
2     2015   210
3     2016   184
4     2017   274
5     2018   397
6     2019   310

Then we want to pipe straight to ggplot() and put the new n column on the y-axis.

company_ipo_sector %>% 
  group_by(ipo.year) %>%
  count(ipo.year) %>% 
  ggplot(aes(x = ipo.year, y = n)) +
  geom_col(color = "cornflowerblue") + 
  scale_x_continuous(breaks = scales::pretty_breaks(n = 20)) +
  theme(axis.text.x = element_text(angle = 90))

I like that chart, but it would be nice to be able to hover on the bars and get some more information. Let’s wrap the whole code flow inside of the ggplotly() function from plotly, which will convert this to an interactive chart. The names of the columns will be displayed in the tooltip, so let’s use rename(num IPOs = n, year = ipo.year) to create better labels.

ggplotly(
company_ipo_sector %>% 
  group_by(ipo.year) %>%
  count(ipo.year) %>% 
  rename(`num IPOs` = n, year = ipo.year) %>% 
  ggplot(aes(x = year, y = `num IPOs`)) +
  geom_col(color = "cornflowerblue") + 
  scale_x_continuous(breaks = scales::pretty_breaks(n = 20)) +
  theme(axis.text.x = element_text(angle = 90))
)

We see a big decline in 2008 due to the financial crisis, and a steady rise until 2014 when things jump, but that might be due to the fact that since 2014, not as many companies have had a chance to be delisted. I’ll leave it to an IPO maven to explain things further. I did come across this treasure trove of data on the IPO market for the curious. There’s a lot of interesting stuff in there, but one thing to note about this data source and others I stumbled upon is that IPO data tends to focus on companies with a certain market cap, generally greater than $50 million. We didn’t make any cutoff based on market cap, and thus will have more observations than you might find if you Google something like ‘number of IPOs in year XXXX’. For the curious, I’ll post how to create this market cap filter on linkedin, and more importantly, it does set off some neurons in my brain to think that researchers tend to focus on IPOs of a certain market cap. That usually means there’s weird data stuff going on in the ignored area, or it’s risky, or it’s not worth the time to institutional investors because of market structure issues - or any of a host of reasons to investigate the stuff that other people find unattractive.

Let’s get back on course and chart IPOs by sector by year. Instead of using count, we’ll use add_count(), which is a short-hand for group_by() + add_tally().

company_ipo_sector %>% 
  group_by(ipo.year, sector) %>% 
  select(ipo.year, sector) %>% 
  add_count(ipo.year, sector) %>% 
  slice(1) %>% 
  filter(ipo.year > 2003)

# A tibble: 193 x 3
# Groups:   ipo.year, sector [193]
   ipo.year sector                    n
      <dbl> <chr>                 <int>
 1     2004 Basic Industries          3
 2     2004 Capital Goods             4
 3     2004 Consumer Durables         1
 4     2004 Consumer Non-Durables     2
 5     2004 Consumer Services        14
 6     2004 Energy                    2
 7     2004 Finance                   8
 8     2004 Health Care              13
 9     2004 Miscellaneous             2
10     2004 Public Utilities          2
# … with 183 more rows

Now let’s take that data and pipe it to ggplot(). I want to highlight sector differences by year, so will use the fill = sector aesthetic mapping along with facet_wrap(~ipo.year). Let’s also save some room on the x-axis labels by removing the word Consumer from the sector column using mutate(sector = str_remove(sector, "Consumer")).

company_ipo_sector %>% 
  group_by(ipo.year) %>% 
  filter(ipo.year > 2003 & !is.na(sector)) %>%
  mutate(sector = str_remove(sector, "Consumer")) %>% 
  count(sector) %>% 
  ggplot(aes(x = sector, y = n, fill = sector)) +
  geom_col() +
  facet_wrap(~ipo.year) +
  theme(axis.text.x = element_text(angle = 90)) +
  labs(x = "")

Not perfect, but better. Looking at 2013 through 2019, it immediately jumps out that the Health Care and Finance sectors have the most IPOs. Let’s use between(ipo.year, 2004, 2019) to cut down on the number of years and enforce three rows with facet_wrap(~ipo.year, nrow = 3).

We’ll also wrap our entire code flow in parentheses, and then pipe to ggplotly().

(
  company_ipo_sector %>% 
  group_by(ipo.year) %>% 
  filter(between(ipo.year, 2004, 2019) & !is.na(sector)) %>%
  mutate(sector = str_remove(sector, "Consumer")) %>% 
  count(sector) %>% 
  ggplot(aes(x = sector, y = n, fill = sector)) +
  geom_col() +
  facet_wrap(~ipo.year,  nrow = 5) +
  theme(axis.text.x = element_text(angle = 90)) +
  labs(x = "")
  ) %>% 
  ggplotly()

Hover on that chart and notice that the tooltip is displaying the sector twice - that’s because we used sector in both the x and fill aesthetic mappings. To customize the tooltip, we can add an explicit aesthetic mapping called text and paste together exactly what we want to display. I want to show the sector and the number of IPOs, and label those values as such, so will set text = paste("sector:", sector, "<br> Number of IPOs:", n, sep = " "). That creates a new aesthetic mapping inside ggplot(). Now we need to tell ggplotly() to use just that text by adding the argument tooltip = "text" to ggplotly().

(company_ipo_sector %>% 
  group_by(ipo.year) %>% 
  filter(between(ipo.year, 2004, 2019) & !is.na(sector)) %>%
  mutate(sector = str_remove(sector, "Consumer")) %>% 
  count(sector) %>% 
  ggplot(aes(x = sector, y = n, fill = sector, text = paste("sector:", sector, "<br> Number of IPOs:", n, sep = " "))) +
  geom_col() +
  facet_wrap(~ipo.year,  nrow = 5) +
  theme(axis.text.x = element_text(angle = 90)) +
  labs(x = "")
 ) %>% 
  ggplotly(tooltip = "text")

Alright, the tooltip looks how I want it to - notice that we gained another nice functionality. We can double click in the legend to isolate the trace of just one sector throughout these years.

Here’s one more way to organize this data: facet_wrap() ing by sector instead of year. This emphasizes the history of each sector rather than the structure of each year’s IPO market.

(
company_ipo_sector %>% 
  group_by(ipo.year) %>% 
  filter(between(ipo.year, 2004, 2019) & !is.na(sector)) %>%
  mutate(sector = str_remove(sector, "Consumer")) %>% 
  count(sector) %>%  
  ggplot(aes(x = ipo.year, y = n, fill = sector)) +
  geom_col() +
  facet_wrap(~sector) +
  theme(axis.text.x = element_text(angle = 90))
) %>% 
  ggplotly()

This chart really emphasizes the paths of the different sectors - more than 100 Finance IPOs in each of the last two years. If we start allocating dollars based on IPO year, we’re going to get imbalanced exposure to various sectors. In 2018 and 2019, we would have been making heavy tilts to financial and health care.

Let’s move on to evaluating the performance of these companies since their IPOs, which means we need to import their price histories. We have tickers saved in our company_ipo_sector data frame, but before we grab those tickers, let’s do a little clean up. First, some companies have different share classes and multiple tickers, which means they appear more than once. I’m going to get rid of those by using distinct(company, .keep_all = TRUE).

company_ipo_sector %>% 
  distinct(company, .keep_all = TRUE) %>% 
  head()

# A tibble: 6 x 4
  symbol company                                ipo.year sector           
  <chr>  <chr>                                     <dbl> <chr>            
1 TXG    10x Genomics, Inc.                         2019 Capital Goods    
2 YI     111, Inc.                                  2018 Health Care      
3 PIH    1347 Property Insurance Holdings, Inc.     2014 Finance          
4 FLWS   1-800 FLOWERS.COM, Inc.                    1999 Consumer Services
5 BCOW   1895 Bancorp of Wisconsin, Inc.            2019 Finance          
6 VNET   21Vianet Group, Inc.                       2011 Technology

Next, let’s remove missing sector labels with filter(!is.na(sector)) and work with just 10 years of data by adding between(ipo.year, 2004, 2014).

company_ipo_sector %>% 
  distinct(company, .keep_all = TRUE) %>% 
  filter(!is.na(sector) &  between(ipo.year, 2004, 2014)) %>% 
  head()

# A tibble: 6 x 4
  symbol company                                ipo.year sector       
  <chr>  <chr>                                     <dbl> <chr>        
1 PIH    1347 Property Insurance Holdings, Inc.     2014 Finance      
2 VNET   21Vianet Group, Inc.                       2011 Technology   
3 TWOU   2U, Inc.                                   2014 Technology   
4 JOBS   51job, Inc.                                2004 Technology   
5 ABIL   Ability Inc.                               2014 Capital Goods
6 XLRN   Acceleron Pharma Inc.                      2013 Health Care

That leaves us with 842 tickers.

company_ipo_sector %>% 
  distinct(company, .keep_all = TRUE) %>% 
  filter(!is.na(sector) &  between(ipo.year, 2004, 2014)) %>% 
  nrow()

[1] 843

If we want to examine the performance of these companies over time, we’ll need their price histories. 842 tickers is a lot, so for today’s purposes, let’s randomly sample 10 tickers per year, which will give us a total of 110 tickers. To do so, we need to group_by(ipo.year) and then sample_n(10) before a call to pull(symbol).

set.seed(1234)

tickers <-
company_ipo_sector %>% 
  distinct(company, .keep_all = TRUE) %>% 
  filter(!is.na(sector) &  between(ipo.year, 2004, 2014)) %>% 
  group_by(ipo.year) %>%
  # randomly sample 10 tickers per yer
  # if you wish to run this in a more complete way, remove the next line
  sample_n(10) %>%  
  pull(symbol)

We will use the riingo package to import data from the excellent tiingo. We covered that package previously in this post, if a quick refresher is useful.

We do first need to create an API key. riingo makes that quite convenient:

riingo_browse_signup()
# This requires that you are signed in on the site once you sign up
riingo_browse_token()

Now set your token for this session:

# Need an API key for tiingo

riingo_set_token("your API key here")

We’re ready to rock and roll.

Again, to ease the amount of data, we’ll import monthly data instead of daily data by setting resample_frequency = "monthly" inside of riingo_prices().

prices_riingo <-
  tickers %>%
  riingo_prices(start_date = "2004-01-01",  resample_frequency = "monthly") %>% 
  group_by(ticker)

Here’s a look at the first three months of prices for tickers that IPO’d in the first half 2004. Notice that each price series starts on a different date, depending on what month the company went public.

prices_riingo %>% 
  filter(date <= "2004-07-01") %>% 
  slice(1:3)

# A tibble: 11 x 14
# Groups:   ticker [4]
   ticker date                close  high   low  open volume adjClose
   <chr>  <dttm>              <dbl> <dbl> <dbl> <dbl>  <int>    <dbl>
 1 ABR    2004-04-30 00:00:00  19.4  20.6  19    20.0 5.61e6     6.21
 2 ABR    2004-05-31 00:00:00  19.0  20.0  18.4  19.4 6.20e5     6.05
 3 ABR    2004-06-30 00:00:00  20.0  21    18.5  19   1.46e6     6.37
 4 BCBP   2004-01-30 00:00:00  21    24.8  21    21   9.90e3    12.0 
 5 BCBP   2004-02-27 00:00:00  28    28    21.1  22   9.80e3    15.9 
 6 BCBP   2004-03-31 00:00:00  27    28    24    27   1.21e4    15.4 
 7 NUVA   2004-05-31 00:00:00  11.2  11.6  10.3  11.0 7.59e6    11.2 
 8 NUVA   2004-06-30 00:00:00  11.0  12.2  10.6  11.2 1.90e6    11.0 
 9 NWBI   2004-01-30 00:00:00  22.5  23.2  20.2  21.2 1.01e6     5.27
10 NWBI   2004-02-27 00:00:00  25.3  26.7  22.5  23.0 1.36e6     5.94
11 NWBI   2004-03-31 00:00:00  25.4  26.1  23.7  25.1 7.87e5     5.96
# … with 6 more variables: adjHigh <dbl>, adjLow <dbl>, adjOpen <dbl>,
#   adjVolume <int>, divCash <dbl>, splitFactor <dbl>

A quick caveat, we’re working with monthly prices here to avoid the load of daily frequencies and, thus, we get the price on the last day of the month of the IPO. Taking NUVA as an example, the stock was listed on 2004-05-13 so our first price observation is 2004-05-31.

prices_riingo %>% 
  filter(ticker == "NUVA") %>% 
  head()

# A tibble: 6 x 14
# Groups:   ticker [1]
  ticker date                close  high   low  open volume adjClose
  <chr>  <dttm>              <dbl> <dbl> <dbl> <dbl>  <int>    <dbl>
1 NUVA   2004-05-31 00:00:00 11.2   11.6 10.3  11.0  7.59e6    11.2 
2 NUVA   2004-06-30 00:00:00 11.0   12.2 10.6  11.2  1.90e6    11.0 
3 NUVA   2004-07-30 00:00:00 10     11.3  9.35 11.1  1.08e6    10   
4 NUVA   2004-08-31 00:00:00  9.49  10.4  8.97  9.9  9.21e5     9.49
5 NUVA   2004-09-30 00:00:00 10.6   11.2  9.32  9.63 6.47e5    10.6 
6 NUVA   2004-10-29 00:00:00  9.86  11.6  9.25 10.4  3.14e6     9.86
# … with 6 more variables: adjHigh <dbl>, adjLow <dbl>, adjOpen <dbl>,
#   adjVolume <int>, divCash <dbl>, splitFactor <dbl>

Let’s go ahead and calculate monthly returns for each of our tickers by calling mutate(monthly_return = close/lag(close) - 1).

prices_riingo %>% 
  select(ticker, date, close) %>% 
  mutate(monthly_return = close/lag(close) - 1) %>% 
  head()

# A tibble: 6 x 4
# Groups:   ticker [1]
  ticker date                close monthly_return
  <chr>  <dttm>              <dbl>          <dbl>
1 ABR    2004-04-30 00:00:00  19.4        NA     
2 ABR    2004-05-31 00:00:00  19.0        -0.0252
3 ABR    2004-06-30 00:00:00  20.0         0.0522
4 ABR    2004-07-30 00:00:00  19          -0.0476
5 ABR    2004-08-31 00:00:00  20.9         0.0984
6 ABR    2004-09-30 00:00:00  22.2         0.0637

We have monthly returns for each of our tickers since inception. Since we ultimately plan to build some toy portfolios based on different selection methods or algorithms, let’s take a quick look at how these companies have performed.

We’ll use a few methods to get a feel for performance. First, we’ll calculate the Sharpe Ratio for each company. For more information on the Sharpe Ratio, see this post, but in short, it’s a measure of the ratio of return to risk, so a higher Sharpe Ratio is better than a lower Sharpe Ratio.

There is a SharpeRatio function in the PerformanceAnalytics package, and we can use tq_performance() to apply that function to our tidy tibble of monthly returns.

We have 110 tickers so we’ll expect to get 110 observations back.

prices_riingo %>% 
  select(ticker, date, close) %>% 
  mutate(monthly_return = close/lag(close) - 1) %>%
  tq_performance(Ra = monthly_return,
                 performance_fun = SharpeRatio,
                 FUN = "StdDev")

# A tibble: 110 x 2
# Groups:   ticker [110]
   ticker `StdDevSharpe(Rf=0%,p=95%)`
   <chr>                        <dbl>
 1 ABR                         0.0703
 2 MNKD                        0.0659
 3 NUVA                        0.142 
 4 DPZ                         0.205 
 5 HEP                         0.0384
 6 KNL                         0.0704
 7 CHCI                        0.0743
 8 BECN                        0.0911
 9 ENS                         0.136 
10 WCG                         0.190 
# … with 100 more rows

Let’s go ahead and order these by Sharpe Ratio, from highest to lowest, using arrange(desc(better_name_for_this_column)).

prices_riingo %>% 
  select(ticker, date, close) %>% 
  mutate(monthly_return = close/lag(close) - 1) %>%
  tq_performance(Ra = monthly_return,
                 performance_fun = SharpeRatio,
                 FUN = "StdDev") %>%
  `colnames<-`(c("ticker", "sharpe_ratio")) %>% 
  arrange(desc(sharpe_ratio)) %>% 
  head(10)

# A tibble: 10 x 2
# Groups:   ticker [10]
   ticker sharpe_ratio
   <chr>         <dbl>
 1 RNG           0.317
 2 AWK           0.288
 3 DG            0.285
 4 GWRE          0.277
 5 IBP           0.248
 6 POST          0.223
 7 WD            0.217
 8 MELI          0.206
 9 DPZ           0.205
10 TRNO          0.202

Since the start dates are jagged, a cumulative return won’t really be a fair comparison - one ticker might have a higher or lower Sharpe Ratio simply by virtue of being in existence longer. To account for that, let’s add the annualize = TRUE argument.

prices_riingo %>% 
  select(ticker, date, close) %>% 
  mutate(monthly_return = close/lag(close) - 1) %>%
  tq_performance(Ra = monthly_return,
                 performance_fun = SharpeRatio,
                 FUN = "StdDev", 
                 annualize = TRUE) %>% 
  `colnames<-`(c("ticker", "sharpe_ratio")) %>% 
  arrange(desc(sharpe_ratio))  %>% 
  head(10)

# A tibble: 10 x 2
# Groups:   ticker [10]
   ticker sharpe_ratio
   <chr>         <dbl>
 1 RNG           1.07 
 2 AWK           0.981
 3 DG            0.960
 4 GWRE          0.919
 5 IBP           0.761
 6 POST          0.699
 7 TRNO          0.643
 8 WD            0.640
 9 DPZ           0.561
10 LOPE          0.533

The tickers in the top 10 didn’t change, but the order of the tickers did change. That would make a big difference if we implemented a sorting algorithm based on Sharpe Ratio cut-points.

Let’s quickly port this to ggplot(). We’ll remove the x-axis labels and tick marks by supplying element_blank() to axis.text.x and axis.ticks.x, customize the tooltip with the text aesthetic mapping again and pipe to ggplotly(). That will give us an interactive, scrollable legend.

(
prices_riingo %>% 
  select(ticker, date, close) %>% 
  mutate(monthly_return = close/lag(close) - 1) %>%
  tq_performance(Ra = monthly_return,
                 performance_fun = SharpeRatio,
                 FUN = "StdDev", 
                 annualize = TRUE) %>%
  `colnames<-`(c("ticker", "sharpe_ratio")) %>% 
  arrange(desc(sharpe_ratio)) %>% 
  ggplot(aes(x = ticker, y = sharpe_ratio, color = ticker, text = paste("ticker:", ticker, "<br> sharpe ratio:", round(sharpe_ratio, 3), sep = " "))) +
  geom_point(aes(color = ticker)) +
  theme(axis.text.x = element_blank(),
        axis.ticks.x = element_blank())
) %>% 
  ggplotly(tooltip = "text")

Note, though, that the Sharpe Ratio is an aggregate measure in the sense that it gives us one number as a measure of performance over time, and could be hiding pockets of high turbulence. To adjust for that, let’s calculate the rolling mean return, rolling standard deviation of returns, and the ratio of those two will give the rolling Sharpe Ratio. I’ve heard rumors that there’s a blazing fast package for rolling calculations called, appropriately, the roll package. roll has a built-in rolling mean function called roll_mean and a rolling standard deviation function called roll_sd.

We can call those in inside of mutate() as long as we convert our monthly_returns column to a matrix inside the pipe. Here’s the full code flow:

prices_riingo %>% 
  select(ticker, date, close) %>% 
  mutate(monthly_returns = close/lag(close) - 1,
         rolling_mean = roll_mean(as.matrix(monthly_returns), 6, na_restore = T),
         rolling_sd = roll_sd(as.matrix(monthly_returns), 6, na_restore = T),
         rolling_sharpe = rolling_mean/rolling_sd) %>% 
  na.omit() %>% 
  head()

# A tibble: 6 x 7
# Groups:   ticker [1]
  ticker date                close monthly_returns rolling_mean rolling_sd
  <chr>  <dttm>              <dbl>           <dbl>        <dbl>      <dbl>
1 ABR    2004-10-29 00:00:00  20.9         -0.0586       0.0138     0.0658
2 ABR    2004-11-30 00:00:00  23.6          0.129        0.0396     0.0768
3 ABR    2004-12-31 00:00:00  24.5          0.0398       0.0375     0.0765
4 ABR    2005-01-31 00:00:00  23.8         -0.0302       0.0404     0.0729
5 ABR    2005-02-28 00:00:00  25            0.0504       0.0324     0.0677
6 ABR    2005-03-31 00:00:00  24.8         -0.01         0.0201     0.0676
# … with 1 more variable: rolling_sharpe <dbl>

And for timing purposes:

tic()
rolling_sharpe_roll_timed <- 
  prices_riingo %>% 
  select(ticker, date, close) %>% 
  mutate(monthly_returns = close/lag(close) - 1,
         rolling_mean = roll_mean(as.matrix(monthly_returns), 6, na_restore = T),
         rolling_sd = roll_sd(as.matrix(monthly_returns), 6, na_restore = T),
         rolling_sharpe = rolling_mean/rolling_sd) %>% 
  na.omit()
toc()

0.021 sec elapsed

On my machine, that took about 0.1 seconds. That is one-tenth of a second to perform three rolling calcs on 110 tickers.

Here’s the same calculation with tidyquant.

sharpe_tq_roll <- function(df){
  SharpeRatio(df, 
              Rf = 0, 
              FUN = "StdDev")
}

tic()
rolling_sharpe_tq_timed <- 
prices_riingo %>% 
  select(ticker, date, close) %>% 
  mutate(monthly_returns = close/lag(close) - 1) %>% 
  na.omit() %>% 
tq_mutate(
        select     = monthly_returns,
        mutate_fun = rollapply, 
        width      = 6,
        align      = "right",
        FUN        = sharpe_tq_roll,
        col_rename = "tq_sharpe"
    ) %>% 
  na.omit()
toc()

11.208 sec elapsed

That took about 10 seconds on my machine.

Alright, speed tests are fun but let’s get these rolling calculations into some visualizations. Let’s see how a first try with ggplotly() treats us.

(
rolling_sharpe_roll_timed %>% 
  ggplot(aes(x = date, y = rolling_sharpe, color = ticker)) +
  geom_line(show.legend = FALSE)
) %>% 
  ggplotly()

Well, that chart isn’t bad - it gives some sense of the range for these rolling Sharpes and we can again double-click the legend to isolate the fund of our choice.

That’s all for today. Next time we’ll get into some CAGR calculations and portfolio building. If you like this sort of code through check out my book, Reproducible Finance with R. Thanks for reading and see you next time!

Some final notes:
1. Not specific to finance, but several of the stringr and ggplot tricks in this post came from this awesome Business Science University course. 2. I’m also going to be posting weekly code snippets on linkedin, connect with me there if you’re keen for some R finance stuff.

Reproducible Finance with R: A Sharpe Ratio Shiny App

Fri, 18 Nov 2016 00:00:00 +0000

In this previous post, we used an R Notebook to grab the monthly return data on three stocks, build a portfolio, visualize portfolio performance, and calculate the Sharpe Ratio. The Notebook format emphasized reproducibility and reuse by other R coders.

Today, we’ll convert that Notebook into a Shiny application that allows end users to build their own portfolios, and then calculate performance/Sharpe Ratio. Friday = fun day!

Here is the link to the app.

Close readers of the source code for this app will see that it was built in an Rmarkdown file (with output: flexdashboard::flexdashboard and runtime: shiny added to the YAML header).

---
title: "Sharpe Ratio Shiny"
runtime: shiny
output:
  flexdashboard::flex_dashboard:
    orientation: rows
    source_code: embed
---

This app could have been built using an app.r file, but I prefer to use a flexdashboard because it keeps the entire workflow in the Rmarkdown world. In the previous post, we started with a Notebook (also an Rmarkdown file type) and made use of code chunks to enforce logic on our data import, calculations and visualizations. This Shiny app makes use of the same code chunk structure, and I find that the logic translates well. For example, the setup chunks are almost identical and contain our most important function.

```{r setup, message = FALSE}
library(shiny)
library(flexdashboard)
library(PerformanceAnalytics)
library(quantmod)
library(dygraphs)

# Function to calculate monthly returns on a stock
monthly_stock_returns <- function(ticker, start_year) {
  # Download the data from Yahoo finance
  symbol <- getSymbols(ticker, src = 'yahoo', from = start_year,
                       auto.assign = FALSE, warnings = FALSE)
  # Tranform it to monthly returns using the periodReturn function from quantmod
  data <- periodReturn(symbol, period = 'monthly', type = 'log')

  # Let's rename the column of returns to something intuitive because the column
  # name is what will eventually be displayed on the time series graph
  colnames(data) <- as.character(ticker)

  # We want to be able to work with the xts objects that result from this function
  # so let's explicitly put them to the global environment with an easy to use
  # name, the stock ticker
  assign(ticker, data, .GlobalEnv)
}
```

The sidebar code chunk is, of course, unique to the Shiny app, because there are no reactive inputs in a Notebook. But the dygraphs code chunks are similar enough that it’s easy to transfer the Notebook code, with a few changes, over to the flexdashboard:

```{r}
##dygraph chunk
dygraphOutput("dygraphDollarGrowth")

output$dygraphDollarGrowth%
    dyAxis("y", label = "$") %>%
    dyOptions(axisLineWidth = 1.5, fillGraph = TRUE, drawGrid = TRUE)
})
```

File formats aside, from a team workflow perspective, this conversion to a Shiny app is super important - it’s where the R coders co-mingle with team members who need to make use of R’s analytical tools, but do not want to touch the code. For example, we can imagine a portfolio manager who wants the ability to quickly iterate through different portfolios and compare Sharpe Ratios, for internal construction purposes or perhaps even in a client-facing context. The PM does not want to write or reproduce this R code; he or she wants to focus on the portfolio.

In other words, a PM wants to see this:

Not this:

```{r}
##dygraph chunk
dygraphOutput("dygraphDollarGrowth")

output$dygraphDollarGrowth<-renderDygraph({
  dygraph(portfolio_growth(), main = "Growth of $1 Invested in Your Portfolio") %>%
    dyAxis("y", label = "$") %>%
    dyOptions(axisLineWidth = 1.5, fillGraph = TRUE, drawGrid = TRUE)
})
```

```{r}
valueBoxOutput("approvalBox1")
output$approvalBox1<-renderValueBox({
  valueBox(value = sharpe_ratio(), icon = "fa-line-chart", color = "primary")
})
```

Note that the portfolio performance and Share Ratio calculations are consolidated and moved to the front page, and the individual stock returns are on the second page. The original Notebook had the opposite layout - we began with individual returns and progressed to the portfolio - because it was emphasizing the steps involved in arriving at the conclusion. We wanted our collaborators to start with the basics of grabbing stock return data and then proceed through each logical step.

With this Shiny app, we don’t want to force our collaborators to go through our logic, because that is not the purpose of this app. End users of this app build and analyze portfolios, so let’s put those tools front and center. Give the users what they want!

Have fun with this app, dream about buying tech stocks at their lows, and remember, as with our previous Notebook, that this app is a starting point. End users might want the ability to choose more than three stocks, or add bonds to the portfolio, or benchmark against a return other than a risk-free rate. This is where R coders and portfolio managers start to collaborate and build things bigger and better. Have a good weekend!

Reproducible Finance with R: The Sharpe Ratio

Wed, 09 Nov 2016 00:00:00 +0000

Financial applications were an early driving force behind the adoption of the R language, but as data science becomes increasingly critical to banks, hedge funds, investment managers, data providers, exchanges, etc., R is becoming even more important to Finance. We are excited and inspired by what the future holds in the brave new world of data-driven financial institutions. In this first post of what we hope will be a regular series about Finance, R and RStudio, we present a classic use case: import stock data, build a portfolio, and calculate the Sharpe Ratio. We use the new RStudio IDE Notebooks tool to emphasize reproducibility.

By way of a brief roadmap, we’ll start with a function that grabs monthly stock returns and saves those monthly returns as an xts object in the global environment. With that function, we will create three xts objects of monthly returns, and merge those three xts objects into one object, before passing that merged object to dygraphs to peek at the individual stocks. Then, we move on to build a portfolio by selecting asset weights and calculating the portfolio monthly returns. Next, we will calculate the growth of a dollar invested in that portfolio (which is what matters to us) over time, and save the results to an xts object. Dygraphs will come in handy again for the portfolio visualizations. Finally, we will calculate the Sharpe Ratio.

Before we get to the fun stuff - the code itself! - I will note that these posts aim to be useful to R coders who either work in the financial industry or want to work in the financial industry. At times the posts will contain ideas or paradigms that are good practice in the institutional context but perhaps not directly relevant to an R user on the lookout for one-off coding tricks. That is a good segue into the structure and content of this Notebook, which could be fit comfortably into one setup chunk and one substantive code chunk, instead of my five chunks.

I chose to use five chunks to demonstrate how this document might fit into the workflow of a team of analysts with varying levels of R knowledge. Team workflow + reproducibility is going to be a recurrent theme in this series, as it is a recurrent theme at financial institutions using the RStudio toolchain.

Five chunks breaks this code into simple steps: build an import function, choose/visualize the stocks, choose portfolio weights/visualize returns, and calculate the Sharpe Ratio. From a team workflow perspective, this structure could be an introductory template for analysts that are just learning R, or it could serve as the starting point for advanced users who want to use the data import and return functions before they add complexity. For example, calculating the Sharpe Ratio is just the beginning of risk-to-volatility analysis, and most shops have their own proprietary algorithms/models to advance the analysis. Beginners or advanced users could start with a common Notebook template like this one, to standardize the data import and basic visualization workflow.

Now, onwards to the setup code chunk, where we load three packages: quantmod to download the data, PerformanceAnalytics to run portfolio calculations, and dygraphs to graph time series objects. We will also create a function to import stock data.

library(PerformanceAnalytics)
library(quantmod)
library(dygraphs)

# Function to calculate monthly returns on a stock
monthly_stock_returns <- function(ticker, start_year) {
  # Download the data from Yahoo finance
  symbol <- getSymbols(ticker, src = 'yahoo', auto.assign = FALSE, warnings = FALSE)
  # Tranform it to monthly returns using the periodReturn function from quantmod
  data <- periodReturn(symbol, period = 'monthly', subset=paste(start_year, "::", sep = ""),
                       type = 'log')

  # Let's rename the column of returns to something intuitive because the column name is what
  # will eventually be displayed on the time series graph.
  colnames(data) <- as.character(ticker)

  # We want to be able to work with the xts objects that result from this function
  # so let's explicitly put them to the global environment with an easy to use
  # name, the stock ticker.
  assign(ticker, data, .GlobalEnv)
}

The monthly_stock_returns function above takes 2 parameters, a stock symbol and a year. Note that we could have included a third parameter called something like ‘period’ if we wanted the ability to grab periods other than monthly returns. For example, we can envision a desire to look at annual, weekly or daily returns. Here, I force monthly returns because I don’t want to allow different period options. It’s a choice driven by the purpose of this Notebook - which here is focused on monthly returns.

In the next chunk, we choose three stock tickers and a starting year argument for the monthly_stock_returns function. Then, we merge them into one xts object and graph their individual performances over time.

# Choose the starting year and assign it to the 'year' variable. How about 2010?
year <- 2010

# Use the function the monthly returns on 3 stocks, and pass in the 'year' value
# Let's choose Google, JP Morgan and Amazon; after you run these functions, have
# a look at the global environment and make sure your three xts objects are there
monthly_stock_returns('GOOG', year)

##     As of 0.4-0, 'getSymbols' uses env=parent.frame() and
##  auto.assign=TRUE by default.
## 
##  This  behavior  will be  phased out in 0.5-0  when the call  will
##  default to use auto.assign=FALSE. getOption("getSymbols.env") and 
##  getOptions("getSymbols.auto.assign") are now checked for alternate defaults
## 
##  This message is shown once per session and may be disabled by setting 
##  options("getSymbols.warning4.0"=FALSE). See ?getSymbols for more details.

monthly_stock_returns('JPM', year)
monthly_stock_returns('AMZN', year)

# Merge the 3 monthly return xts objects into 1 xts object.
merged_returns <- merge.xts(GOOG, JPM, AMZN)

# Before we combine these into a portfolio, graph the individual returns and
# see if anything jumps out as unusual. It looks like something happened to
# Google in March of 2014, but that something didn't affect JP Morgan or Amazon.
dygraph(merged_returns, main = "Google v JP Morgan v Amazon") %>%
  dyAxis("y", label = "%") %>%
  dyOptions(colors = RColorBrewer::brewer.pal(3, "Set2"))

Nothing earth-shattering thus far: we have an xts object of three time series and have seen that one of them had weird behavior in April of 2014 (a Google stock split). We’ll ignore that behavior for this example and go on to constructing a portfolio, which means finding the monthly returns of a weighted combination of assets. Unsurprisingly, we start out by choosing those weights.

# We have the 3 monthly returns saved in 1 object.
# Now, let's choose the respective weights of those 3.
# Here we'll allocate 25% to Google, 25% to JP Morgan and 50% to Amazon.
w <- c(.25, .25, .50)

# Now use the built in PerformanceAnalytics function Return.portfolio
# to calculate the monthly returns on the portfolio, supplying the vector of weights 'w'.
portfolio_monthly_returns <- Return.portfolio(merged_returns, weights = w)

# Use dygraphs to chart the portfolio monthly returns.
dygraph(portfolio_monthly_returns, main = "Portfolio Monthly Return") %>%
  dyAxis("y", label = "%")

Now, instead of looking at monthly returns, let’s look at how $1 would have grown in this portfolio.

# Add the wealth.index = TRUE argument and, instead of returning monthly returns,
# the function will return the growth of $1 invested in the portfolio.
dollar_growth <- Return.portfolio(merged_returns, weights = w, wealth.index = TRUE)

# Use dygraphs to chart the growth of $1 in the portfolio.
dygraph(dollar_growth, main = "Growth of $1 Invested in Portfolio") %>%
  dyAxis("y", label = "$")

A dollar would have grown quite nicely in this portfolio - about 2.5x - fantastic. Now let’s look at the risk/reward of this portfolio by calculating the Sharpe Ratio. Briefly, the Sharpe Ratio is the mean of the excess monthly returns above the risk-free rate, divided by the standard deviation of the excess monthly returns above the risk-free rate. This is the formulation of the Sharpe Ratio as of 1994; if we wished to use the original formulation from 1966 the denominator would be the standard deviation of portfolio monthly returns. Learn more here.

In other words, the Sharpe Ratio measures excess returns per unit of volatility, where we take the standard deviation to represent portfolio volatility. The Sharpe Ratio was brought to us by Bill Sharpe - arguably the most important economist for modern investment management as the creator of the Sharpe Ratio, CAPM and Financial Engines, a forerunner of today’s robo-advisor movement.

In the code chunk below, we’ll calculate the Sharpe Ratio in two ways.

First, we’ll use the Return.excess function from PerformanceAnalytics to calculate a time series of monthly excess returns. Two arguments need to be supplied: the time series of returns and the risk-free rate. The function will return a time series of excess returns, and we’ll take the mean of that time series to get the numerator of the Sharpe Ratio. Then we’ll divide by the standard deviation of the that time series to get the Sharpe Ratio.

Our second method is a bit easier. We’ll use the SharpeRatio function in PerformanceAnalytics, for which we’ll supply two arguments: a time series of monthly returns and risk-free rate.

For both methods I use a risk-free rate of .03% as the approximate mean of the 1-month Treasury bill rate since 2010. I’ll cover a quick way to grab this and other data via Quandl in a future post.

# Method 1: use the Return.excess function from PerformanceAnalytics,
# then calculate the Sharpe Ratio manually.
portfolio_excess_returns <- Return.excess(portfolio_monthly_returns, Rf = .0003)
sharpe_ratio_manual <- round(mean(portfolio_excess_returns)/StdDev(portfolio_excess_returns), 4)

# If we wanted to use the original, 1966 formulation of the Sharpe Ratio, there is one small
# change to the code in Method 1.
# sharpe_ratio_manual <- round(mean(portfolio_excess_returns)/StdDev(portfolio_monthly_returns), 4)

# Method 2: use the built in SharpeRatio function in PerformanceAnalytics.
sharpe_ratio <- round(SharpeRatio(portfolio_monthly_returns, Rf = .0003), 4)

Using the Return.excess function and then dividing by the standard deviation of excess returns, the Sharpe Ratio is sharpe_ratio_manual[,1] = 0.211.

Using the built in SharpeRatio function, the Sharpe Ratio is sharpe_ratio[1,] = 0.211.

Alright, we have built a portfolio and calculated the Sharpe Ratio - and also set up some nice reusable chunks for data import, portfolio construction and visualization. We haven’t done anything terribly complex but this can serve as a useful paradigm to any collaborators, including our future selves, who want to reproduce this work, learn from this work, or expand upon this work.

In the next post, we will create a Shiny app to let users enter their own stock tickers, starting year, portfolio weights and risk-free rate, and then calculate a portfolio Sharpe Ratio. See you next time!