This tutorial will teach you about how to use R for portfolio analysis. We will be using various financial packages from R that will help us perform portfolio analysis.

This tutorial will teach you about how to use R for portfolio analysis. We will be using various financial packages from R that will help us perform portfolio analysis. Let’s look at these packages:



Quantmod



<a href="https://financetrain.com/introduction-to-quantmod-in-r/">Quantmod </a>is a very powerful package that is designed for quant traders to explore and build <a href="https://financetrain.com/introduction-to-quantitative-trading/">quantitative trading</a> models. For our work related to portfolio analysis, it will primarily be used to download relevant stock data, although it has further functionality for advanced techniques. It comes with both the xts and zoo packages, both of which are excellent programmes for manipulating time series data. The quantmod package can be used for three important things: 1) downloading data, 2) creating charts and 3) technical indicators and other functions.



PortfolioAnalytics



The second package that is used is PortfolioAnalytics. This package is designed especially to optimise portfolios according to specific criteria, for example, Markowitz <a href="https://financetrain.com/mean-variance-analysis-assumptions/">mean-variance</a> portfolio optimisation. Using the PortfolioAnalytics package, you can get solutions and visualizations for portfolio problems with complex objectives and constraints. It allows you to specify a portfolio with assets, constraints and objectives that are solver agnostic. It supports various objective types such as: return, risk, risk budget, and weight concentration. It has solid functions for optimization problems. It can also be used for creating charts such as risk budgets and efficient frontier.&nbsp;



PerformanceAnalytics



The PortfolioAnalytics package also comes with the PerformanceAnalytics package, which is useful for calculating portfolio returns. It is used for performance and risk analysis of financial instruments or portfolios. It includes various functions to calculate various metrics such as Conditional <a href="https://financetrain.com/value-at-risk-var/">Value at Risk</a> (CVAR), Standard Deviation, Expected Tail Loss (ETL), and Expected Shortfall (ES).&nbsp;



DerivMkts



Finally, DerivMkts is used for the valuation of options and is specifically used in this tutorial to calculate implied volatility for portfolio optimisation. The package contains a set of pricing and expository functions that are useful in teaching financial derivatives.



Note that this is not an exhaustive list. There are many financial packages, however, for the purpose of portfolio analysis we will be using these packages.&nbsp;

R Financial Packages for Portfolio Analysis

We will use QuantMod R package to download stock data. This allows for downloading stock data from multiple sources, although Yahoo is the default option.



To start using the Quantmod library, you can install and load it in your R environment using the following commands in R console or R Studio (Preferred).



<pre class="wp-block-code"><code>install.packages('quantmod') 
library(quantmod) </code></pre>



Once the package is installed, you would use the getSymbols function to download the data. Below is an example that gets the daily history of AAPL from 2016/12/31 to 2018/12/31.



<pre class="wp-block-code"><code>getSymbols("AAPL",
 from = "2016/12/31",
 to = "2018/12/31",
 periodicity = "daily")
## 'getSymbols' currently uses auto.assign=TRUE by default, but will
## use auto.assign=FALSE in 0.5-0. You will still be able to use
## 'loadSymbols' to automatically load data. getOption("getSymbols.env")
## and getOption("getSymbols.auto.assign") will still be checked for
## alternate defaults.
## 
## &#91;1] "AAPL"
</code></pre>



The data will be loaded in the AAPL variable. You can preview the first few rows of the data using the <code>head()</code> function.&nbsp;



<pre class="wp-block-code"><code>head(AAPL)

## AAPL.Open AAPL.High AAPL.Low AAPL.Close AAPL.Volume
## 2017-01-03 115.80 116.33 114.76 116.15 28781900
## 2017-01-04 115.85 116.51 115.75 116.02 21118100
## 2017-01-05 115.92 116.86 115.81 116.61 22193600
## 2017-01-06 116.78 118.16 116.47 117.91 31751900
## 2017-01-09 117.95 119.43 117.94 118.99 33561900
## 2017-01-10 118.77 119.38 118.30 119.11 24462100
## AAPL.Adjusted
## 2017-01-03 111.2870
## 2017-01-04 111.1624
## 2017-01-05 111.7277
## 2017-01-06 112.9733
## 2017-01-09 114.0081
## 2017-01-10 114.1230
</code></pre>



