Site icon R-bloggers

Quantitative Trading Strategy Using R: A Step by Step Guide

[This article was first published on R programming, and kindly contributed to R-bloggers]. (You can report issue about the content on this page here)
Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.
< !-- Simple Share Buttons Adder (6.2.2) simplesharebuttons.com -->

In this post we will discuss about building a trading strategy using R. Before dwelling into the trading jargons using R let us spend some time understanding what R is. R is an open source. There are more than 4000 add on packages,18000 plus members of LinkedIn’s group and close to 80 R Meetup groups currently in existence. It is a perfect tool for statistical analysis especially for data analysis. The concise setup of Comprehensive R Archive Network knows as CRAN provides you the list of packages along with the base installation required. There are lot of packages available depending upon the analysis needs to be done. To implement the trading strategy, we will use the package called quantstrat.

Four Step Process of Any Basic Trading Strategy

  1. Hypothesis formation
  2. Testing
  3. Refining
  4. Production

Our hypothesis is formulated as “market is mean reverting”. Mean reversion is a theory that suggests that the prices eventually move back to their average value. The second step involves testing the hypothesis for which we formulate a strategy on our hypothesis and compute indicators, signals and performance metrics. The testing phase can be broken down into three steps, getting the data, writing the strategy and analyzing the output. In this example we consider NIFTY-Bees. It is an exchange traded fund managed by Goldman Sachs. NSE has huge volume for the instrument hence we consider this. The image below shows the Open-High-Low-Close price of the same.

We set a threshold level to compare the fluctuations in the price. If the price increases/decreases we update the threshold column. The closing price is compared with the upper band and with the lower band. When the upper band is crossed, it is a signal for sell. Similarly when the lower band is crossed, it is a signal for sell.

The coding section can be summarized as follows,

A helicopter view towards the output of the strategy is given in the diagram below.

Thus our hypothesis that market is mean reverting is supported. Since this is back-testing we have room for refining the trading parameters that would improve our average returns and the profits realized. This can be done by setting different threshold levels, more strict entry rules, stop loss etc. One could choose more data for back-testing, use Bayseian approach for threshold set up, take volatility into account.

Once you are confident about the trading strategy backed by the back-testing results you could step into live trading. Production environment is a big topic in itself and it’s out of scope in the article’s context. To explain in brief this would involve writing the strategy on a trading platform.

As mentioned earlier, we would be building the model using quantstrat package. Quantstrat provides a generic infrastructure to model and backtest signal-based quantitative strategies. It is a high-level abstraction layer (built on xts, FinancialInstrument, blotter, etc.) that allows you to build and test strategies in very few lines of code.

The key features of quantstrat are,

In this post we build a strategy that includes indicators, signals, and rules.

For a generic signal based model following are the objects one should consider,

Without much ado let’s discuss the coding part. We prefer R studio for coding and insist you use the same. You need to have certain packages installed before programming the strategy.

The following set of commands installs the necessary packages.

install.packages("quantstrat", repos="http://R-Forge.R-project.org")
install.packages("blotter", repos="http://R-Forge.R-project.org")
install.packages("FinancialInstrument", repos="http://R-Forge.R-project.org")

Once you have installed the packages you import them for further usage.

require(quantstrat)

Read the data from csv file and convert it into xts object.

ym_xts &lt;- as.xts(read.zoo("Path//Data.csv",sep = "," , header=TRUE,format = "%m/%d/%Y %H:%M", tz=""))
NSEI&lt;-ym_xts

We initialize the portfolio with the stock, currency, initial equity and the strategy type.

stock.str='NSEI' # stock we trying it on
currency('INR')
stock(stock.str,currency='INR',multiplier=1)
initEq=1000
initDate = index(NSEI[1])#should always be before/start of data
#Declare mandatory names to be used
portfolio.st='MeanRev'
account.st='MeanRev'
initPortf(portfolio.st,symbols=stock.str, initDate=initDate)
initAcct(account.st,portfolios='MeanRev', initDate=initDate)
initOrders(portfolio=portfolio.st,initDate=initDate)

Add position limit if you wish to trade more than once on the same side.

addPosLimit(portfolio.st, stock.str, initDate, 1, 1 )

