3.0 Workflow
The general workflow is shown in the diagram below. We’ll step through the workflow first with a group of individual assets (stocks) and then with portfolios of stocks.
Performance Analysis Workflow
3.1 Individual Assets
Individual assets are the simplest form of analysis because there is no portfolio aggregation (Step 3A). We’ll re-do the “Quick Example” this time getting the Sharpe Ratio, a measure of reward-to-risk.
Before we get started let’s find the performance function we want to
use from PerformanceAnalytics. Searching
tq_performance_fun_options, we can see that
SharpeRatio is available. Type ?SharpeRatio,
and we can see that the arguments are:
args(SharpeRatio)## function (R, Rf = 0, p = 0.95, FUN = c("StdDev", "VaR", "ES"),
## weights = NULL, annualize = FALSE, SE = FALSE, SE.control = NULL,
## ...)
## NULLWe can actually skip the baseline path because the function does not
require Rb. The function takes R, which is
passed using Ra in
tq_performance(Ra, Rb, performance_fun, ...). A little bit
of foresight saves us some work.
Step 1A: Get stock prices
Use tq_get() to get stock prices.
stock_prices <- c("AAPL", "GOOG", "NFLX") %>%
tq_get(get = "stock.prices",
from = "2010-01-01",
to = "2015-12-31")
stock_prices## # A tibble: 4,527 × 8
## symbol date open high low close volume adjusted
## <chr> <date> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 AAPL 2010-01-04 7.62 7.66 7.58 7.64 493729600 6.53
## 2 AAPL 2010-01-05 7.66 7.70 7.62 7.66 601904800 6.54
## 3 AAPL 2010-01-06 7.66 7.69 7.53 7.53 552160000 6.43
## 4 AAPL 2010-01-07 7.56 7.57 7.47 7.52 477131200 6.42
## 5 AAPL 2010-01-08 7.51 7.57 7.47 7.57 447610800 6.46
## 6 AAPL 2010-01-11 7.6 7.61 7.44 7.50 462229600 6.41
## 7 AAPL 2010-01-12 7.47 7.49 7.37 7.42 594459600 6.33
## 8 AAPL 2010-01-13 7.42 7.53 7.29 7.52 605892000 6.42
## 9 AAPL 2010-01-14 7.50 7.52 7.46 7.48 432894000 6.39
## 10 AAPL 2010-01-15 7.53 7.56 7.35 7.35 594067600 6.28
## # … with 4,517 more rowsStep 2A: Mutate to returns
Using the tidyverse split, apply, combine framework, we
can mutate groups of stocks by first “grouping” with
group_by and then applying a mutating function using
tq_transmute. We use the quantmod function
periodReturn as the mutating function. We pass along the
arguments period = "monthly" to return the results in
monthly periodicity. Last, we use the col_rename argument
to rename the output column.
stock_returns_monthly <- stock_prices %>%
group_by(symbol) %>%
tq_transmute(select = adjusted,
mutate_fun = periodReturn,
period = "monthly",
col_rename = "Ra")
stock_returns_monthly## # A tibble: 216 × 3
## # Groups: symbol [3]
## symbol date Ra
## <chr> <date> <dbl>
## 1 AAPL 2010-01-29 -0.103
## 2 AAPL 2010-02-26 0.0654
## 3 AAPL 2010-03-31 0.148
## 4 AAPL 2010-04-30 0.111
## 5 AAPL 2010-05-28 -0.0161
## 6 AAPL 2010-06-30 -0.0208
## 7 AAPL 2010-07-30 0.0227
## 8 AAPL 2010-08-31 -0.0550
## 9 AAPL 2010-09-30 0.167
## 10 AAPL 2010-10-29 0.0607
## # … with 206 more rowsStep 3A: Aggregate to Portfolio Returns (Skipped)
Step 3A can be skipped because we are only interested in the Sharpe Ratio for individual stocks (not a portfolio).
Step 3B can also be skipped because the SharpeRatio
function from PerformanceAnalytics does not require a
baseline.
Step 4: Analyze Performance
The last step is to apply the SharpeRatio function to
our groups of stock returns. We do this using
tq_performance() with the arguments Ra = Ra,
Rb = NULL (not required), and
performance_fun = SharpeRatio. We can also pass other
arguments of the SharpeRatio function such as
Rf, p, FUN, and
annualize. We will just use the defaults for this
example.
stock_returns_monthly %>%
tq_performance(
Ra = Ra,
Rb = NULL,
performance_fun = SharpeRatio
)## # A tibble: 3 × 4
## # Groups: symbol [3]
## symbol `ESSharpe(Rf=0%,p=95%)` `StdDevSharpe(Rf=0%,p=95%)` VaRSharpe(Rf=0%,p…¹
## <chr> <dbl> <dbl> <dbl>
## 1 AAPL 0.173 0.292 0.218
## 2 GOOG 0.129 0.203 0.157
## 3 NFLX 0.237 0.284 0.272
## # … with abbreviated variable name ¹`VaRSharpe(Rf=0%,p=95%)`Now we have the Sharpe Ratio for each of the three stocks. What if we want to adjust the parameters of the function? We can just add on the arguments of the underlying function.
stock_returns_monthly %>%
tq_performance(
Ra = Ra,
Rb = NULL,
performance_fun = SharpeRatio,
Rf = 0.03 / 12,
p = 0.99
)## # A tibble: 3 × 4
## # Groups: symbol [3]
## symbol `ESSharpe(Rf=0.2%,p=99%)` `StdDevSharpe(Rf=0.2%,p=99%)` VaRSharpe(Rf=…¹
## <chr> <dbl> <dbl> <dbl>
## 1 AAPL 0.116 0.258 0.134
## 2 GOOG 0.0826 0.170 0.0998
## 3 NFLX 0.115 0.272 0.142
## # … with abbreviated variable name ¹`VaRSharpe(Rf=0.2%,p=99%)`3.2 Portfolios (Asset Groups)
Portfolios are slightly more complicated because we are now dealing
with groups of assets versus individual stocks, and we need to aggregate
weighted returns. Fortunately, this is only one extra step with
tidyquant using tq_portfolio().
Single Portfolio
Let’s recreate the CAPM analysis in the “Quick Example” this time comparing a portfolio of technology stocks to the SPDR Technology ETF (XLK).
Steps 1A and 2A: Asset Period Returns
This is the same as what we did previously to get the monthly returns
for groups of individual stock prices. We use the split, apply, combine
framework using the workflow of tq_get,
group_by, and tq_transmute.
stock_returns_monthly <- c("AAPL", "GOOG", "NFLX") %>%
tq_get(get = "stock.prices",
from = "2010-01-01",
to = "2015-12-31") %>%
group_by(symbol) %>%
tq_transmute(select = adjusted,
mutate_fun = periodReturn,
period = "monthly",
col_rename = "Ra")
stock_returns_monthly## # A tibble: 216 × 3
## # Groups: symbol [3]
## symbol date Ra
## <chr> <date> <dbl>
## 1 AAPL 2010-01-29 -0.103
## 2 AAPL 2010-02-26 0.0654
## 3 AAPL 2010-03-31 0.148
## 4 AAPL 2010-04-30 0.111
## 5 AAPL 2010-05-28 -0.0161
## 6 AAPL 2010-06-30 -0.0208
## 7 AAPL 2010-07-30 0.0227
## 8 AAPL 2010-08-31 -0.0550
## 9 AAPL 2010-09-30 0.167
## 10 AAPL 2010-10-29 0.0607
## # … with 206 more rowsSteps 1B and 2B: Baseline Period Returns
This was also done previously.
baseline_returns_monthly <- "XLK" %>%
tq_get(get = "stock.prices",
from = "2010-01-01",
to = "2015-12-31") %>%
tq_transmute(select = adjusted,
mutate_fun = periodReturn,
period = "monthly",
col_rename = "Rb")
baseline_returns_monthly## # A tibble: 72 × 2
## date Rb
## <date> <dbl>
## 1 2010-01-29 -0.0993
## 2 2010-02-26 0.0348
## 3 2010-03-31 0.0684
## 4 2010-04-30 0.0126
## 5 2010-05-28 -0.0748
## 6 2010-06-30 -0.0540
## 7 2010-07-30 0.0745
## 8 2010-08-31 -0.0561
## 9 2010-09-30 0.117
## 10 2010-10-29 0.0578
## # … with 62 more rowsStep 3A: Aggregate to Portfolio Period Returns
The tidyquant function, tq_portfolio()
aggregates a group of individual assets into a single return using a
weighted composition of the underlying assets. To do this we need to
first develop portfolio weights. There are two ways to do this for a
single portfolio:
- Supplying a vector of weights
- Supplying a two column tidy data frame (tibble) with stock symbols in the first column and weights to map in the second.
Suppose we want to split our portfolio evenly between AAPL and NFLX. We’ll show this using both methods.
Method 1: Aggregating a Portfolio using Vector of Weights
We’ll use the weight vector, c(0.5, 0, 0.5). Two
important aspects to supplying a numeric vector of weights: First,
notice that the length (3) is equal to the number of assets (3). This is
a requirement. Second, notice that the sum of the weighting vector is
equal to 1. This is not “required”, but is best practice. If the sum is
not 1, the weights will be distributed accordingly by scaling the vector
to 1, and a warning message will appear.
wts <- c(0.5, 0.0, 0.5)
portfolio_returns_monthly <- stock_returns_monthly %>%
tq_portfolio(assets_col = symbol,
returns_col = Ra,
weights = wts,
col_rename = "Ra")
portfolio_returns_monthly## # A tibble: 72 × 2
## date Ra
## <date> <dbl>
## 1 2010-01-29 0.0307
## 2 2010-02-26 0.0629
## 3 2010-03-31 0.130
## 4 2010-04-30 0.239
## 5 2010-05-28 0.0682
## 6 2010-06-30 -0.0219
## 7 2010-07-30 -0.0272
## 8 2010-08-31 0.116
## 9 2010-09-30 0.251
## 10 2010-10-29 0.0674
## # … with 62 more rowsWe now have an aggregated portfolio that is a 50/50 blend of AAPL and NFLX.
You may be asking why didn’t we use GOOG? The important thing to understand is that all of the assets from the asset returns don’t need to be used when creating the portfolio! This enables us to scale individual stock returns and then vary weights to optimize the portfolio (this will be a further subject that we address in the future!)
Method 2: Aggregating a Portfolio using Two Column Tibble with Symbols and Weights
A possibly more useful method of aggregating returns is using a tibble of symbols and weights that are mapped to the portfolio. We’ll recreate the previous portfolio example using mapped weights.
wts_map <- tibble(
symbols = c("AAPL", "NFLX"),
weights = c(0.5, 0.5)
)
wts_map## # A tibble: 2 × 2
## symbols weights
## <chr> <dbl>
## 1 AAPL 0.5
## 2 NFLX 0.5Next, supply this two column tibble, with symbols in the first column
and weights in the second, to the weights argument in
tq_performance().
stock_returns_monthly %>%
tq_portfolio(assets_col = symbol,
returns_col = Ra,
weights = wts_map,
col_rename = "Ra_using_wts_map")## # A tibble: 72 × 2
## date Ra_using_wts_map
## <date> <dbl>
## 1 2010-01-29 0.0307
## 2 2010-02-26 0.0629
## 3 2010-03-31 0.130
## 4 2010-04-30 0.239
## 5 2010-05-28 0.0682
## 6 2010-06-30 -0.0219
## 7 2010-07-30 -0.0272
## 8 2010-08-31 0.116
## 9 2010-09-30 0.251
## 10 2010-10-29 0.0674
## # … with 62 more rowsThe aggregated returns are exactly the same. The advantage with this method is that not all symbols need to be specified. Any symbol not specified by default gets a weight of zero.
Now, imagine if you had an entire index, such as the Russell 2000, of 2000 individual stock returns in a nice tidy data frame. It would be very easy to adjust portfolios and compute blended returns, and you only need to supply the symbols that you want to blend. All other symbols default to zero!
Step 3B: Merging Ra and Rb
Now that we have the aggregated portfolio returns (“Ra”) from Step 3A and the baseline returns (“Rb”) from Step 2B, we can merge to get our consolidated table of asset and baseline returns. Nothing new here.
RaRb_single_portfolio <- left_join(portfolio_returns_monthly,
baseline_returns_monthly,
by = "date")
RaRb_single_portfolio## # A tibble: 72 × 3
## date Ra Rb
## <date> <dbl> <dbl>
## 1 2010-01-29 0.0307 -0.0993
## 2 2010-02-26 0.0629 0.0348
## 3 2010-03-31 0.130 0.0684
## 4 2010-04-30 0.239 0.0126
## 5 2010-05-28 0.0682 -0.0748
## 6 2010-06-30 -0.0219 -0.0540
## 7 2010-07-30 -0.0272 0.0745
## 8 2010-08-31 0.116 -0.0561
## 9 2010-09-30 0.251 0.117
## 10 2010-10-29 0.0674 0.0578
## # … with 62 more rowsStep 4: Computing the CAPM Table
The CAPM table is computed with the function table.CAPM
from PerformanceAnalytics. We just perform the same task
that we performed in the “Quick Example”.
RaRb_single_portfolio %>%
tq_performance(Ra = Ra, Rb = Rb, performance_fun = table.CAPM)## # A tibble: 1 × 12
## ActiveP…¹ Alpha Annua…² Beta `Beta+` `Beta-` Corre…³ Corre…⁴ Infor…⁵ R-squ…⁶
## <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 0.327 0.0299 0.425 0.754 0.503 -0.243 0.283 0.0162 0.858 0.0799
## # … with 2 more variables: TrackingError <dbl>, TreynorRatio <dbl>, and
## # abbreviated variable names ¹ActivePremium, ²AnnualizedAlpha, ³Correlation,
## # ⁴`Correlationp-value`, ⁵InformationRatio, ⁶`R-squared`Now we have the CAPM performance metrics for a portfolio! While this is cool, it’s cooler to do multiple portfolios. Let’s see how.
Multiple Portfolios
Once you understand the process for a single portfolio using Step 3A, Method 2 (aggregating weights by mapping), scaling to multiple portfolios is just building on this concept. Let’s recreate the same example from the “Single Portfolio” Example this time with three portfolios:
- 50% AAPL, 25% GOOG, 25% NFLX
- 25% AAPL, 50% GOOG, 25% NFLX
- 25% AAPL, 25% GOOG, 50% NFLX
Steps 1 and 2 are the Exact Same as the Single Portfolio Example
First, get individual asset returns grouped by asset, which is the exact same as Steps 1A and 1B from the Single Portfolio example.
stock_returns_monthly <- c("AAPL", "GOOG", "NFLX") %>%
tq_get(get = "stock.prices",
from = "2010-01-01",
to = "2015-12-31") %>%
group_by(symbol) %>%
tq_transmute(select = adjusted,
mutate_fun = periodReturn,
period = "monthly",
col_rename = "Ra")Second, get baseline asset returns, which is the exact same as Steps 1B and 2B from the Single Portfolio example.
baseline_returns_monthly <- "XLK" %>%
tq_get(get = "stock.prices",
from = "2010-01-01",
to = "2015-12-31") %>%
tq_transmute(select = adjusted,
mutate_fun = periodReturn,
period = "monthly",
col_rename = "Rb")Step 3A: Aggregate Portfolio Returns for Multiple Portfolios
This is where it gets fun. If you picked up on Single Portfolio, Step3A, Method 2 (mapping weights), this is just an extension for multiple portfolios.
First, we need to grow our portfolios. tidyquant has a
handy, albeit simple, function, tq_repeat_df(), for scaling
a single portfolio to many. It takes a data frame, and the number of
repeats, n, and the index_col_name, which adds
a sequential index. Let’s see how it works for our example. We need
three portfolios:
stock_returns_monthly_multi <- stock_returns_monthly %>%
tq_repeat_df(n = 3)
stock_returns_monthly_multi## # A tibble: 648 × 4
## # Groups: portfolio [3]
## portfolio symbol date Ra
## <int> <chr> <date> <dbl>
## 1 1 AAPL 2010-01-29 -0.103
## 2 1 AAPL 2010-02-26 0.0654
## 3 1 AAPL 2010-03-31 0.148
## 4 1 AAPL 2010-04-30 0.111
## 5 1 AAPL 2010-05-28 -0.0161
## 6 1 AAPL 2010-06-30 -0.0208
## 7 1 AAPL 2010-07-30 0.0227
## 8 1 AAPL 2010-08-31 -0.0550
## 9 1 AAPL 2010-09-30 0.167
## 10 1 AAPL 2010-10-29 0.0607
## # … with 638 more rowsExamining the results, we can see that a few things happened:
- The length (number of rows) has tripled. This is the essence of
tq_repeat_df: it grows the data frame length-wise, repeating the data framentimes. In our case,n = 3. - Our data frame, which was grouped by symbol, was ungrouped. This is
needed to prevent
tq_portfoliofrom blending on the individual stocks.tq_portfolioonly works on groups of stocks. - We have a new column, named “portfolio”. The “portfolio” column name
is a key that tells
tq_portfoliothat multiple groups exist to analyze. Just note that for multiple portfolio analysis, the “portfolio” column name is required. - We have three groups of portfolios. This is what
tq_portfoliowill split, apply (aggregate), then combine on.
Now the tricky part: We need a new table of weights to map on. There’s a few requirements:
- We must supply a three column tibble with the following columns: “portfolio”, asset, and weight in that order.
- The “portfolio” column must be named “portfolio” since this is a key name for mapping.
- The tibble must be grouped by the portfolio column.
Here’s what the weights table should look like for our example:
weights <- c(
0.50, 0.25, 0.25,
0.25, 0.50, 0.25,
0.25, 0.25, 0.50
)
stocks <- c("AAPL", "GOOG", "NFLX")
weights_table <- tibble(stocks) %>%
tq_repeat_df(n = 3) %>%
bind_cols(tibble(weights)) %>%
group_by(portfolio)
weights_table## # A tibble: 9 × 3
## # Groups: portfolio [3]
## portfolio stocks weights
## <int> <chr> <dbl>
## 1 1 AAPL 0.5
## 2 1 GOOG 0.25
## 3 1 NFLX 0.25
## 4 2 AAPL 0.25
## 5 2 GOOG 0.5
## 6 2 NFLX 0.25
## 7 3 AAPL 0.25
## 8 3 GOOG 0.25
## 9 3 NFLX 0.5Now just pass the the expanded
stock_returns_monthly_multi and the
weights_table to tq_portfolio for portfolio
aggregation.
portfolio_returns_monthly_multi <- stock_returns_monthly_multi %>%
tq_portfolio(assets_col = symbol,
returns_col = Ra,
weights = weights_table,
col_rename = "Ra")
portfolio_returns_monthly_multi## # A tibble: 216 × 3
## # Groups: portfolio [3]
## portfolio date Ra
## <int> <date> <dbl>
## 1 1 2010-01-29 -0.0489
## 2 1 2010-02-26 0.0482
## 3 1 2010-03-31 0.123
## 4 1 2010-04-30 0.145
## 5 1 2010-05-28 0.0245
## 6 1 2010-06-30 -0.0308
## 7 1 2010-07-30 0.000600
## 8 1 2010-08-31 0.0474
## 9 1 2010-09-30 0.222
## 10 1 2010-10-29 0.0789
## # … with 206 more rowsLet’s assess the output. We now have a single, “long” format data
frame of portfolio returns. It has three groups with the aggregated
portfolios blended by mapping the weight_table.
Steps 3B and 4: Merging and Assessing Performance
These steps are the exact same as the Single Portfolio example.
First, we merge with the baseline using “date” as the key.
RaRb_multiple_portfolio <- left_join(portfolio_returns_monthly_multi,
baseline_returns_monthly,
by = "date")
RaRb_multiple_portfolio## # A tibble: 216 × 4
## # Groups: portfolio [3]
## portfolio date Ra Rb
## <int> <date> <dbl> <dbl>
## 1 1 2010-01-29 -0.0489 -0.0993
## 2 1 2010-02-26 0.0482 0.0348
## 3 1 2010-03-31 0.123 0.0684
## 4 1 2010-04-30 0.145 0.0126
## 5 1 2010-05-28 0.0245 -0.0748
## 6 1 2010-06-30 -0.0308 -0.0540
## 7 1 2010-07-30 0.000600 0.0745
## 8 1 2010-08-31 0.0474 -0.0561
## 9 1 2010-09-30 0.222 0.117
## 10 1 2010-10-29 0.0789 0.0578
## # … with 206 more rowsFinally, we calculate the performance of each of the portfolios using
tq_performance. Make sure the data frame is grouped on
“portfolio”.
RaRb_multiple_portfolio %>%
tq_performance(Ra = Ra, Rb = Rb, performance_fun = table.CAPM)## # A tibble: 3 × 13
## # Groups: portfolio [3]
## portfolio Activ…¹ Alpha Annua…² Beta `Beta+` `Beta-` Corre…³ Corre…⁴ Infor…⁵
## <int> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 1 0.231 0.0193 0.258 0.908 0.741 0.312 0.472 0 0.917
## 2 2 0.219 0.0192 0.256 0.886 0.660 0.436 0.438 0.0001 0.809
## 3 3 0.319 0.0308 0.439 0.721 0.394 -0.179 0.252 0.0325 0.774
## # … with 3 more variables: `R-squared` <dbl>, TrackingError <dbl>,
## # TreynorRatio <dbl>, and abbreviated variable names ¹ActivePremium,
## # ²AnnualizedAlpha, ³Correlation, ⁴`Correlationp-value`, ⁵InformationRatioInspecting the results, we now have a multiple portfolio comparison
of the CAPM table from PerformanceAnalytics. We can do the
same thing with SharpeRatio as well.
RaRb_multiple_portfolio %>%
tq_performance(Ra = Ra, Rb = NULL, performance_fun = SharpeRatio)## # A tibble: 3 × 4
## # Groups: portfolio [3]
## portfolio `ESSharpe(Rf=0%,p=95%)` `StdDevSharpe(Rf=0%,p=95%)` VaRSharpe(Rf=0…¹
## <int> <dbl> <dbl> <dbl>
## 1 1 0.172 0.355 0.263
## 2 2 0.146 0.334 0.236
## 3 3 0.150 0.317 0.238
## # … with abbreviated variable name ¹`VaRSharpe(Rf=0%,p=95%)`