You might notice that one does not need to save it as a variable. getSymbols, by default, will save the ticker history as a variable with the ticker name. If you want to disable this function, you would set auto.assign to FALSE. The variable is also saved as an xts object, which is useful as it allows for easy time-manipulation.



<pre class="wp-block-code"><code>AAPL &lt;- getSymbols("AAPL",
 from = "2016/12/31",
 to = "2018/12/31",
 periodicity = "daily",
 auto.assign = FALSE)
head(AAPL)
## AAPL.Open AAPL.High AAPL.Low AAPL.Close AAPL.Volume
## 2017-01-03 115.80 116.33 114.76 116.15 28781900
## 2017-01-04 115.85 116.51 115.75 116.02 21118100
## 2017-01-05 115.92 116.86 115.81 116.61 22193600
## 2017-01-06 116.78 118.16 116.47 117.91 31751900
## 2017-01-09 117.95 119.43 117.94 118.99 33561900
## 2017-01-10 118.77 119.38 118.30 119.11 24462100
## AAPL.Adjusted
## 2017-01-03 111.2870
## 2017-01-04 111.1624
## 2017-01-05 111.7277
## 2017-01-06 112.9733
## 2017-01-09 114.0081
## 2017-01-10 114.1230
</code></pre>



You may also want to get more than one variable. To do this, you would need to use lapply in combination with getSymbols. Here is how you would get the data for AAPL and GOOG.



<pre class="wp-block-code"><code>myStocks &lt;-lapply(c("AAPL", "GOOG"), function(x) {getSymbols(x, 
 from = "2016/12/31", 
 to = "2018/12/31",
 periodicity = "daily",
 auto.assign=FALSE)} )
names(myStocks) &lt;- c("AAPL", "GOOG")
head(myStocks$AAPL)
## AAPL.Open AAPL.High AAPL.Low AAPL.Close AAPL.Volume
## 2017-01-03 115.80 116.33 114.76 116.15 28781900
## 2017-01-04 115.85 116.51 115.75 116.02 21118100
## 2017-01-05 115.92 116.86 115.81 116.61 22193600
## 2017-01-06 116.78 118.16 116.47 117.91 31751900
## 2017-01-09 117.95 119.43 117.94 118.99 33561900
## 2017-01-10 118.77 119.38 118.30 119.11 24462100
## AAPL.Adjusted
## 2017-01-03 111.2870
## 2017-01-04 111.1624
## 2017-01-05 111.7277
## 2017-01-06 112.9733
## 2017-01-09 114.0081
## 2017-01-10 114.1230
head(myStocks$GOOG)
## GOOG.Open GOOG.High GOOG.Low GOOG.Close GOOG.Volume
## 2017-01-03 778.81 789.630 775.800 786.14 1657300
## 2017-01-04 788.36 791.340 783.160 786.90 1073000
## 2017-01-05 786.08 794.480 785.020 794.02 1335200
## 2017-01-06 795.26 807.900 792.204 806.15 1640200
## 2017-01-09 806.40 809.966 802.830 806.65 1274600
## 2017-01-10 807.86 809.130 803.510 804.79 1176800
## GOOG.Adjusted
## 2017-01-03 786.14
## 2017-01-04 786.90
## 2017-01-05 794.02
## 2017-01-06 806.15
## 2017-01-09 806.65
## 2017-01-10 804.79
</code></pre>



Finally, you may only want a particular column of data. As this tutorial will focus on portfolio optimisation, the adjusted price, which takes into account corporate actions will be the focus here. To get an object with only the adjusted values of AAPL and GOOG, you would need to add this code after the above.



<pre class="wp-block-code"><code>adjustedPrices &lt;- lapply(myStocks, Ad)
adjustedPrices &lt;- do.call(merge, adjustedPrices)
head(adjustedPrices)
## AAPL.Adjusted GOOG.Adjusted
## 2017-01-03 111.2870 786.14
## 2017-01-04 111.1624 786.90
## 2017-01-05 111.7277 794.02
## 2017-01-06 112.9733 806.15
## 2017-01-09 114.0081 806.65
## 2017-01-10 114.1230 804.79
</code></pre>

Downloading Stock Data in R Using QuantMod