Create the strategy object.

stratMR &lt;- strategy("MeanRev", store = TRUE)

We build a function that computes the thresholds are which we want to trade. If price moves by thresh1 we update threshold to new price. New bands for trading are Threshold+/-Thresh2. Output is an xts object though we use reclass function to ensure.

THTFunc&lt;-function(CompTh=NSEI,Thresh=6, Thresh2=3){
numRow&lt;- nrow(CompTh)
xa&lt;-coredata(CompTh)[,4]
xb&lt;-xa
tht&lt;-xa[1]
for(i in 2:numRow){
   if(xa[i]&gt;(tht+Thresh)){ tht&lt;-xa[i]}
   if(xa[i]&lt;(tht-Thresh)){ tht&lt;-xa[i]}
   xb[i]&lt;-tht
}
up &lt;- xb + Thresh2
dn&lt;- xb-Thresh2
res &lt;- cbind(xb, dn,up)
colnames(res) &lt;- c("THT", "DOWN", "UP")
reclass(res,CompTh)
}

Add the indicator, signal and the trading rule.

stratMR &lt;- add.indicator(strategy = stratMR, name = "THTFunc", arguments = list(CompTh=quote(mktdata), Thresh=0.5, Thresh2=0.3), label='THTT')
stratMR&lt;-add.signal(stratMR,name="sigCrossover",arguments= list(columns=c("Close","UP"),relationship="gt"),label="Cl.gt.UpperBand")
stratMR&lt;-add.signal(stratMR,name="sigCrossover",arguments= list(columns=c("Close","DOWN"),relationship="lt"),label="Cl.lt.LowerBand")
stratMR &lt;- add.rule(stratMR,name='ruleSignal', arguments = list(sigcol="Cl.gt.UpperBand",sigval=TRUE, prefer = 'close', orderqty=-1, ordertype='market', orderside=NULL, threshold=NULL,osFUN=osMaxPos),type='enter')
stratMR &lt;- add.rule(stratMR,name='ruleSignal', arguments = list(sigcol="Cl.lt.LowerBand",sigval=TRUE, prefer = 'close', orderqty= 1, ordertype='market', orderside=NULL, threshold=NULL,osFUN=osMaxPos),type='enter')
start_t&lt;-Sys.time()

Run the strategy and have a look at the order book.

out&lt;-try(applyStrategy(strategy=stratMR , portfolios='MeanRev') )
# look at the order book
getOrderBook('MeanRev')
end_t&lt;-Sys.time()

Update the portfolio and view the trade statistics

updatePortf('MeanRev', stock.str)
chart.Posn(Portfolio='MeanRev',Symbol=stock.str)
tradeStats('MeanRev', stock.str)
View(t(tradeStats('MeanRev')))
.Th2 = c(.3,.4)
.Th1 = c(.5,.6)
require(foreach)
require(doParallel)
registerDoParallel(cores=2)
stratMR&lt;-add.distribution(stratMR,paramset.label='THTFunc',component.type= 'indicator',component.label = 'THTT',
                         variable = list(Thresh = .Th1),label = 'THTT1')
stratMR&lt;-add.distribution(stratMR,paramset.label='THTFunc',component.type= 'indicator',component.label = 'THTT',
                         variable = list(Thresh2 = .Th2),label = 'THTT2')
results&lt;-apply.paramset(stratMR, paramset.label='THTFunc', portfolio.st=portfolio.st, account.st=account.st, nsamples=4, verbose=TRUE)
stats &lt;- results$tradeStats
View(t(stats))

Here is the complete code