To calculate the returns of AAPL &amp; GOOG over the time period, you can use the <code>Return.calculate</code> function.



<pre class="wp-block-code"><code>stockReturns &lt;- Return.calculate(adjustedPrices)
head(stockReturns)
## AAPL.Adjusted GOOG.Adjusted
## 2017-01-03 NA NA
## 2017-01-04 -0.001119178 0.0009667604
## 2017-01-05 0.005085153 0.0090481583
## 2017-01-06 0.011148442 0.0152766979
## 2017-01-09 0.009159465 0.0006202319
## 2017-01-10 0.001008411 -0.0023058897
</code></pre>



This will then calculate the daily returns of AAPL and GOOG over the time period. The first day, as there is nothing to divide it by, will be NA. It generally makes sense to use this code instead to diverge from that problem.



<pre class="wp-block-code"><code>stockReturns &lt;- Return.calculate(adjustedPrices)&#91;-1]
head(stockReturns)
## AAPL.Adjusted GOOG.Adjusted
## 2017-01-04 -0.001119178 0.0009667604
## 2017-01-05 0.005085153 0.0090481583
## 2017-01-06 0.011148442 0.0152766979
## 2017-01-09 0.009159465 0.0006202319
## 2017-01-10 0.001008411 -0.0023058897
## 2017-01-11 0.005373393 0.0038767816
</code></pre>



If one wants to calculate the <a href="https://financetrain.com/how-to-calculate-portfolio-returns/">returns of a portfolio</a>, one can use the <code>Return.portfolio</code> function with the returns of the stocks as one argument and the weights of the stocks as another. For this example, it will be an equal weight between AAPL and GOOG.



<pre class="wp-block-code"><code>portReturns &lt;- Return.portfolio(stockReturns, c(0.5, 0.5))
head(portReturns)
## portfolio.returns
## 2017-01-04 -7.620906e-05
## 2017-01-05 7.068722e-03
## 2017-01-06 1.321878e-02
## 2017-01-09 4.868296e-03
## 2017-01-10 -6.500634e-04
## 2017-01-11 4.625730e-03
</code></pre>



This does not rebalance the portfolio. To do this, just add the <code>rebalance_on</code> argument. In this case, it is going to be done monthly.



<pre class="wp-block-code"><code>portReturnsRebalanced &lt;- Return.portfolio(stockReturns, c(0.5, 0.5), rebalance_on = "months")
head(portReturnsRebalanced)
## portfolio.returns
## 2017-01-04 -7.620906e-05
## 2017-01-05 7.068722e-03
## 2017-01-06 1.321878e-02
## 2017-01-09 4.868296e-03
## 2017-01-10 -6.500634e-04
## 2017-01-11 4.625730e-03
</code></pre>



You can also get an annual table of performance using the <code>table.AnnualizedReturns</code> function. The arguments are an xts object of portfolio returns (can be multiple) and the risk-free rate, used to calculate the <a href="https://financetrain.com/sharpe-ratio/">Sharpe ratio</a>. In this example, the non-rebalanced portfolio will be compared to the monthly rebalanced portfolio.



<pre class="wp-block-code"><code>allPortReturns &lt;- cbind(portReturns, portReturnsRebalanced)
colnames(allPortReturns) &lt;- c("Non-Rebalanced", "Monthly Rebalanced")
table.AnnualizedReturns(allPortReturns, Rf = 0.1/252)
## Non-Rebalanced Monthly Rebalanced
## Annualized Return 0.1647 0.1769
## Annualized Std Dev 0.2114 0.2104
## Annualized Sharpe (Rf=10%) 0.2549 0.3085
</code></pre>

Calculating Stock Returns and Portfolio Returns in R

This is a brief recap of Modern Portfolio Theory (MPT) before delving into practical applications of it. While there are many aspects of MPT, the focus will be on its application for portfolio optimisation. The origin of MPT came from a paper written by Harry Markowitz in 1952 to create an optimal portfolio. From thereon, he continued to expand on this theory until, eventually, it became known as MPT and occur in the aspects that are now common knowledge.



The first aspect relating to MPT is that, by increasing one’s number of assets in a portfolio, one can reduce the risk of the overall portfolio. This is because assets are, generally speaking, not perfectly correlated. As such, through diversification, one can remove the level of stock-specific risk. Mathematically, this is represented by the variance equation of a portfolio:



<div class="wp-block-image"><figure class="aligncenter size-large"><img src="https://financetrain.com/wp-content/uploads/variance-equation.png" alt="" class="wp-image-26574"/></figure></div>



Where σ is the standard deviation of the asset, w is the weight of the asset and ρ is the correlation between 2 assets. As long as ρ is not equal to 1, the addition of a new asset will reduce the portfolio risk until it equals only the market risk.



The expected return of the portfolio is calculated as follows:



<div class="wp-block-image"><figure class="aligncenter size-large"><img src="https://financetrain.com/wp-content/uploads/portfolio-return.png" alt="" class="wp-image-26575"/></figure></div>



We can now plot the expected return and expected variance of a whole combination of portfolios. Below is an example of this:



<div class="wp-block-image"><figure class="aligncenter size-large"><img src="https://financetrain.com/wp-content/uploads/2010/06/Efficient-Frontier.gif" alt="" class="wp-image-195"/></figure></div>



The individual dots represent potential combinations of assets that make up a hypothetical portfolio. The better portfolio is always considered the one to the top-right, as it has less risk and a greater expected return. The portfolios that are considered best for each level of risk (i.e. highest expected return per unit of risk) form the solid line known as the efficient frontier. These are the optimal portfolios that an investor can choose from. The specific choice of the portfolio depends on the return profile and risk appetite of the investor.



From this relationship, there are two generally used portfolio optimisations. These are minimum-variance and mean-variance optimisation. In minimum variance, the portfolio that is selected is the one that has the lowest risk. For a highly risk-averse investor, this would be an optimal portfolio. In mean-variance optimisation, the optimal portfolio is the portfolio with the highest ratio between expected return and risk. It is often termed as the greatest risk-adjusted portfolio.

Modern Portfolio Theory

For this tutorial, both minimum-variance and mean-variance will be taught. The PortfolioAnalytics package will be used extensively throughout as it allows for a simple workflow for portfolio optimisations. The first part of the code is to define that a portfolio optimisation problem exists. The only variable that needs to be defined is the names of the components of the portfolio. It will then print out a summary of the portfolio defined so far.



<pre class="wp-block-code"><code>port &lt;- portfolio.spec(assets = colnames((stockReturns)))
port
## **************************************************
## PortfolioAnalytics Portfolio Specification 
## **************************************************
## 
## Call:
## portfolio.spec(assets = colnames((stockReturns)))
## 
## Number of assets: 2 
## Asset Names
## &#91;1] "AAPL.Adjusted" "GOOG.Adjusted"
</code></pre>



Next, you’d want to add some constraints to the portfolio. Popular ones would be full_investment, meaning that the sum of the assets must equal 100%, weight_sum, which constrains the total weight of the portfolio to a specific percentage, box, which allows for a minimum and maximum weight for individual assets, and long_only, where assets weights can only be positive. In this example, full_weights, long_only and box will be used. When you print a summary of the port object, it will now show the constraints.



<pre class="wp-block-code"><code>port &lt;- add.constraint(portfolio = port,
 type = "full_investment")
port &lt;- add.constraint(portfolio = port,
 type = "long_only")
port &lt;- add.constraint(portfolio = port,
 type = "box",
 min = 0.0,
 max = 0.7)
port
## **************************************************
## PortfolioAnalytics Portfolio Specification 
## **************************************************
## 
## Call:
## portfolio.spec(assets = colnames((stockReturns)))
## 
## Number of assets: 2 
## Asset Names
## &#91;1] "AAPL.Adjusted" "GOOG.Adjusted"
## 
## Constraints
## Enabled constraint types
## - full_investment 
## - long_only 
## - box
</code></pre>



Finally, you’ll want to add the objective metric to optimise. To do this, add.objective is used. To maximise the objective, one specifies the type argument to “return”; to minimise the objective, one specifies the type argument to “risk”. The first example will be for a minimum variance portfolio, so the type will be risk and the metric (argument name) that we are looking to minimise is the standard deviation. To reduce code, the portfolio port will be duplicated for portMinVar.