require(quantstrat)
ym_xts &lt;- as.xts(read.zoo("~/webinar//N1.csv",sep = "," , header=TRUE,format = "%m/%d/%Y %H:%M", tz=""))
NSEI&lt;-ym_xts
colnames(NSEI)&lt;-c("Open","High","Low","Close")
stock.str='NSEI' # stock we trying it on
currency('INR')
stock(stock.str,currency='INR',multiplier=1)
initEq=1000
initDate = index(NSEI[1])#should always be before/start of data
portfolio.st='MeanRev'
account.st='MeanRev'
initPortf(portfolio.st,symbols=stock.str, initDate=initDate)
initAcct(account.st,portfolios='MeanRev', initDate=initDate)
initOrders(portfolio=portfolio.st,initDate=initDate)
addPosLimit(portfolio.st, stock.str, initDate, 1, 1 ) #set max pos
stratMR &lt;- strategy("MeanRev", store = TRUE)
THTFunc&lt;-function(CompTh=NSEI,Thresh=6, Thresh2=3){
numRow&lt;- nrow(CompTh)
xa&lt;-coredata(CompTh)[,4]
xb&lt;-xa
tht&lt;-xa[1]
for(i in 2:numRow){
   if(xa[i]&gt;(tht+Thresh)){ tht&lt;-xa[i]}
   if(xa[i]&lt;(tht-Thresh)){ tht&lt;-xa[i]}
   xb[i]&lt;-tht
}
up &lt;- xb + Thresh2
dn&lt;- xb-Thresh2
res &lt;- cbind(xb, dn,up)
colnames(res) &lt;- c("THT", "DOWN", "UP")
reclass(res,CompTh)
}
stratMR &lt;- add.indicator(strategy = stratMR, name = "THTFunc", arguments = list(CompTh=quote(mktdata), Thresh=0.5, Thresh2=0.3), label='THTT')
stratMR &lt;- add.signal(stratMR,name="sigCrossover",arguments = list(columns=c("Close","UP"),relationship="gt"),label="Cl.gt.UpperBand")
stratMR &lt;- add.signal(stratMR,name="sigCrossover",arguments = list(columns=c("Close","DOWN"),relationship="lt"),label="Cl.lt.LowerBand")
stratMR &lt;- add.rule(stratMR,name='ruleSignal', arguments = list(sigcol="Cl.gt.UpperBand",sigval=TRUE, prefer = 'close', orderqty=-1, ordertype='market', orderside=NULL, threshold=NULL,osFUN=osMaxPos),type='enter')
stratMR &lt;- add.rule(stratMR,name='ruleSignal', arguments = list(sigcol="Cl.lt.LowerBand",sigval=TRUE, prefer = 'close', orderqty= 1, ordertype='market', orderside=NULL, threshold=NULL,osFUN=osMaxPos),type='enter')
start_t&lt;-Sys.time()
out&lt;-try(applyStrategy(strategy=stratMR , portfolios='MeanRev') )
getOrderBook('MeanRev')
end_t&lt;-Sys.time()
updatePortf('MeanRev', stock.str)
chart.Posn(Portfolio='MeanRev',Symbol=stock.str)
tradeStats('MeanRev', stock.str)
View(t(tradeStats('MeanRev')))
.Th2 = c(.3,.4)
.Th1 = c(.5,.6)
require(foreach)
require(doParallel)
registerDoParallel(cores=2)
stratMR&lt;-add.distribution(stratMR,paramset.label='THTFunc',component.type = 'indicator',component.label = 'THTT', variable = list(Thresh = .Th1),label = 'THTT1')
stratMR&lt;-add.distribution(stratMR,paramset.label='THTFunc',component.type='indicator',component.label = 'THTT', variable = list(Thresh2 = .Th2),label = 'THTT2')
results &lt;- apply.paramset(stratMR, paramset.label='THTFunc', portfolio.st=portfolio.st, account.st=account.st, nsamples=4, verbose=TRUE)
stats &lt;- results$tradeStats
View(t(stats))

Next Step

Once you are familiar with these basics you could take a look at how to start using quantimod package in R. Or in case you’re good at C++, take a look at an example strategy coded in C++.

If you’re a retail trader or a tech professional looking to start your own automated trading desk, start learning algo trading today! Begin with basic concepts like automated trading architecture, market microstructure, strategy backtesting system and order management system.

< !-- Simple Share Buttons Adder (6.2.2) simplesharebuttons.com -->

The post Quantitative Trading Strategy Using R: A Step by Step Guide appeared first on .

To leave a comment for the author, please follow the link and comment on their blog: R programming.

R-bloggers.com offers daily e-mail updates about R news and tutorials about learning R and many other topics. Click here if you're looking to post or find an R/data-science job.
Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.