<pre class="wp-block-code"><code>portMinVar &lt;- port
portMinVar &lt;- add.objective(portfolio = portMinVar,
 type = "risk",
 name = "StdDev")
portMinVar
## **************************************************
## PortfolioAnalytics Portfolio Specification 
## **************************************************
## 
## Call:
## portfolio.spec(assets = colnames((stockReturns)))
## 
## Number of assets: 2 
## Asset Names
## &#91;1] "AAPL.Adjusted" "GOOG.Adjusted"
## 
## Constraints
## Enabled constraint types
## - full_investment 
## - long_only 
## - box 
## 
## Objectives:
## Enabled objective names
## - StdDev
</code></pre>



Now the objective has been added. To do it for mean-variance, there would be 2 objectives: maximise returns (mean sample returns) whilst minimising standard deviation. Below is the example code:



<pre class="wp-block-code"><code>portMeanVar &lt;- port
portMeanVar &lt;- add.objective(portfolio = portMeanVar,
 type = "risk",
 name = "StdDev")
portMeanVar &lt;- add.objective(portfolio = portMeanVar,
 type = "return",
 name = "mean")
portMeanVar
## **************************************************
## PortfolioAnalytics Portfolio Specification 
## **************************************************
## 
## Call:
## portfolio.spec(assets = colnames((stockReturns)))
## 
## Number of assets: 2 
## Asset Names
## &#91;1] "AAPL.Adjusted" "GOOG.Adjusted"
## 
## Constraints
## Enabled constraint types
## - full_investment 
## - long_only 
## - box 
## 
## Objectives:
## Enabled objective names
## - StdDev 
## - mean
</code></pre>



You will notice that there are now two objectives. Finally, the portfolios are going to be optimised and the returns compared. The arguments are the portfolio specified, the returns of each asset and the optimisation method. Generally, random works best as it is a global optimisation problem. One can then extract the weights and create portfolio returns using the Return.portfolio function.



<pre class="wp-block-code"><code>set.seed(10260)
minVarOpt &lt;- optimize.portfolio(R = stockReturns,
 portfolio = portMinVar,
 optimize_method = "random")
## Leverage constraint min_sum and max_sum are restrictive, 
## consider relaxing. e.g. 'full_investment' constraint should be min_sum=0.99 and max_sum=1.01
## Warning: executing %dopar% sequentially: no parallel backend registered
extractWeights(minVarOpt)
## AAPL.Adjusted GOOG.Adjusted 
## 0.43 0.57
minVarReturns &lt;- Return.portfolio(stockReturns, weight = extractWeights(minVarOpt), rebalance_on = "months")
table.AnnualizedReturns(R = minVarReturns, Rf = 0.1/250)
## portfolio.returns
## Annualized Return 0.1745
## Annualized Std Dev 0.2100
## Annualized Sharpe (Rf=10.08%) 0.2951
</code></pre>



Let’s repeat for mean-variance optimisation and compare performance.



<pre class="wp-block-code"><code>set.seed(10260)
meanVarOpt &lt;- optimize.portfolio(R = stockReturns,
 portfolio = portMeanVar,
 optimize_method = "random")
## Leverage constraint min_sum and max_sum are restrictive, 
## consider relaxing. e.g. 'full_investment' constraint should be min_sum=0.99 and max_sum=1.01
extractWeights(meanVarOpt)
## AAPL.Adjusted GOOG.Adjusted 
## 0.44 0.56
meanVarReturns &lt;- Return.portfolio(stockReturns, weight = extractWeights(meanVarOpt), rebalance_on = "months")
optimisedPortfolioReturns &lt;- cbind(minVarReturns, meanVarReturns)
colnames(optimisedPortfolioReturns) &lt;- c("Minimum Variance", "Mean Variance")
table.AnnualizedReturns(R = optimisedPortfolioReturns, Rf = 0.1/252)
## Minimum Variance Mean Variance
## Annualized Return 0.1745 0.1749
## Annualized Std Dev 0.2100 0.2100
## Annualized Sharpe (Rf=10%) 0.2991 0.3007
</code></pre>

Portfolio Optimisation in R

Portfolio Analysis in R

This frontmatter description will appear below the title

COURSE

Portfolio Analysis in R

Lessons

R Programming Bundle: 25% OFF