+
+ Hundreds of academic papers implemented as LEAN trading strategies
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/01 API Tutorials/00 Introduction/00 Introduction.html b/01 API Tutorials/00 Introduction/00 Introduction.html
new file mode 100644
index 0000000..7f208e0
--- /dev/null
+++ b/01 API Tutorials/00 Introduction/00 Introduction.html
@@ -0,0 +1,37 @@
+
+API tutorials seek to give you an introduction to building an algorithm using the QuantConnect API.
+
+
\ No newline at end of file
diff --git a/API Tutorials/Tutorial01 Consolidating Data to Build Bars.html b/01 API Tutorials/01 Consolidating Data to Build Bars/01 Consolidating Data to Build Bars.html
old mode 100644
new mode 100755
similarity index 75%
rename from API Tutorials/Tutorial01 Consolidating Data to Build Bars.html
rename to 01 API Tutorials/01 Consolidating Data to Build Bars/01 Consolidating Data to Build Bars.html
index 5d1de5b..65121c5
--- a/API Tutorials/Tutorial01 Consolidating Data to Build Bars.html
+++ b/01 API Tutorials/01 Consolidating Data to Build Bars/01 Consolidating Data to Build Bars.html
@@ -1,13 +1,14 @@
+
Consolidators are used to combine data together from finer resolutions into larger ones. This can be useful for indicators with specific data requirements or to perform long term analysis in conjunction with short term signals.
-
-Consolidators should be constructed and setup in your Initialize() method; this ensures they are only initialized once. There are three key steps to create and register a consolidator:
-
+ Consolidators should be constructed and setup in your Initialize() method; this ensures they are only initialized once. There are three key steps to create and register a consolidator:
+
+
Create the consolidator object.
Bind an event handler to handle the new bars.
Register it with the subscription manager to start receiving data.
-
-In C# this looks like:
-
public class ConsolidatorDemoAlgorithm : QCAlgorithm
+
+
+
public class ConsolidatorDemoAlgorithm : QCAlgorithm
{
public override void Initialize()
{
@@ -39,8 +40,7 @@
public override void OnData(Slice data)
{ }
}
-The LEAN API also has other consolidator types to handle working with Ticks and RenkoBars.
-
-In C# this looks like:
-
// From tick data sources
+
+
+
+ The LEAN API also has other consolidator types to handle working with Ticks and RenkoBars.
+
+
+
// From tick data sources
var tickConsolidator = new TickConsolidator(TimeSpan.FromMinutes(30));
//from renko bars
var renkoConsolidator = new RenkoConsolidator(TimeSpan.FromMinutes(30));
-
-There are two key points to remember:
-
+
+
+
+
+ There are two key points to remember:
+
+
Request a smaller resolution than what you want to produce.
In backtesting we only know the bar is ready on the next data point; so it may appear like daily bars are triggered at odd times. In live trading, they are scanned to be triggered every second at a minimum.
-
-
The raw data of QuantConnect is provided in Tick, Minute, Second, Hour or Daily bars. Using these building blocks you can combine data together to get any other resolution of data required.
+ The raw data of QuantConnect is provided in Tick, Minute, Second, Hour or Daily bars. Using these building blocks you can combine data together to get any other resolution of data required.
+
+
diff --git a/API Tutorials/Tutorial04 Scheduled Events.html b/01 API Tutorials/02 Scheduled Events/02 Scheduled Events.html
old mode 100644
new mode 100755
similarity index 66%
rename from API Tutorials/Tutorial04 Scheduled Events.html
rename to 01 API Tutorials/02 Scheduled Events/02 Scheduled Events.html
index 9237c12..eac686e
--- a/API Tutorials/Tutorial04 Scheduled Events.html
+++ b/01 API Tutorials/02 Scheduled Events/02 Scheduled Events.html
@@ -1,16 +1,21 @@
+
Scheduled events allow you to trigger code blocks for execution at specific times according to rules you set. This feature helps coordinate your algorithm activities and perform analysis at regular intervals; while letting the trading engine take care of market holidays.
-
-The scheduling is set with two rules: the DateRules and TimeRules classes. The schedule manager takes one of each and executes an action code block.
-In C# this looks like:
-
+ The scheduling is set with two rules: the DateRules and TimeRules classes. The schedule manager takes one of each and executes an action code block.
+
-The time rules trigger specify when on the day the event should be triggered. They can be specified as below:
+
+ The time rules trigger specify when on the day the event should be triggered. They can be specified as below:
+
@@ -66,5 +73,7 @@
-For a demonstration see the tutorial video below:
-https://youtu.be/SUu4MKlm93I
+
+ For a demonstration see the tutorial video below:
+
+
diff --git a/01 API Tutorials/03 Tracking and Managing Orders/01 Overview.html b/01 API Tutorials/03 Tracking and Managing Orders/01 Overview.html
new file mode 100755
index 0000000..9c9b242
--- /dev/null
+++ b/01 API Tutorials/03 Tracking and Managing Orders/01 Overview.html
@@ -0,0 +1,42 @@
+
+ Tracking and managing orders is an important part of an algorithmic trading strategy. Intelligent order management encourages discipline and a deep understanding of your algorithm. Through the QuantConnect API you can get order fields, update their values and cancel pending orders. This can be useful for lowering trading costs and improving order fills.
+ When you place a trade you receive an OrderTicket for you to access the order. This allows you to safely (asynchronously) update and cancel the order while in live trading. In live trading you cannot assume order updates are processed successfully as the brokerage may have already filled the trade.
+
+
+
+ You can place several types of orders including:
+
+
+
+
+
+
Supported Order Types
+
+
+
+
+
Market Order
+
var ticket = MarketOrder("SPY", 100);self.ticket = self.MarketOrder("SPY", 100)
+
+
+
Limit Order
+
var ticket = LimitOrder("SPY", 100, 100.10m);self.ticket = self.LimitOrder("SPY", 100, 100.1)
+
+
+
Stop Market Order
+
var ticket = StopMarketOrder("SPY", 100, 100.10m);self.ticket = self.StopMarketOrder("SPY", 100, 100.1)
# update the order fields (LimitPrice, StopPrice, Tag or Quantity)
+updateOrderFields = UpdateOrderFields()
+updateOrderFields.LimitPrice = newLongLimit
+_ticket.Update(updateOrderFields)
+
+
+
+ You can also cancel your order if required:
+
+
+
_ticket.Cancel();
+
ticket.Cancel()
+
+
+ In the video below we demonstrate putting it all together to create a moving take-profit order which gradually decreases its profit
+ target as time passes.
+
+
diff --git a/01 API Tutorials/03 Tracking and Managing Orders/03 Full Python Example.html b/01 API Tutorials/03 Tracking and Managing Orders/03 Full Python Example.html
new file mode 100755
index 0000000..e53941f
--- /dev/null
+++ b/01 API Tutorials/03 Tracking and Managing Orders/03 Full Python Example.html
@@ -0,0 +1,78 @@
+
+ This is a complete port from C# to Python of this Quick Start Lesson.
+
+
+
+
+```Lesson 6 - Tracking and Managing Orders:
+Immediately place 4 orders. Plot end of day price of each order in 'Order Tickets' plot. Debug log filled orders.
+```
+import numpy as np
+from decimal import Decimal
+
+class BasicTemplateAlgorithm(QCAlgorithm):
+
+ def Initialize(self):
+ self._limitTicket = None
+ self._stopMarketTicket = None
+ self._stopLimitTicket = None
+ self.SetCash(25000)
+ self.SetStartDate(2009,1,1)
+ self.SetEndDate(2009,6,1)
+ self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol
+
+ def OnData(self, slice):
+ if self._limitTicket is None:
+
+ self.MarketOrder(self.spy, 100)
+
+ self._limitTicket = self.LimitOrder(
+ self.spy,
+ 100,
+ slice["SPY"].Close * Decimal(0.9),
+ "limit order")
+
+ self._stopMarketTicket = self.StopMarketOrder(
+ self.spy,
+ -100,
+ slice["SPY"].Close * Decimal(0.95),
+ "stop market")
+
+ self._stopLimitTicket = self.StopLimitOrder(
+ self.spy,
+ -100,
+ slice["SPY"].Close * Decimal(0.9),
+ slice["SPY"].Close * Decimal(0.8),
+ "stop limit")
+
+
+ def OnEndOfDay(self):
+ ```End of each day, plot our asset & order prices```
+ if self._limitTicket is None:
+ return
+
+ self.Plot("Order Tickets", "SPY", self.Portfolio['SPY'].Price)
+
+ if self._stopMarketTicket.Status != OrderStatus.Filled:
+ self.Plot("Order Tickets", "Stop Price",
+ self._stopMarketTicket.Get(OrderField.StopPrice))
+
+ if self._stopLimitTicket.Status != OrderStatus.Filled:
+ self.Plot("Order Tickets", "Limit Price",
+ self._stopLimitTicket.Get(OrderField.LimitPrice))
+
+ def OnOrderEvent(self, OrderEvent):
+ ```Event when the order is filled. Debug log the order fill. :OrderEvent:```
+
+ if OrderEvent.FillQuantity == 0:
+ return
+
+ fetched = self.Transactions.GetOrderById(OrderEvent.OrderId)
+
+ self.Debug("{} was filled. Symbol: {}. Quantity: {}. Direction: {}"
+ .format(str(fetched.Type),
+ str(OrderEvent.Symbol),
+ str(OrderEvent.FillQuantity),
+ str(OrderEvent.Direction)))
+
+
diff --git a/01 API Tutorials/04 Using Options in QuantConnect/01 Introduction.html b/01 API Tutorials/04 Using Options in QuantConnect/01 Introduction.html
new file mode 100755
index 0000000..fd8f150
--- /dev/null
+++ b/01 API Tutorials/04 Using Options in QuantConnect/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ QuantConnect provides US options trade and quotes price data for approximately 4000 symbols, each of which has roughly 10 strikes on average. Data is available starting January 1st, 2008. In this tutorial, we will discuss how to use QuantConnect to start your options trading algorithm.
+
diff --git a/01 API Tutorials/04 Using Options in QuantConnect/02 Add Options.html b/01 API Tutorials/04 Using Options in QuantConnect/02 Add Options.html
new file mode 100755
index 0000000..0ab569f
--- /dev/null
+++ b/01 API Tutorials/04 Using Options in QuantConnect/02 Add Options.html
@@ -0,0 +1,35 @@
+
+ Before trading options, you need to add options for a given underlying equity and set the resolution in step Initialize with AddOption method. The commonly used parameters will be explained in the method table. Please refer to the link below for details of each method.
+
underlying(string): The underlying equity symbol
+resolution: Tick, Second, Minute, Hour, or Daily. Default is minute
+fillDataForward(bool): If true, returns the last available data even if none in that time slice. The default value is true.
+
+
+
+
+
+
def Initialize(self):
+ self.SetStartDate(2017, 01, 01) #Set Start Date
+ self.SetEndDate(2017, 06, 30) #Set End Date
+ self.SetCash(50000) #Set Strategy Cash
+ equity = self.AddEquity("GOOG", Resolution.Daily) # Add the underlying stock: Google
+ option = self.AddOption("GOOG", Resolution.Daily) # Add the option corresponding to underlying stock
+ self.symbol = option.Symbol
+
+
+
+ The return value of AddOption method is an option security object , please refer to the link for detailed properties and methods of option class.
+
diff --git a/01 API Tutorials/04 Using Options in QuantConnect/03 Filter Contracts.html b/01 API Tutorials/04 Using Options in QuantConnect/03 Filter Contracts.html
new file mode 100755
index 0000000..02b6927
--- /dev/null
+++ b/01 API Tutorials/04 Using Options in QuantConnect/03 Filter Contracts.html
@@ -0,0 +1,43 @@
+
+ After adding the options for specific underlying stock, you can set the filter criteria with SetFilter method to pull contracts using the specified min and max strike and expiration range values you need for a given symbol.
+
min Strike, max Strike: The min and max strike rank relative to market price
+min Expiry, max Expiry: The range of time to expiration to include, for example, TimeSpan.FromDays(10) would exclude contracts expiring in less than 10 days
+
+
+
+
+ Here parameters min Strike and max Strike are the relative values with respect to the market price. We use Google(NASDAQ: GOOG) as an example to describe the filter criteria. If today is 01/03/2017, the market price of underlying stock is $776, the strike prices of GOOG options are spaced $2.5. Then SetFilter(-1, +2, timedelta(0), timedelta(90)) will fist look up at the money contracts with strike being K=$777.5 (Here K might not being $100 since rarely will option be ATM exactly). Then filter will looks for options with strikes between and including (777.5 + 2.5*2, 777.5 - 2.5*1). The time to expiration of these options are restricted within 90 days from now on.
+
+
+ For the strike, the exchange normally chooses the strike prices at which options can be written so that they are spaced $2.50, $5, or $10 apart. Typically the spacing is $2.50 when the stock price is between $5 and $25, $5 when the stock price is between $25 and $200, and $10 for stock prices above $200. So you should carefully choose the parameters of min strike and max Strike in case there is no contracts satisfy the filter criteria if the range is too small, less than the minimum units of strike prices change.
+
+
+ For the expiry, there are many expiration dates that apply to the different series of options. An option cycle is the pattern of months in which options contracts expire. There are three kinds of common option cycles. The options on the January cycle have contracts available in the first month of each quarter (January, April, July and October). Options assigned to the February cycle use the middle month of each quarter (February, May, August and November). And options in the March cycle have options available during the last month of each quarter (March, June, September and December). In addition, individual stock options typically expire in the current month and the subsequent month.
+
+
+
+
+
# filter the contracts with strikes between (market price - 10, market price + 10)
+option.SetFilter(-10,10)
+# filter the contracts which expires more than 30 days but no longer than 60 days
+option.SetFilter(TimeSpan.FromDays(30),TimeSpan.FromDays(60))
+# filter the contracts with strikes between(ATM Strike - 10 * strike space value, market price + 10 * strike space value) and with expiration days less than 180 days
+option.SetFilter(-10, +10, timedelta(0), timedelta(180))
+
+
diff --git a/01 API Tutorials/04 Using Options in QuantConnect/04 Select Contracts.html b/01 API Tutorials/04 Using Options in QuantConnect/04 Select Contracts.html
new file mode 100755
index 0000000..99d89ed
--- /dev/null
+++ b/01 API Tutorials/04 Using Options in QuantConnect/04 Select Contracts.html
@@ -0,0 +1,191 @@
+
+ For QuantConnect API, Slice class provides a data structure for all of an algorithm's data at a single time step. So you need to use the property Slice.OptionChains to request options data for this slice.
+
+OptionChains is a collection of OptionChain keyed by the option's underlying symbol. The elements in Slice.OptionChains have properties Key(the underlying symbol object) and Value(the option chain).
+
+OptionChain represents an entire chain of option contracts for a single underlying security. In other words, it is a list of option contracts.
+
+OptionContract defines a single option contract at a specific expiration and strike price. For any contract x in the option chain, you can use the following statements to check different options properties.
+
+
+
+
+
+
Properties of Option Contract x
+
+
+
+
+
x.Symbol.Value
+
Get the string of option contract's symbol
+
+
+
x.AskPrice, x.BidPrice
+
Get the ask price, Get the bid price
+
+
+
x.Expiry
+
Get the expiration date
+
+
+
x.Strike
+
Get the strike price
+
+
+
x.ImpliedVolatility
+
Get the implied volatility
+
+
+
x.Greeks
+
Get the Greeks letter
+
+
+
x.Right
+
Get the right being purchased
+x.Right ＝ 1 call option[right to buy]
+x.Right ＝ 0 put option[right to sell]
+
+
+
x.UnderlyingLastPrice
+
Get the last price the underlying security traded at
+
+
+
x.UnderlyingSymbol
+
Gets the underlying security's symbol
+
+
+
+
+
+ We can print out the details of the contract after filtering with Python data frame to show these properties. Assume today is 01/03/2017. The stock price at 01/03/2017 09:31:00 is $776.01 per share. Here we use SetFilter(-1, +1, timedelta(0), timedelta(60)) to filter the contracts.
+
+
+
+
+
def OnData(self,slice):
+ for kvp in slice.OptionChains:
+ if kvp.Key != self.symbol:
+ continue
+ optionchain = kvp.Value
+ df = pd.DataFrame([[x.Right,float(x.Strike),x.Expiry,float(x.BidPrice),float(x.AskPrice)] for x in optionchain],
+ index=[x.Symbol.Value for x in optionchain],
+ columns=['type(call 0, put 1)', 'strike', 'expiry', 'ask price', 'bid price'])
+ self.Log(f"Underlying price: {optionchain.Underlying.Price}\n{df}")
+
+
+
+
+
+
Symbol
+
type(call 0, put 1)
+
Strike
+
Expiry
+
Ask Price
+
Bid Price
+
+
+
+
+
GOOG 170217C00780000
+
0
+
780.0
+
2017-02-17
+
26.4
+
27.9
+
+
+
GOOG 170120P00782500
+
1
+
782.5
+
2017-01-20
+
14.7
+
16.3
+
+
+
GOOG 170120C00782500
+
0
+
782.5
+
2017-01-20
+
9.4
+
10.2
+
+
+
GOOG 170120P00780000
+
1
+
780.0
+
2017-01-20
+
13.4
+
15.0
+
+
+
GOOG 170120C00780000
+
0
+
780.0
+
2017-01-20
+
10.6
+
11.5
+
+
+
GOOG 170217P00780000
+
1
+
780.0
+
2017-02-17
+
28.9
+
30.8
+
+
+
GOOG 170120P00777500
+
1
+
777.5
+
2017-01-20
+
12.2
+
13.7
+
+
+
GOOG 170120C00777500
+
0
+
777.5
+
2017-01-20
+
11.8
+
12.9
+
+
+
+
+
+ Here we give an example of how to find ATM, ITM and OTM contracts for trading. First, we need to extract the OptionChain from OptionChains according to symbols we added in Initialize step. Secondly, we extract ATM, ITM and OTM contracts by using UnderlyingLastPrice and Strike properties. Note here the strikes of ATM options are not exactly the same as the market price of underlying stocks, thus here we first sort the contracts by the absolute values of the difference between the UnderlyingLastPrice and the Strike. Then we choose the contract with the minimum absolute value as the ATM contract.
+
+
+
+
+
for kvp in slice.OptionChains:
+ if kvp.Key != self.symbol:
+ continue
+ optionchain = kvp.Value
+ # differentiate the call and put options
+ call = [x for x in optionchain if x.Right == OptionRight.Call]
+ put = [x for x in optionchain if x.Right == OptionRight.Put]
+ price = optionchain.Underlying.Price
+ # choose ITM contracts
+ contracts = [x for x in call if price - x.Strike > 0]
+ # or choose ATM contracts
+ contracts = [x for x in call if price - x.Strike == 0]
+ # or choose OTM contracts
+ contracts = [x for x in call if price - x.Strike < 0]
+ # sort the contracts by their expiration dates
+ contracts = sorted(contracts, key = lambda x: x.Expiry, reverse = True)
+
+
+
+ Finally, we trade the options by using the contract's symbol.
+
+
+
+
+
if len(contracts) == 0: continue
+# trade the contracts with the farthest expiration
+symbol = contracts[0].Symbol
+self.MarketOrder(symbol, 1)
+self.MarketOnCloseOrder(symbol, -1)
+
+
diff --git a/01 API Tutorials/04 Using Options in QuantConnect/05 Algorithm.html b/01 API Tutorials/04 Using Options in QuantConnect/05 Algorithm.html
new file mode 100755
index 0000000..cf59940
--- /dev/null
+++ b/01 API Tutorials/04 Using Options in QuantConnect/05 Algorithm.html
@@ -0,0 +1,10 @@
+
+ This simple example demonstrates how you can inspect the option chain to pick a specific option contract to trade.
+
+
+
+
+
+
+
+
diff --git a/01 API Tutorials/04 Using Options in QuantConnect/06 Summary.html b/01 API Tutorials/04 Using Options in QuantConnect/06 Summary.html
new file mode 100755
index 0000000..da313e2
--- /dev/null
+++ b/01 API Tutorials/04 Using Options in QuantConnect/06 Summary.html
@@ -0,0 +1,3 @@
+
+ After mastering the basic knowledge of options market, this tutorial we take a close at how to use Quantconnect to customize your own options trading. For example, how you can access an option chain, how to view the details of the contract as a Python data frame, and the most important how to trade the specific option contract.
+
+QuantConnect maintains collections of related tutorials we call a Tutorial Series. We have tutorial series covering the topic below - each with a set of 8-10 child tutorials beneath them.
+
\ No newline at end of file
diff --git a/02 Tutorial Series/01 Introduction to Financial Python/00 About.html b/02 Tutorial Series/01 Introduction to Financial Python/00 About.html
new file mode 100644
index 0000000..8fec69d
--- /dev/null
+++ b/02 Tutorial Series/01 Introduction to Financial Python/00 About.html
@@ -0,0 +1,21 @@
+
This tutorial series introduces basic Python applied to financial concepts. If you have great investment ideas but don't know how to write them, or if you think you need to learn some basic skills in quantitative finance, then this is a good starting point. The series is broken into four parts: python, math and statistics, basic financial concepts related to investment and financial time series analysis.
+
+
We not only introduce the concepts but also show you how to apply the introduced techniques step by step using Python code snippets. We use real financial datasets as examples and after each chapter we design a QuantConnect algorithm applying what we learned.
+
+
+
+
+
+
14 Tutorials
+
+
+
+
+
8 Backtests
+
+
+
+
+
167 Code Snippets
+
+
diff --git a/02 Tutorial Series/01 Introduction to Financial Python/01 What Will I learn %3F.html b/02 Tutorial Series/01 Introduction to Financial Python/01 What Will I learn %3F.html
new file mode 100644
index 0000000..7593f3e
--- /dev/null
+++ b/02 Tutorial Series/01 Introduction to Financial Python/01 What Will I learn %3F.html
@@ -0,0 +1,7 @@
+
+
Python
+
Statistics
+
Linear Algebra
+
Modern Portfolio Theory
+
Multi-factor Models
+
diff --git a/02 Tutorial Series/01 Introduction to Financial Python/02 Tutorials.html b/02 Tutorial Series/01 Introduction to Financial Python/02 Tutorials.html
new file mode 100644
index 0000000..9ddd2e6
--- /dev/null
+++ b/02 Tutorial Series/01 Introduction to Financial Python/02 Tutorials.html
@@ -0,0 +1,88 @@
+
+The most popular asset pricing model since 1992.
+ Read Tutorial
+
+
+
diff --git a/02 Tutorial Series/02 Introduction to Options/00 About.html b/02 Tutorial Series/02 Introduction to Options/00 About.html
new file mode 100644
index 0000000..43c78d3
--- /dev/null
+++ b/02 Tutorial Series/02 Introduction to Options/00 About.html
@@ -0,0 +1,20 @@
+
The goal of this series is to introduce options to those who are option novices and have basic knowledge of applied mathematics, statistics and financial markets. We will primarily talk about the fundamentals of options and cover topics such as what are options, key terms and concepts option traders need to be familiar with(exercise and assignment, The moneyness, Intrinsic and time value of options etc.) After knowing the basics of options, we will teach how to use QuantConnect API to conduct your options research with over 4000 underlying stock symbols.
+
The following few options tutorials were created to help you understand exactly how options are used as the investment and risk hedging tools. We will further discuss the pricing method of options like BSM model and Monte Carlo method. And then several metrics to gauge the options risks like the Greek letters, different kinds of volatilities used in options pricing and trading. At the end of some tutorials, we will apply the knowledge in that tutorial to demonstrate some simple algorithms developed with Python on Quantconnect attempting to help you gain an insight into options trading and learn more efficient API tools to better customize your own trading algorithms.
+
+
+
+
+
+
8 Tutorials
+
+
+
+
+
3 Backtests
+
+
+
+
+
65 Code Snippets
+
+
diff --git a/02 Tutorial Series/02 Introduction to Options/01 What Will I learn %3F.html b/02 Tutorial Series/02 Introduction to Options/01 What Will I learn %3F.html
new file mode 100644
index 0000000..f05701e
--- /dev/null
+++ b/02 Tutorial Series/02 Introduction to Options/01 What Will I learn %3F.html
@@ -0,0 +1,10 @@
+
+
General Features of Options
+
QuantConnect Options API
+
Options Pricing: Black-Scholes-Merton Model
+
Stochastic Process
+
Monte Carlo Method
+
The Greek Letters
+
Historical Volatility and Implied Volatility
+
Local Volatility and Stochastic Volatility
+
diff --git a/02 Tutorial Series/02 Introduction to Options/02 Tutorials.html b/02 Tutorial Series/02 Introduction to Options/02 Tutorials.html
new file mode 100644
index 0000000..3ebc133
--- /dev/null
+++ b/02 Tutorial Series/02 Introduction to Options/02 Tutorials.html
@@ -0,0 +1,83 @@
+
+
+
+
1
+
+
General Features of Options
+ Options Contracts
+ The Value of Options
+ Option Moneyness
+ Option Exercise and Assignment
+ Read Tutorial
+
+
+
2
+
+
QuantConnect Option API
+ Option Data Access
+ Option Contracts filtration
+ Properties of Contracts
+ Order Placement
+ Read Tutorial
+ The goal of this series is to introduce the common options strategies to those who already have basic knowledge of
+ options markets and most importantly, we will teach users how to start your simple options trading algorithm on
+ QuantConnect. These strategies will demonstrate a few of the ways in which options can be used to produce an
+ interesting relationship between profit and stock price. We will primarily talk about the strategies like the
+ Covered Call which involves a single option and the undelying stock, the spreads which involve either taking a
+ position in two or more calls or puts, the conbinations like straddle or strangle which involve taking a position in
+ both calls and puts on the same stocks. For each strategy, except for the description of strategy itself, we will
+ demonstrate the QuantConnect algorithm implemented in Python.
+
+
+
+
+
8 Tutorials
+
+
+
+
10 Backtests
+
+
+
+
45 Code Snippets
+
+
+
diff --git a/02 Tutorial Series/03 Applied Options/01 What Will I learn %3F.html b/02 Tutorial Series/03 Applied Options/01 What Will I learn %3F.html
new file mode 100644
index 0000000..661425d
--- /dev/null
+++ b/02 Tutorial Series/03 Applied Options/01 What Will I learn %3F.html
@@ -0,0 +1,6 @@
+
+
Common Options Strategies
+
Using Options API
+
Payoff Analysis
+
Risk Profile of Options Trading
+
\ No newline at end of file
diff --git a/02 Tutorial Series/03 Applied Options/02 Tutorials.html b/02 Tutorial Series/03 Applied Options/02 Tutorials.html
new file mode 100644
index 0000000..e78c382
--- /dev/null
+++ b/02 Tutorial Series/03 Applied Options/02 Tutorials.html
@@ -0,0 +1,60 @@
+
+
+
+
1
+
+
Covered Call
+ A brief introduction to Covered Call Strategy and the algorithm implemented in python.
+ Read Tutorial
+
+
+
2
+
+
Bull Call Spread
+ A brief introduction to Bull Call Spread strategy and the algorithm implemented in python.
+ Read Tutorial
+
+
+
3
+
+
Long Straddle
+ A brief introduction to Long Straddle strategy and the algorithm implemented in python.
+ Read Tutorial
+
+
+
4
+
+
Long Strangle
+ A brief introduction to Long Strangle strategy and the algorithm implemented in python.
+ Read Tutorial
+
+
+
5
+
+
Butterfly Spread
+ A brief introduction to Butterfly Spread strategy and the algorithm implemented in python.
+ Read Tutorial
+
+
+
6
+
+
Iron Condor
+ A brief introduction to Iron Condor strategy and the algorithm implemented in python.
+ Read Tutorial
+
+
+
7
+
+
Iron Butterfly
+ A brief introduction to Iron Butterfly strategy and the algorithm implemented in python.
+ Read Tutorial
+
+
+
8
+
+
Protective Collar
+ A brief introduction to Protective Collar strategy and the algorithm implemented in python.
+ Read Tutorial
+
+
+
diff --git a/03 Open Source/00 Introduction/Introduction.html b/03 Open Source/00 Introduction/Introduction.html
new file mode 100644
index 0000000..dff5ed2
--- /dev/null
+++ b/03 Open Source/00 Introduction/Introduction.html
@@ -0,0 +1,47 @@
+
+QuantConnect has a large open source community driving innovation in the LEAN Algorithmic Trading Engine. We have collected relevant tutorials here for community members learn from and use with their local installations of LEAN.
+
diff --git a/03 Open Source/01 Debugging Python/00.html b/03 Open Source/01 Debugging Python/00.html
new file mode 100644
index 0000000..c2005ec
--- /dev/null
+++ b/03 Open Source/01 Debugging Python/00.html
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/03 Open Source/01 Debugging Python/01 Introduction.html b/03 Open Source/01 Debugging Python/01 Introduction.html
new file mode 100644
index 0000000..ea57f4a
--- /dev/null
+++ b/03 Open Source/01 Debugging Python/01 Introduction.html
@@ -0,0 +1,7 @@
+
+
+
+ In this tutorial, for those algorithm developers who opt to work offline, we will explore the different methods to debug a python algorithm.
+
\ No newline at end of file
diff --git a/03 Open Source/01 Debugging Python/02 Installing LEAN with Python.html b/03 Open Source/01 Debugging Python/02 Installing LEAN with Python.html
new file mode 100644
index 0000000..ba680ab
--- /dev/null
+++ b/03 Open Source/01 Debugging Python/02 Installing LEAN with Python.html
@@ -0,0 +1,30 @@
+
+The first step is to install LEAN and get it running with python algorithms.
+
Build the solution by clicking Build Menu -> Build Solution.
+
Press F5 to run LEAN.
+
+
+
By default, Lean will run the C# version of BasicTemplateAlgorithm. From here the next step is to run the python version of the BasicTemplateAlgorithm successfully.
Run Lean without debugging by clicking on Debug -> Start Without Debugging
+
Lean will stop and wait for the debugger to attach
+
Set breakpoints
+
In Visual Studio, select Debug -> Attach to Process (or press Ctrl+Alt+P) to open the Attach to Process dialog box.
+
For Connection type, select Default
+
For Attach to, select Python
+
Search for QuantConnect.Lean.Launcher.exe process and attach
+
+
+
+
diff --git a/03 Open Source/01 Debugging Python/06 Limitations.html b/03 Open Source/01 Debugging Python/06 Limitations.html
new file mode 100644
index 0000000..f126eb5
--- /dev/null
+++ b/03 Open Source/01 Debugging Python/06 Limitations.html
@@ -0,0 +1,3 @@
+
Unfortunately, this debugging scenario entails some limitations.
+
It is not possible to concurrently debug the python algorithm and Lean (C# code). That means that the debugger will not stop at breakpoints in Lean nor we can step into methods defined in Lean (e.g., SetHoldings).
+
Method 1 ptvsd will always stop after ptvsd.break_into_debugger() call and it not possible to untoggled it. However, we can use conditional statements to prevent its call and avoid unnecessary breaks. In order to resume the algorithm execution without breakpoints, we need to detach the process (Debug -> Detach All).
diff --git a/03 Open Source/01 Debugging Python/07 Summary.html b/03 Open Source/01 Debugging Python/07 Summary.html
new file mode 100644
index 0000000..88aa936
--- /dev/null
+++ b/03 Open Source/01 Debugging Python/07 Summary.html
@@ -0,0 +1,3 @@
+
+In this tutorial, we have learned how to debug python algorithms in Visual Studio. It is not quite as smooth as native python yet, but knowing how to debug python algorithms in LEAN can give you a new level of understanding of how they work and allow for easier debugging of your strategy.
+
diff --git a/03 Open Source/03 Using the API File Provider/02 How do I use the API File Provider.html b/03 Open Source/03 Using the API File Provider/02 How do I use the API File Provider.html
new file mode 100644
index 0000000..79485b6
--- /dev/null
+++ b/03 Open Source/03 Using the API File Provider/02 How do I use the API File Provider.html
@@ -0,0 +1,10 @@
+
+Ensuring a high data quality is one of the hardest parts of setting reliable backtesting. There are many challenges to ensuring your data is in the right format, free of errors or omissions and historically accurate. We've tried to address this for you by opening the LEAN Data Library and letting you download our data. LEAN data is organized into millions of tiny files which can be difficult to put into place manually, but using the API File Provider we provide a way for you to automatically install this into your LEAN project.
+
Currently we provide forex and cfd data for each of the major vendors we support in tick, second, minute, hour and daily resolution. To request data; go to your data library and specify what you'd like to download.
+
+
Each data file has a unique URL to download the data for the day which will get a LEAN formatted CSV zip. By using the API File Downloader we check if you have the file in your data-folder; and if not we attempt to download it from the API. This assumes you have already added the data to your repository through the web interface.
+
This requires 2 key changes to the config.json file in the QuantConnect.Lean.Launcher Project:
+
Insert your job-user-id and api-access-token into the relevant config fields. You can find these on your Account page.
Update the data-provider configuration to refer to the APIDataProvider class. This is called QuantConnect.Lean.Engine.DataFeeds.ApiDataProvider.
+
+
Check out the video below where we guide you step by step through how to use the API Data Provider.
+
diff --git a/03 Open Source/04 Lean Report Creator/00.html b/03 Open Source/04 Lean Report Creator/00.html
new file mode 100644
index 0000000..02cabcd
--- /dev/null
+++ b/03 Open Source/04 Lean Report Creator/00.html
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/03 Open Source/04 Lean Report Creator/01 Introduction.html b/03 Open Source/04 Lean Report Creator/01 Introduction.html
new file mode 100644
index 0000000..f5f8f98
--- /dev/null
+++ b/03 Open Source/04 Lean Report Creator/01 Introduction.html
@@ -0,0 +1,14 @@
+
+The LEAN Report Creator (LRC) is a report generated from backtesting-result objects and allows you to quickly create polished, professional-grade reports for each backtest (see a full example report generated by LRC). We hope that you can use these reports to share your strategy performance with prospective investors.
+The report was generated using the examples provided in this tutorial.
+
+
+The algorithm used to generate the example report is provided below.
+
+
+
+
+Users working through the QuantConnect.com IDE can have these reports generated automatically at the end of a backtest. To generate one, look at the “Report” tab below your backtest result charts and click "Request Report".
+
+
+
diff --git a/03 Open Source/04 Lean Report Creator/02 Creating a Report.html b/03 Open Source/04 Lean Report Creator/02 Creating a Report.html
new file mode 100644
index 0000000..a2ea27a
--- /dev/null
+++ b/03 Open Source/04 Lean Report Creator/02 Creating a Report.html
@@ -0,0 +1,50 @@
+
+The Lean Report Creator is a project located in the Report folder. It is a command line tool that takes the JSON backtest result object as its input.
+You can run it using command line arguments, or by filling in the config.json file.
+
+The program has a few options you should configure to your requirements:
+
+
+
+
+
+
Command Switch
+
Description
+
+
+
+
+
--backtest-data-source-file
+
Location of the source backtest JSON file.
+
+
--live-data-source-file
+
Location of the source live JSON file.
+
+
+
--report-destination
+
Resulting output HTML file location.
+
+
+
--strategy-name
+
Name of the strategy. This will appear at the top-right corner of each page in the report.
+
+
+
--strategy-version
+
Version number of the strategy. This will appear at the top-right corner next to the strategy name.
+
+
+
--strategy-description
+
Description that describes what the strategy does. This will appear under the "Strategy Description" section of the report.
+
+
+
+
+
+The program injects the images as base64 encoded objects into the HTML file to make it more portable and simpler to share with your partners.
+
\ No newline at end of file
diff --git a/03 Open Source/04 Lean Report Creator/03 Source Backtest.html b/03 Open Source/04 Lean Report Creator/03 Source Backtest.html
new file mode 100644
index 0000000..f7fa836
--- /dev/null
+++ b/03 Open Source/04 Lean Report Creator/03 Source Backtest.html
@@ -0,0 +1,39 @@
+
+The --backtest-data-source-file switch refers to a JSON file created by the LEAN Engine. This holds all of the backtest data which is required for generating the report HTML. This data can be sourced from desktop or cloud backtests.
+
+
+
Desktop Backtesting Results
+
+By default, LEAN saves the backtest result data to disk inside of your LEAN launcher folder: Lean/Launcher/bin/Debug/BasicTemplateAlgorithm.json. You can access it like this from the Report executable:
+
+Backtest processed reports can be downloaded via API. The following example imports the QuantConnect API class and uses it to download the final HTML report. To access the API you will need to know your API User ID and Token, which can be obtained in the Account page.
+
+>>> from quantconnect.api import Api
+>>> from json import dump
+>>> api = Api(your-user-id, your-token)
+>>> data = api.read_backtest(project-id, backtest-id)
+>>> with open("./json/sample.json", 'w+') as fp:
+>>> json.dump(data['result'], fp, ensure_ascii=False)
+
+You can manually download the backtest result file and place the file in the location configured in the config.json file.
+
+
+
+
+You can update your report description by clicking on the Project Description button in your project panel.
+
+
\ No newline at end of file
diff --git a/03 Open Source/04 Lean Report Creator/04 Customizing Report Contents.html b/03 Open Source/04 Lean Report Creator/04 Customizing Report Contents.html
new file mode 100644
index 0000000..7c86acc
--- /dev/null
+++ b/03 Open Source/04 Lean Report Creator/04 Customizing Report Contents.html
@@ -0,0 +1,24 @@
+
+The report can contain a description of the strategy. This is set either in the config.json file or via the command line argument --strategy-description.
+An example config.json configuration is provided below.
+
+
+
{
+ "data-folder": "../../../Data",
+ "strategy-name": "Example Algo (FX + Equity) Strategy",
+ "strategy-version": "v1.2.0",
+ "strategy-description": "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+ "live-data-source-file": "",
+ "backtest-data-source-file": "example_algo_fx.json",
+ "report-destination": "Report.html",
+
+ ...
+}
+
+
+
+
+We recommend that you use the existing config.example.json
+and rename it to config.json once you have finished editing the file. Please rebuild the project on rename or if you make any changes to the configuration
+so that the file is copied into the binary output path.
+
\ No newline at end of file
diff --git a/03 Open Source/04 Lean Report Creator/05 Interpreting Report Charts.html b/03 Open Source/04 Lean Report Creator/05 Interpreting Report Charts.html
new file mode 100644
index 0000000..e7a0510
--- /dev/null
+++ b/03 Open Source/04 Lean Report Creator/05 Interpreting Report Charts.html
@@ -0,0 +1,39 @@
+
Cumulative Return
+
+
+This chart shows the cumulative returns for your strategy in blue for backtesting, orange for live trading, and the benchmark in gray.
+
+
+
Returns per Trade
+
+
+This chart shows a histogram showing the distribution of returns per trade over the algorithm's backtesting or live trading period.
+
+
+
Top 5 Drawdown Periods
+
+
+This chart shows the drawdown of each day. A certain day's drawdown is defined as the percentage of loss compared to the maximum value before this day. The drawdowns are calculated based on daily data. The top 5 drawdown periods are marked in the chart with different colors.
+
+
+
Monthly Returns
+
+
+This chart shows the return of each month. We convert original price series into monthly series and calculate the returns of each month. The green color indicates positive return, the red color indicates negative return, and the greater the loss is, the darker the color is; the yellow color means the gain or loss is rather small; the white color means the month is not included in the backtest period. The values in the cells are in percentage.
+
+
+
Annual Returns
+
+
This chart shows the return of each year. We calculate the total return within each year, shown by the blue bars. The red dotted line represents the average of the annual returns.
+
+
+
Crisis Events
+
+
This group of charts shows the behaviors of both your strategy and the benchmark during a certain historical period. We set the value of your strategy the same as the benchmark at the beginning of each crisis event, and the lines represent the cumulative returns of your strategy and benchmark from the beginning of this crisis event. The report only draws the crisis event charts whose periods are covered by your strategy.
+
+
+
Asset Allocations
+
+
+The asset allocation charts show a time-weighted average of each asset to your portfolio. When a certain asset has a very small percentage and is too small to be shown in the pie chart, it will be incorporated into an "Others" category. The value of the percentage could be either positive or negative.
+
diff --git a/03 Open Source/05 Brokerage Development Guide/00.html b/03 Open Source/05 Brokerage Development Guide/00.html
new file mode 100644
index 0000000..cedc442
--- /dev/null
+++ b/03 Open Source/05 Brokerage Development Guide/00.html
@@ -0,0 +1,43 @@
+
+
+ Updated July 14th, 2018: The Brokerage Development Guide is an active work in progress.
+
\ No newline at end of file
diff --git a/03 Open Source/05 Brokerage Development Guide/01 Introduction.html b/03 Open Source/05 Brokerage Development Guide/01 Introduction.html
new file mode 100644
index 0000000..a239d1d
--- /dev/null
+++ b/03 Open Source/05 Brokerage Development Guide/01 Introduction.html
@@ -0,0 +1,9 @@
+
+Creating a fully supported brokerage is a challenging endeavor. LEAN requires a number of individual pieces which together form a complete brokerage implementation. This guide aims to describe in as much detail as possible what you need to do for each module. There are nine key components to implement - these are described individually in the sections below.
+
+
+
+Each submitted brokerage pull-request must pass all tests before being merged. Partially completed brokerage implementations are acceptable if merged to a branch. It's easy to fall behind master so be sure to keep your branch updated with the master branch. Please make sure to read LEAN's coding style guidelines and comply with the code commenting and design standards.
+
+
+
diff --git a/03 Open Source/05 Brokerage Development Guide/02 Guide Contents.html b/03 Open Source/05 Brokerage Development Guide/02 Guide Contents.html
new file mode 100644
index 0000000..73ae158
--- /dev/null
+++ b/03 Open Source/05 Brokerage Development Guide/02 Guide Contents.html
@@ -0,0 +1,37 @@
+
The root of the brokerage system is the algorithm job packets. These hold configuration information about how to run LEAN. The program logic is a little convoluted; it moves from config.json > create job packet > create brokerage factory matching name > set job packet brokerage data > factory creates brokerage instance. Because of this we'll start creating a brokerage at the root -- the configuration and brokerage factory...
\ No newline at end of file
diff --git a/03 Open Source/05 Brokerage Development Guide/03 Step 1%3A Laying a Foundation.html b/03 Open Source/05 Brokerage Development Guide/03 Step 1%3A Laying a Foundation.html
new file mode 100644
index 0000000..45ce511
--- /dev/null
+++ b/03 Open Source/05 Brokerage Development Guide/03 Step 1%3A Laying a Foundation.html
@@ -0,0 +1,67 @@
+
+The IBrokerageFactory creates brokerage instances with a Job Packet which configures LEAN. It contains the name of the selected brokerage to create, which is used to create the right BrokerageFactory type. The configuration live-mode-brokerage key is used to set the brokerage name.
+
+
+
1.1 Create Authentication Configuration
+
+In the configuration file add a few key-values with your brokerage configuration information. This will be used for most local debugging and testing as the default. E.g. oanda-access-token and oanda-account-id. These will be copied to the job packet which contains a matching field BrokerageData. This is a dictionary of <string,string> pairs.
+
+
+
1.2 Create Brokerage Data
+
+By default the IBrokerageFactory.BrokerageData implementation should load all required configuration from the config file using the Config class. E.g. Config.Get("oanda-access-token"). This can be a simple pass through to the config for most brokerages.
+
+
+
1.3 Create Brokerage Model
+
+Brokerage Models tell LEAN what order types a brokerage supports, whether we're allowed to update an order, and what transaction models to use for fills. It is important to do but something we can come back to later. For now, we should just create a stub implementation which we'll extend and improve later. This file MyBrokerageBrokerageModel.cs lives in the /Common/Brokerages folder. For now, you can make it an empty implementation inheriting from the DefaultBrokerageModel. See this example of a partially implemented model here. Set your empty placeholder model to the BrokerageModel property.
+
+
+
1.4 Create Brokerage Instance in Factory
+
+The Brokerage Factory uses a job packet to create an initialized brokerage instance. This happens in the CreateBrokerage() method. You should assume the job has the best source of data not the class BrokerageData property. The BrokerageData property on the factory are the starting default values sourced from config which can be overridden by a runtime job.
+
+
+
+Given our IBrokerage implementation hasn't been started yet let's make a placeholder file for our brokerage with the methods stubbed out: MyBrokerage.cs in the MyBrokerage folder, in the Brokerages solution. All the methods should throw a new NotImplementedException() for now except for the constructor which should save any required authentication data to private variables. The CreateBrokerage() method should create a brokerage object but not connect to the brokerage. The connection is done later in the LEAN start-up process.
+
+
+
1.5 Create Configuration Environment
+
+In the config file LEAN has helper environments which group configuration flags together and override the root configuration values. You should make a mybrokerage-live environment for your brokerage which specifies the brokerage type name for live-mode-brokerage. You should copy the paper-trading brokerage setup to start. You should set the environmentvalue to your new brokerage environment for testing.
+
+
+
+ Tip:
+
In the IBrokerageFactory examples, you'll see code like this: Composer.Instance.AddPart<IDataQueueHandler>(dataQueueHandler), which is adding parts to the "Composer". The Composer is a system in LEAN for loading types dynamically. In this case, it is adding an instance of the DataQueueHandler for the brokerage to the composer. You can think of the composer as a library, and adding parts is like adding books to its collection. But we'll come back to this later...
+
+
+
+
+
Stage 1: Checklist
+
+
Configuration keys and placeholder values for brokerage authentication requirements.
+
Created folder for brokerage in Brokerages solution; with MyBrokerageFactory.cs.
+
Implemented all interfaces of the BrokerageFactory (some with stub implementations).
+
Create a stub MyBrokerage.cs with Not Implemented exceptions.
+
Create a stub MyBrokerageBrokerageModel.cs inheriting from DefaultBrokerageModel.
+
Created a mybrokerage live configuration environment specifying your class.
+
Set the environment configuration to your new brokerage environment.
+
+
+
+ Action:
+
Build the solution. Although running won't work the stub implementations should still build.
+
\ No newline at end of file
diff --git a/03 Open Source/05 Brokerage Development Guide/04 Step 2%3A Creating the Brokerage.html b/03 Open Source/05 Brokerage Development Guide/04 Step 2%3A Creating the Brokerage.html
new file mode 100644
index 0000000..7cda62c
--- /dev/null
+++ b/03 Open Source/05 Brokerage Development Guide/04 Step 2%3A Creating the Brokerage.html
@@ -0,0 +1,204 @@
+
+The IBrokerage holds the bulk of the core logic responsible for running the brokerage implementation. Many smaller models described later use the Brokerage implementation internally so its best to start implementation of the IBrokerage now. Brokerage classes can get quite large so you should use a partial class modifier to break up the files in appropriate categories. It has many important roles vital for the stability of a running algorithm. These include:
+
+
+
Maintain Connection - Connect and maintain connection while algorithm running.
+
Setup State - Initialize the algorithm portfolio, open orders and cashbook.
+
Order Operations - Create, update and cancel orders.
+
Order Events - Receive order fills and apply them to portfolio.
Brokerage Events - Interpret brokerage messages and act when required.
+
Serve History Requests - Provide historical data on request.
+
+
+Often brokerages will have their own ticker styles, order class names, event names. Many of the methods in the brokerage implementation may simply be converting from the brokerage object format into LEAN format. You should plan accordingly to write neat code.
+
+
+
+The brokerage will eventually implement 3 interfaces:
+
class MyBrokerage : IBrokerage, IDataDownloader, IHistoryProvider { ... }
+
+
+
+Implementation Style. This guide will focus mostly on implementing the brokerage step by step in LEAN; as its a more natural workflow for most people. You can also follow a more test-driven-development process by following the test harness. To do this create a new test class which extends from the base class in /Tests/Brokerages/BrokerageTests.cs. This test-framework tests all the methods for an IBrokerage implementation.
+
+
+
2.1 Brokerage Requirements
+
QuantConnect is best used with streaming or socket based brokerage connections. Streaming brokerage implementations allow for the easiest translation of broker events into LEAN events. Without streaming order-events you will need to poll for to check for fills. In our experience this is fraught with additional risks and challenges.
+
+
2.2 Installing a Library
+
+Most brokerages will provide a wrapper for their API. You should use this where possible as long as it has a permissive license. Although it is technically possible to embed an external github repository we've elected to not do this to make LEAN easier to install (submodules can be tricky for beginners). You should copy the library into its own subfolder of the brokerage implementation: /Brokerages/MyBrokerage/BrokerLib/*.
+
+
+LEAN Open-Source. If you copy and paste code from an external source leave the comments and headers intact, and if they do not have a comment header be sure to add one to each file referencing the source. Let's keep the attributions in place.
+
+
+
+ Tip:
+
Libraries will need to be .NET Framework 4.6.2 compatible as LEAN is fully cross-platform via Mono.
+
+
+
+ Action:
+
Build the project again to make sure the library is compiling successfully. Its good to make sure your library is integrated successfully before continuing.
+
+
+
2.4 IBrokerage Class Implementation
+
+
+ Base Class
+
Using a base class is optional but allows you to reuse event methods we have provided. The Brokerage object implements these event handlers and marks the remaining items as abstract.
+
LEAN provides an optional base class BaseWebsocketsBrokerage which seeks to connect and maintain a socket connection and pass messages to an event handler. As each socket connection is different consider carefully before using this class; it might be easier and more maintainable to simply maintain your own socket connection.
+
+
+ Tip:
+
Brush up on the partial class keyword. This will help you break-up your class later.
+
+
+
+
+ Class Constructor
+
Once the scaffolding brokerage methods are in place (overrides of the abstract base classes); you can focus on the class constructor. Here if you are using a brokerage SDK you can create a new instance of their library, and store it to a class variable for later use. You should make your constructor take all the arguments it needs. This is passed to you from code you implemented in the previous section, the IBrokerageFactory.
Offload constructor work to BrokerageFactory and use BaseWebsocketBrokerage base class.
+
+
+
+
+
+ string Name
+
The Name property is a human readable brokerage name for debugging and logging. For US Equity regulated brokerages convention states this name generally ends in the word "Brokerage".
+
+
+
+ void Connect()
+
The Connect method triggers logic for establishing a link to your brokerage. Normally we do not do this in the constructor as it would make algorithms and brokerages die in the BrokerageFactory process. For most brokerages this will be simply calling the connect method on your SDK library.
Establish websocket connection and monitoring in a thread.
+
+
+
+
Exceptions
+
+In the event of a soft failure like internet connection lost, or server 502 errors you should create a new BrokerageMessageEvent. By doing this you allow the algorithm to handle the brokerage messages. For example: Interactive Brokers resets socket connections at different times globally, so users in other parts of the world can get disconnected at strange times of the day. Knowing this, they may elect to have their algorithm ignore specific disconnection attempts.
+
+
+In the event of a hard-failure such as the password being incorrect or an unsupported API method you should throw a real exception with details of the error. You can see examples of using both of these techniques in the FXCM Connect method.
+
+
+
+
+ void Disconnect()
+
Disconnect is called at the end of the algorithm before shutting down LEAN.
+
+
+
+ bool IsConnected
+
A boolean property to indicate the state of the brokerage connection. Depending on your connection style this may be automatically handled for you and simply require passing back the value from your SDK. Alternatively you may need to maintain your own connection state flag in your brokerage.
+
+
+
+ bool PlaceOrder(Order order)
+
+Send a new LEAN order to the brokerage and report back the success or failure. The PlaceOrder method accepts a generic Order object which is the base class for all order types. The first step of placing an order is often to convert it from LEAN format into the Brokerage SDK required format. Brokerage implementations should aim to support as many LEAN order types as possible. There may be other order types in the brokerage but implementing them is considered out of scope of a rev-0 brokerage implementation.
+
+
+Once the order type is converted you should send it to your brokerage submit API. Often you will receive an immediate reply indicating the order was successfully placed.
+
+
+Part of the order conversion might be converting the brokerage ticker (e.g. LEAN name "EURUSD", OANDA name is "EUR/USD"). This is done with a BrokerageSymbolMapper class. We'll get to that in Step 3, for now you can pass a request for the brokerage ticker to the stub implementation.
+
+
+The PlaceOrder() method returns true when the order is accepted to the brokerage. If it is invalid, immediately rejected or there is an internet outage you can return false.
+
+
+
+ Tip:
+
Create an internal method: BrokerOrder ConvertOrder(Order order) for conversion to brokerage orders. You will use this over and over again. Converting order types is an error prone process and its recommended to carefully review each order after you've completed a port. Remember to check each required brokerage order property, brokers like InteractiveBrokers have hundreds of properties.
+
+
+
+ Tip:
+
Use the IsConnected boolean to check if you're connected before placing the order. If not throw an exception to halt the algorithm.
+
+
+
+
+ bool UpdateOrder(Order order)
+
Transmit an update request to the API and return true if it was successfully processed. There are no simple examples here! Updating an order is one of the most tricky part of the brokerage implementations. You can easily run into synchronization issues.
diff --git a/Tutorial Series/Introduction to Financial Python/images/placeholder.txt b/03 Open Source/05 Brokerage Development Guide/05 Step 3%3A Translating Symbol Conventions.html
similarity index 100%
rename from Tutorial Series/Introduction to Financial Python/images/placeholder.txt
rename to 03 Open Source/05 Brokerage Development Guide/05 Step 3%3A Translating Symbol Conventions.html
diff --git a/Tutorial Series/Introduction to Machine Learning/Tutorial01 Structure and Construction of Neural Networks.html b/03 Open Source/05 Brokerage Development Guide/06 Step 4%3A Describe Brokerage Limitations.html
similarity index 100%
rename from Tutorial Series/Introduction to Machine Learning/Tutorial01 Structure and Construction of Neural Networks.html
rename to 03 Open Source/05 Brokerage Development Guide/06 Step 4%3A Describe Brokerage Limitations.html
diff --git a/Tutorial Series/Introduction to Machine Learning/Tutorial02 Kernel Function and Construction of Support Vector Machines.html b/03 Open Source/05 Brokerage Development Guide/07 Step 5%3A Enable Live Data Streaming.html
similarity index 100%
rename from Tutorial Series/Introduction to Machine Learning/Tutorial02 Kernel Function and Construction of Support Vector Machines.html
rename to 03 Open Source/05 Brokerage Development Guide/07 Step 5%3A Enable Live Data Streaming.html
diff --git a/Tutorial Series/Introduction to Machine Learning/Tutorial03 Bayes' Theorem and Classification of Market Signals by Naive Bayes.html b/03 Open Source/05 Brokerage Development Guide/08 Step 6%3A Enable Serving Historical Data.html
similarity index 100%
rename from Tutorial Series/Introduction to Machine Learning/Tutorial03 Bayes' Theorem and Classification of Market Signals by Naive Bayes.html
rename to 03 Open Source/05 Brokerage Development Guide/08 Step 6%3A Enable Serving Historical Data.html
diff --git a/Tutorial Series/Introduction to Machine Learning/Tutorial04 Using Entropy and Information Gain to Construct ID3 Decision Tree.html b/03 Open Source/05 Brokerage Development Guide/09 Step 7%3A Downloading Data.html
similarity index 100%
rename from Tutorial Series/Introduction to Machine Learning/Tutorial04 Using Entropy and Information Gain to Construct ID3 Decision Tree.html
rename to 03 Open Source/05 Brokerage Development Guide/09 Step 7%3A Downloading Data.html
diff --git a/Tutorial Series/Introduction to Machine Learning/Tutorial05 Random Subtrees and Class Prediction with Random Forest.html b/03 Open Source/05 Brokerage Development Guide/10 Step 8%3A Brokerage Fee Structures.html
similarity index 100%
rename from Tutorial Series/Introduction to Machine Learning/Tutorial05 Random Subtrees and Class Prediction with Random Forest.html
rename to 03 Open Source/05 Brokerage Development Guide/10 Step 8%3A Brokerage Fee Structures.html
diff --git a/Tutorial Series/Introduction to Machine Learning/Tutorial06 Boosting Ensemble and Making Predictions with AdaBoost.html b/03 Open Source/05 Brokerage Development Guide/11 Step 9%3A Updating Algorithm API.html
similarity index 100%
rename from Tutorial Series/Introduction to Machine Learning/Tutorial06 Boosting Ensemble and Making Predictions with AdaBoost.html
rename to 03 Open Source/05 Brokerage Development Guide/11 Step 9%3A Updating Algorithm API.html
diff --git a/03 Open Source/06 Generating Random Backtest Data/00.html b/03 Open Source/06 Generating Random Backtest Data/00.html
new file mode 100644
index 0000000..fb95fe4
--- /dev/null
+++ b/03 Open Source/06 Generating Random Backtest Data/00.html
@@ -0,0 +1 @@
+
diff --git a/03 Open Source/06 Generating Random Backtest Data/01 Introduction.html b/03 Open Source/06 Generating Random Backtest Data/01 Introduction.html
new file mode 100644
index 0000000..51fc885
--- /dev/null
+++ b/03 Open Source/06 Generating Random Backtest Data/01 Introduction.html
@@ -0,0 +1,2 @@
+
Real market data is often expensive and governed by difficult redistribution licenses. QuantConnect wanted to give the LEAN users a way to design and test their algorithms, without needing to download and buy real financial data. The RandomDataGenerator seeks to address that by randomly generating data in the LEAN format, for the various asset types we support.
+
diff --git a/03 Open Source/06 Generating Random Backtest Data/02 Using the Random Data Generator.html b/03 Open Source/06 Generating Random Backtest Data/02 Using the Random Data Generator.html
new file mode 100644
index 0000000..c86faaf
--- /dev/null
+++ b/03 Open Source/06 Generating Random Backtest Data/02 Using the Random Data Generator.html
@@ -0,0 +1,28 @@
+
The LEAN Random Data Generator is located in the LEAN ToolBox and can be accessed by executing the QuantConnect.ToolBox.exe CLI program.
+
We recommend cloning LEAN and building from the source code directly from Github. However, if this is not possible for you we have made a snapshot of the build available for your convenience here: 2019-01-19-QuantConnect.ToolBox.Binaries.zip
+
+
+
To run the ToolBox open a command window and execute it from the command line. To execute it you will need C# or Mono installed:
+The Random Data Generator has many parameters you can configure to generate the various datasets LEAN supports. Please see the next section for documentation on these parameters.
+
\ No newline at end of file
diff --git a/03 Open Source/06 Generating Random Backtest Data/03 Command Parameters.html b/03 Open Source/06 Generating Random Backtest Data/03 Command Parameters.html
new file mode 100644
index 0000000..9580486
--- /dev/null
+++ b/03 Open Source/06 Generating Random Backtest Data/03 Command Parameters.html
@@ -0,0 +1,77 @@
+
+
+
+
Random Data Generator Parameters
+
+
+
security-type
+
+
+ Security type to generate.
+ Possible Values: Equity, Crypto, Forex, Cfd, Option, Future
+ Default: Equity
+
+ Example: --security-type=Equity
+
+
+
+
resolution
+
+
+ Resolution of data to store.
+ Possible Values: Tick, Second, Minute, Hour, Daily
+ Default: Minute
+
+ Example: --resolution=Minute
+
+
+
+
from-date
+
+
+ Start date for the data to generate: format yyyy-mm-dd.
+
+ Example: --from-date=2018-01-01
+
+
+
+
to-date
+
+
+ Final date of the generated data: format yyyy-mm-dd.
+
+ Example: --to-date=2019-01-01
+
+
+
+
Symbol Count
+
+
+ Number of tickers to generate
+
+ Example: --symbol-count=100
+
+
+
+
data-density
+
+
+ Tick density of the data generated to model low volume data.
+ Possible Values: Dense, Sparse, VerySparse
+ Default: Dense
+
+ Example: --density=Dense
+
+
+
+
include-coarse
+
+
+ Generate the coarse universe data when generating Equity data.
+ Default: true
+
+ Example: --include-coarse=true
+
+
+
+
\ No newline at end of file
diff --git a/03 Open Source/06 Generating Random Backtest Data/04 Supported Assets and Resolutions.html b/03 Open Source/06 Generating Random Backtest Data/04 Supported Assets and Resolutions.html
new file mode 100644
index 0000000..7892a03
--- /dev/null
+++ b/03 Open Source/06 Generating Random Backtest Data/04 Supported Assets and Resolutions.html
@@ -0,0 +1,27 @@
+
The Random Data Generator currently supports the following asset types and resolutions:
+
+
+
+
+
Supported Data Types and Resolutions
+
+
+
Equity Trade Only
+
Resolutions Tick, Second, Minute, Hour and Daily
All Equity data resolutions are supported.
+
+
+
Forex, CFD Quotes Only
+
+ Resolutions Tick, Second, Minute, Hour and Daily
+
Forex and CFD generator supports quote (spread) data in all resolutions.
+
+
+
Futures, Crypto Trades and Quotes
+
Resolutions Tick, Second, Minute, Hour and Daily
All Futures and crypto data types and resolutions are supported
+
+
+
Options Trades and Quotes
+
Resolution Minute
Options are partially supported. Currently option random data is generated independent of a random underlying asset making its usefulness limited. This will be fixed by Github Issue #2839.
+
+
+
diff --git a/03 Open Source/06 Generating Random Backtest Data/05 Final Notes.html b/03 Open Source/06 Generating Random Backtest Data/05 Final Notes.html
new file mode 100644
index 0000000..b44db0c
--- /dev/null
+++ b/03 Open Source/06 Generating Random Backtest Data/05 Final Notes.html
@@ -0,0 +1,10 @@
+
+The Random Data Generator uses Brownian motion to generate the data prices. You can see how these prices and ticker strings
+are generated in the
+RandomValueGenerator class.
+
+
+
+If you'd like to use a different system for providing the randomness you can implement your own IRandomValueGenerator or
+extend the RandomValueGenerator class.
+
diff --git a/04 Strategy Library/00 Strategy Library/01 Strategy Library.php b/04 Strategy Library/00 Strategy Library/01 Strategy Library.php
new file mode 100644
index 0000000..9fc944f
--- /dev/null
+++ b/04 Strategy Library/00 Strategy Library/01 Strategy Library.php
@@ -0,0 +1,866 @@
+ 'CAPM Alpha Ranking Strategy on Dow 30 Companies',
+ 'link' => 'strategy-library/capm-alpha-ranking-strategy-on-dow-30-companies',
+ 'description' => 'Applies CAPM model to rank Dow Jones 30 companies.',
+ 'tags'=>'Intermediate,Momentum,Equities'
+ ],
+ [
+ 'name' => 'Combining Mean Reversion and Momentum in Forex Market',
+ 'link' => 'strategy-library/combining-mean-reversion-and-momentum-in-forex-market',
+ 'description' => 'Combines momentum and mean reversion techniques in the forex markets.',
+ 'tags'=>'Intermediate,Mean Reversion,Momentum,Forex'
+ ],
+ [
+ 'name' => 'Pairs Trading-Copula vs Cointegration',
+ 'link' => 'strategy-library/pairs-trading-copula-vs-cointegration',
+ 'description' => 'Applies Copula and Cointergration method to pairs trading.',
+ 'tags'=>'Expert,Pairs Trading,ETFs'
+ ],
+ [
+ 'name' => 'The Dynamic Breakout II Strategy',
+ 'link' => 'strategy-library/the-dynamic-breakout-ii-strategy',
+ 'description' => 'A demonstration of dynamic breakout II strategy.',
+ 'tags'=>'Intermediate,Breakout,Forex'
+ ],
+ [
+ 'name' => 'Dual Thrust Trading Algorithm',
+ 'link' => 'strategy-library/dual-thrust-trading-algorithm',
+ 'description' => 'A demontration of Dual Thrust Intraday strategy.',
+ 'tags'=>'Intermediate,Breakout,Equities'
+ ],
+ [
+ 'name' => 'Can Crude Oil Predict Equity Returns',
+ 'link' => 'strategy-library/can-crude-oil-predict-equity-returns',
+ 'description' => 'Applies regression method to predict the return from the stock market and compare it to the short-term U.S. T-bill rate.',
+ 'tags'=>'Intermediate,Momentum,ETFs'
+ ],
+ [
+ 'name' => 'Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach',
+ 'link' => 'strategy-library/intraday-dynamic-pairs-trading-using-correlation-and-cointegration-approach',
+ 'description' => 'A high frequency pairs trading algorithm based on cointegration.',
+ 'tags'=>'Expert,Pairs Trading,Equities'
+ ],
+ [
+ 'name' => 'The Momentum Strategy Based on the Low Frequency Component of Forex Market',
+ 'link' => 'strategy-library/the-momentum-strategy-based-on-the-low-frequency-Component-of-forex-market',
+ 'description' => 'Applies high frequency filter to the momentum strategy.',
+ 'tags'=>'Intermediate,Momentum,Forex'
+ ],
+ [
+ 'name' => 'Stock Selection Strategy Based on Fundamental Factors',
+ 'link' => 'strategy-library/stock-selection-strategy-based-on-fundamental-factors',
+ 'description' => 'MorningStar Fundamental factors universe selection algorithm.',
+ 'tags'=>'Intermediate,Fundamental Factors,Equities'
+ ],
+ [
+ 'name' => 'Short-Term Reversal Strategy in Stocks',
+ 'link' => 'strategy-library/short-term-reversal-strategy-in-stocks',
+ 'description' => 'A short term reversal algorithm which gives the opposite signal by analyzing recent period price action.',
+ 'tags'=>'Intermediate,Long Short,Mean Reversion,Equities'
+ ],
+ [
+ 'name' => 'Fundamental Factor Long Short Strategy',
+ 'link' => 'strategy-library/fundamental-factor-long-short-strategy',
+ 'description' => 'A basic monthly rebalance long short algorithm based on fundamental factors.',
+ 'tags'=>'Intermediate,Fundamental Factors,Long Short,Equities'
+ ],
+ [
+ 'name' => 'Asset Class Trend Following',
+ 'link' => 'strategy-library/asset-class-trend-following',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/1'
+ ],
+ 'description' => 'Selects ETFs over ten-month moving average and assigns an equally weighted allocation.',
+ 'tags'=>'Beginner,Momentum,ETFs'
+ ],
+ [
+ 'name' => 'Asset Class Momentum',
+ 'link' => 'strategy-library/asset-class-momentum',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/2'
+ ],
+ 'description' => 'Selects ETFs in different asset classes with the highest momentum and assigns an equally weighted allocation.',
+ 'tags'=>'Beginner,Momentum,ETFs'
+
+ ],
+ [
+ 'name' => 'Residual Momentum',
+ 'link' => 'strategy-library/residual-momentum',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/136'
+ ],
+ 'description' => 'Constructs a long/short portfolio based on trailing residual momentum normalized by its standard deviation',
+ 'tags'=>'Intermediate,Equities,Momentum'
+
+ ],
+ [
+ 'name' => 'Sector Momentum',
+ 'link' => 'strategy-library/sector-momentum',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/3'
+ ],
+ 'description' => 'Selects ETFs in different sectors with the highest momentum and assigns an equally weighted allocation.',
+ 'tags'=>'Beginner,Momentum,ETFs'
+ ],
+ [
+ 'name' => 'Overnight Anomaly',
+ 'link' => 'strategy-library/overnight-anomaly',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/4'
+ ],
+ 'description' => 'Buy SPY ETF at its closing price and sell it at the opening each day.',
+ 'tags'=>'Beginner,ETFs'
+ ],
+ [
+ 'name' => 'Forex Carry Trade',
+ 'link' => 'strategy-library/forex-carry-trade',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/5'
+ ],
+ 'description' => 'Goes long the currency with the highest central bank interest rate and goes short the currency with the lowest interest rate.',
+ 'tags'=>'Beginner,Long Short,Forex'
+ ],
+ [
+ 'name' => 'Volatility Effect in Stocks',
+ 'link' => 'strategy-library/volatility-effect-in-stocks',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/7'
+ ],
+ 'description' => 'Constructs equally weighted portfolios by selecting stocks with the lowest volatility in the past one year.',
+ 'tags'=>'Intermediate,Equities'
+ ],
+ [
+ 'name' => 'Forex Momentum',
+ 'link' => 'strategy-library/forex-momentum',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/8'
+ ],
+ 'description' => 'Goes long currencies with strongest 12 month momentum against USD and goes short currencies with the lowest 12 month momentum against USD.',
+ 'tags'=>'Beginner,Momentum,Forex'
+ ],
+ [
+ 'name' => 'Pairs Trading with Stocks',
+ 'link' => 'strategy-library/pairs-trading-with-stocks',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/12'
+ ],
+ 'description' => 'Looks for the security that minimizes the sum of squared deviations and long-short position is opened when pair prices have diverged by multiple of standard deviations.',
+ 'tags'=>'Expert,Pairs Trading,Mean Reversion,Equities'
+ ],
+ [
+ 'name' => 'Short Term Reversal',
+ 'link' => 'strategy-library/short-term-reversal',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/13'
+ ],
+ 'description' => 'Goes long stocks with the lowest return in the previous month and goes short stocks with the greatest return from the previous month.',
+ 'tags'=>'Intermediate,Long Short,Mean Reversion,Equities'
+ ],
+ [
+ 'name' => 'Momentum Effect in Stocks',
+ 'link' => 'strategy-library/momentum-effect-in-stocks',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/14'
+ ],
+ 'description' => 'Goes long stocks with the best 12-month momentum in the large-cap universe.',
+ 'tags'=>'Beginner,Momentum,Equities'
+ ],
+ [
+ 'name' => 'Momentum Effect in Country Equity Indexes',
+ 'link' => 'strategy-library/momentum-effect-in-country-equity-indexes',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/15'
+ ],
+ 'description' => 'Goes long stocks with the best 12-month momentum in the country equity indexes ETFs.',
+ 'tags'=>'Beginner,Momentum,ETFs'
+ ],
+ [
+ 'name' => 'Mean Reversion Effect in Country Equity Indexes',
+ 'link' => 'strategy-library/mean-reversion-effect-in-country-equity-indexes',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/16'
+ ],
+ 'description' => 'Goes long country equity indexes ETFs with the worst 36-month return and short ETFs with the best 36-month return.',
+ 'tags'=>'Beginner,Long Short,Mean Reversion,ETFs'
+
+ ],
+ [
+ 'name' => 'Liquidity Effect in Stocks',
+ 'link' => 'strategy-library/liquidity-effect-in-stocks',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/18'
+ ],
+ 'description' => 'Goes long stocks with the lowest turnover and short on stocks with the highest turnover from the lowest market-cap quartile.',
+ 'tags'=>'Intermediate,Long Short,Equities'
+ ],
+ [
+ 'name' => 'Volatility Risk Premium Effect',
+ 'link' => 'strategy-library/volatility-risk-premium-effect',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/20'
+ ],
+ 'description' => 'Sells at-the-money straddle with one month until maturity and buys an offsetting 15% out-of-the-money puts each month.',
+ 'tags'=>'Expert,Short Volatility,Options'
+ ],
+ [
+ 'name' => 'Momentum Effect in Commodities Futures',
+ 'link' => 'strategy-library/momentum-effect-in-commodities-futures',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/21'
+ ],
+ 'description' => 'Goes long commodity futures with the highest momentum and short on futures with the lowest momentum.',
+ 'tags'=>'Intermediate,Long Short,Futures'
+ ],
+ [
+ 'name' => 'Small Capitalization Stocks Premium Anomaly',
+ 'link' => 'strategy-library/small-capitalization-stocks-premium-anomaly',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/25'
+ ],
+ 'tags'=>'Intermediate,Fundamental Factors,Equities',
+ 'description' => 'Goes long stocks with the lowest market capitalization and rebalances the portfolio once a year.'
+ ],
+ [
+ 'name' => 'Paired Switching',
+ 'link' => 'strategy-library/paired-switching',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/44'
+ ],
+ 'description' => 'Goes long asset with better performance over the last period and rebalances portfolio every quarter.',
+ 'tags'=>'Intermediate,Pairs Trading,Equities'
+ ],
+ [
+ 'name' => 'Term Structure Effect in Commodities',
+ 'link' => 'strategy-library/term-structure-effect-in-commodities',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/22'
+ ],
+ 'description' => 'Buys each month the 20% of commodities with the highest roll-returns and shorts the 20% of commodities with the lowest roll-returns and holds the long-short positions for one month.',
+ 'tags'=>'Expert,Long Short,Futures'
+ ],
+ [
+ 'name' => 'Momentum Effect Combined with Term Structure in Commodities',
+ 'link' => 'strategy-library/momentum-effect-combined-with-term-structure-in-commodities',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/23'
+ ],
+ 'description' => 'Portfolios are formed based on roll returns and the algorithm goes long and short contracts with the highest and lowest one-month performance.',
+ 'tags'=>'Expert,Long Short,Futures'
+ ],
+ [
+ 'name' => 'Book-to-Market Value Anomaly',
+ 'link' => 'strategy-library/book-to-market-value-anomaly',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/26'
+ ],
+ 'description' => 'Quintile portfolios are formed based on the Book-to-Market ratio and the highest quintile is held for one year.',
+ 'tags'=>'Intermediate,Fundamental Factors,Equities'
+ ],
+ [
+ 'name' => 'Gold Market Timing',
+ 'link' => 'strategy-library/gold-market-timing',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/43'
+ ],
+ 'description' => 'Goes long gold when the Fed model shows that the market is undervalued (the earnings yield is higher than the bond yield and their ratio is at least 2).',
+ 'tags'=>'Intermediate,Mean Reversion,ETFs'
+ ],
+ [
+ 'name' => 'Turn of the Month in Equity Indexes',
+ 'link' => 'strategy-library/turn-of-the-month-in-equity-indexes',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/41'
+ ],
+ 'description' => 'Buys SPY the day before the end of the month and liquidates position on 3rd trading day of new month.',
+ 'tags'=>'Beginner,ETFs'
+ ],
+ [
+ 'name' => 'Momentum - Short Term Reversal Strategy',
+ 'link' => 'strategy-library/momentum-short-term-reversal-strategy',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/51'
+ ],
+ 'description' => 'Goes long stocks with the decreasing return from the winner group and short stocks with the increasing return from the loser group.',
+ 'tags'=>'Intermediate,Long Short,Equities'
+ ],
+ [
+ 'name' => 'Pairs Trading with Country ETFs',
+ 'link' => 'strategy-library/pairs-trading-with-country-etfs',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/55'
+ ],
+ 'description' => 'Identifies the price divergence from two highly correlated country ETFs and takes a market neutral position.',
+ 'tags'=>'Expert,Pairs Trading,ETFs'
+ ],
+ [
+ 'name' => 'Sentiment and Style Rotation Effect in Stocks',
+ 'link' => 'strategy-library/sentiment-and-style-rotation-effect-in-stocks',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/53'
+ ],
+ 'description' => 'Creates long-short positions of growth and value stocks based on the investment sentiment.',
+ 'tags'=>'Expert,Long Short,Fundamental Factors,Equities'
+ ],
+ [
+ 'name' => 'Asset Growth Effect',
+ 'link' => 'strategy-library/asset-growth-effect',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/52'
+ ],
+ 'description' => 'Creates long-short positions of stocks based on the annual change of their total assets.',
+ 'tags'=>'Intermediate,Long Short, Fundamental Factors,Equities'
+ ],
+ [
+ 'name' => 'Momentum and State of Market Filters',
+ 'link' => 'strategy-library/momentum-and-state-of-market-filters',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/54'
+ ],
+ 'description' => 'Goes long and short stocks with the highest and lowest six-month momentum respectively if the previous 12 months return on the broad market index was positive.',
+ 'tags'=>'Intermediate,Long Short,Momentum,Equities'
+ ],
+ [
+ 'name' => 'Accrual Anomaly',
+ 'link' => 'strategy-library/accrual-anomaly',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/38'
+ ],
+ 'description' => 'Decile portfolios are formed based on balance sheet based accruals and highest decile is shorted while lowest decile is bought for a year.',
+ 'tags'=>'Intermediate,Long Short,Equities'
+ ],
+ [
+ 'name' => 'Momentum in Mutual Fund Returns',
+ 'link' => 'strategy-library/momentum-in-mutual-fund-returns',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/85'
+ ],
+ 'description' => 'Forms a long-short portfolio of asset management firms based on trailing rate of change and nearness to trailing high.',
+ 'tags'=>'Intermediate,Long Short,Equities'
+ ],
+ [
+ 'name' => 'Momentum and Style Rotation Effect',
+ 'link' => 'strategy-library/momentum-and-style-rotation-effect',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/91'
+ ],
+ 'description' => 'Goes long style index ETF with the highest 12-month momentum and short ETF with the lowest 12-month momentum.',
+ 'tags'=>'Beginner,Long Short,ETFs'
+ ],
+ [
+ 'name' => 'Trading with WTI BRENT Spread',
+ 'link' => 'strategy-library/trading-with-wti-brent-spread',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/100'
+ ],
+ 'description' => 'Goes long the spread if the spread is below 20-day moving average and short if the spread is above 20-day moving average.',
+ 'tags'=>'Intermediate,Mean Reversion,Commodities'
+ ],
+ [
+ 'name' => 'Momentum Effect in REITs',
+ 'link' => 'strategy-library/momentum-effect-in-reits',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/152'
+ ],
+ 'description' => 'Tercile portfolios are formed based on momentum and the best performing portfolio is held.',
+ 'tags'=>'Intermediate,Momentum,ETFs'
+ ],
+ [
+ 'name' => 'Option Expiration Week Effect',
+ 'link' => 'strategy-library/option-expiration-week-effect',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/102'
+ ],
+ 'description' => 'Goes long S&P 100 index ETF during option expiration week and stays in cash during other days.',
+ 'tags'=>'Intermediate,Options'
+ ],
+ [
+ 'name' => 'Earnings Quality Factor',
+ 'link' => 'strategy-library/earnings-quality-factor',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/229'
+ ],
+ 'description' => 'Goes long stocks with high earnings quality and short stocks with low earnings quality based on composite factor score.',
+ 'tags'=>'Intermediate,Long Short,Fundamental Factors,Equities'
+ ],
+ [
+ 'name' => 'January Effect in Stocks',
+ 'link' => 'strategy-library/january-effect-in-stocks',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/114'
+ ],
+ 'description' => 'Invests into small cap stocks at the beginning of each January and stays invested in large cap stocks for rest of the year.',
+ 'tags'=>'Intermediate,Equities'
+ ],
+ [
+ 'name' => 'Momentum and Reversal Combined with Volatility Effect in Stocks',
+ 'link' => 'strategy-library/momentum-and-reversal-combined-with-volatility-effect-in-stocks',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/155'
+ ],
+ 'description' => 'Goes long on stocks from the highest performing quintile from the highest volatility group and short on stocks from the lowest performing quintile from the highest volatility group.',
+ 'tags'=>'Intermediate,Long Short,Equities'
+ ],
+ [
+ 'name' => 'ROA Effect within Stocks',
+ 'link' => 'strategy-library/roa-effect-within-stocks',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/199'
+ ],
+ 'description' => 'Goes long on stocks with highest ROA and short stocks with the lowest ROA from each market capitalization group.',
+ 'tags'=>'Intermediate,Long Short,Fundamental Factors,Equities'
+ ],
+ [
+ 'name' => 'January Barometer',
+ 'link' => 'strategy-library/january-barometer',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/113'
+ ],
+ 'description' => "Invested in equity market with ETF only if January return is positive otherwise switch investments to T-Bills.",
+ 'tags'=>'Beginner,Equities'
+ ],
+ [
+ 'name' => 'Lunar Cycle in Equity Market',
+ 'link' => 'strategy-library/lunar-cycle-in-equity-market',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/61'
+ ],
+ 'description' => "Goes long in emerging market index ETF 7 days before the new moon and switch to a short position on emerging market index ETF 7 days before the full moon.",
+ 'tags'=>'Intermediate,ETFs'
+ ],
+ [
+ 'name' => 'VIX Predicts Stock Index Returns',
+ 'link' => 'strategy-library/vix-predicts-stock-index-returns',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/58'
+ ],
+ 'description' => "Goes long on equity index ETF if the VIX is in the highest percentile short if VIX is in the lowest percentile in the last two-year history.",
+ 'tags'=>'Beginner,Equities'
+ ],
+ [
+ 'name' => 'Combining Momentum Effect with Volume',
+ 'link' => 'strategy-library/combining-momentum-effect-with-volume',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/66'
+ ],
+ 'description' => "Goes long stocks with the highest volume from the top momentum decile and short stocks with the highest volume from the bottom momentum decile.",
+ 'tags'=>'Intermediate,Long Short,Equities'
+ ],
+ [
+ 'name' => 'Short Term Reversal with Futures',
+ 'link' => 'strategy-library/short-term-reversal-with-futures',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/71'
+ ],
+ 'description' => "Goes long (short) on futures from the high-volume, low-open interest group with the lowest (greatest) returns in the previous week.",
+ 'tags'=>'Intermediate,Long Short,Futures'
+ ],
+ [
+ 'name' => 'Pre-holiday Effect',
+ 'link' => 'strategy-library/pre-holiday-effect',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/83'
+ ],
+ 'description' => "Invests in equity market 2 days preceding holiday days and stays in cash during the other trading days.",
+ 'tags'=>'Beginner,Equities'
+ ],
+ [
+ 'name' => 'Beta Factors in Stocks',
+ 'link' => 'strategy-library/beta-factors-in-stocks',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/77'
+ ],
+ 'description' => "Goes long stocks with the bottom beta and short stocks with the top beta, securities are weighted by the ranked betas.",
+ 'tags'=>'Intermediate,Long Short,Equities'
+ ],
+ [
+ 'name' => 'Exploiting Term Structure of VIX Futures',
+ 'link' => 'strategy-library/exploiting-term-structure-of-vix-futures',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/198'
+ ],
+ 'description' => "Buys or sells the nearest VIX futures based on the daily roll and hedge against the open positions with E-mini S&P500 futures.",
+ 'tags'=>'Expert,Futures'
+ ],
+ [
+ 'name' => '12 Month Cycle in Cross-Section of Stocks Returns',
+ 'link' => 'strategy-library/12-month-cycle-in-cross-section-of-stocks-returns',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/125'
+ ],
+ 'description' => "Reviews the returns from last January, going long on the top 10% winners and short the bottom 10%.",
+ 'tags'=>'Intermediate,Long Short,Momentum Equities'
+ ],
+ [
+ 'name' => 'Momentum Effect in Stocks in Small Portfolios',
+ 'link' => 'strategy-library/momentum-effect-in-stocks-in-small-portfolios',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/162'
+ ],
+ 'description' => "Goes long in the 10 stocks with the highest performance and goes short in the 10 stocks with the lowest performance in the previous one year.",
+ 'tags'=>'Intermediate, Momentum,Equities'
+ ],
+ [
+ 'name' => 'Value Effect within Countries',
+ 'link' => 'strategy-library/value-effect-within-countries',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/207'
+ ],
+ 'description' => "Invests in the cheapest 33% of country ETFs according to CAPE ratios.",
+ 'tags'=>'Intermediate,Fundamental Factors,ETFs'
+ ],
+ [
+ 'name' => 'Beta Factor in Country Equity Indexes',
+ 'link' => 'strategy-library/beta-factor-in-country-equity-indexes',
+ 'sources' => [
+ 'Quantpedia' => 'https://www.quantpedia.com/Screener/Details/78'
+ ],
+ 'description' => "Goes long on the low-beta portfolio and short on the high-beta portfolio in country indexes ETFs.",
+ 'tags'=>'Intermediate,Long Short,ETFs'
+ ],
+ [
+ 'name' => 'Price to Earnings Anomaly',
+ 'link' => 'strategy-library/price-earnings-anomaly',
+ 'description' => "Invests in stocks with low P/E ratio.",
+ 'tags'=>'Beginner,Fundamental Factors,Equities'
+ ],
+ [
+ 'name' => 'Fama French Five Factors',
+ 'link' => 'strategy-library/fama-french-five-factors',
+ 'sources' => [
+ 'NYU' => 'https://www.sciencedirect.com/science/article/pii/S0304405X14002323'
+ ],
+ 'description' => "Stock selecting strategy based on Fama-French Five Factors Model.",
+ 'tags'=>'Long Short,Fundamental Factors,Equities'
+ ],
+ [
+ 'name' => 'Mean-Reversion Statistical Arbitrage Strategy in Stocks',
+ 'link' => 'strategy-library/mean-reversion-statistical-arbitrage-strategy-in-stocks',
+ 'sources' => [
+ 'NYU' => 'https://www.math.nyu.edu/faculty/avellane/AvellanedaLeeStatArb071108.pdf'
+ ],
+ 'description' => "Apply statistical arbitrage to take advantage of pricing inefficiencies in stocks.",
+ 'tags'=>'PCA,Mean Reversion,Stocks,Arbitrage'
+ ],
+ [
+ 'name' => 'Expected Idiosyncratic Skewness',
+ 'link' => 'strategy-library/expected-idiosyncratic-skewness',
+ 'sources' => [
+ 'NYU' => 'http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.825.592&rep=rep1&type=pdf'
+ ],
+ 'description' => "Stock selection strategy that calculates expected idiosyncratic skewness using Fama-French three-factor model, sorts stocks based on the calculated skewness, and longs the bottom 5%.",
+ 'tags' => 'Equities, Skewness, Fundamental Factors, Statistical Arbitrage'
+ ],
+ [
+ 'name' => 'Risk Premia in Forex Markets',
+ 'link' => 'strategy-library/risk-premia-in-forex-markets',
+ 'sources' => [
+ 'NYU' => 'https://arxiv.org/pdf/1409.7720.pdf'
+ ],
+ 'description' => "A strategy based on asymmetric tail risks and excess returns in forex markets.",
+ 'tags'=>'Forex,Skewness,Risk Premium'
+
+ ],
+ [
+ 'name' => 'Seasonality Effect based on Same-Calendar Month Returns',
+ 'link' => 'strategy-library/seasonality-effect-based-on-same-calendar-month-returns',
+ 'sources' => [
+ 'NYU' => 'https://www.nber.org/papers/w20815.pdf'
+ ],
+ 'description' => "A strategy that takes long and short positions based on historical same-calendar month returns",
+ 'tags'=>'Seasonality,Stocks,Universe Selection'
+
+ ],
+ [
+ 'name' => 'Standardized Unexpected Earnings',
+ 'link' => 'strategy-library/standardized-unexpected-earnings',
+ 'sources' => [
+ 'NYU' => 'https://www.jstor.org/stable/pdf/247321.pdf'
+ ],
+ 'description' => "Stock selection strategy that calculates the unexpected earnings, standardizes the unexpected earnings, goes long on the top 5%, and rebalances the portfolio monthly.",
+ 'tags' => 'Equities, Fundamental Factors, Earnings, Anomaly'
+ ],
+ [
+ 'name' => 'Price and Earnings Momentum',
+ 'link' => 'strategy-library/price-and-earnings-momentum',
+ 'sources' => [
+ 'NYU' => 'http://papers.ssrn.com/sol3/papers.cfm?abstract_id=299107'
+ ],
+ 'description' => "A momentum strategy based on quarterly returns and earnings growth",
+ 'tags'=>'Momentum, Stocks, Universe Selection, Historical Data, Rolling Window'
+
+ ],
+ [
+ 'name' => 'Improved Momentum Strategy on Commodities Futures',
+ 'link' => 'strategy-library/improved-momentum-strategy-on-commodities-futures',
+ 'sources' => [
+ 'NYU' => 'https://pdfs.semanticscholar.org/a2e9/df201d4b4774fda84a961cc804f2450988c5.pdf'
+ ],
+ 'description' => "An advanced momentum strategy that modifies the basic momentum strategies by introducing Baltas and Kosowski weights and rebalances the portfolio monthly. The new weighing scheme incorporates trend strength into the trading signal, uses an efficient volatility estimator, and adds a dynamic leverage mechanism.",
+ 'tags' => 'Momentum, Futures, Commodities'
+ ],
+ [
+ 'name' => 'Commodities Futures Trend Following',
+ 'link' => 'strategy-library/commodities-futures-trend-following',
+ 'sources' => [
+ 'NYU' => 'https://arxiv.org/pdf/1404.3274.pdf'
+ ],
+ 'description' => "A simple trend following strategy on commodities futures.",
+ 'tags' => 'Momentum, Futures, Commodities'
+ ],
+ [
+ 'name' => 'Forecasting Stock Prices using a Temporal CNN Model',
+ 'link' => 'strategy-library/forecasting-stock-prices-using-a-temporal-cnn-model',
+ 'sources' => [
+ 'Tampere University' => 'https://arxiv.org/pdf/1901.08280.pdf'
+ ],
+ 'description' => "Applying a Temporal Convolutional Neural Network to forecasting future stock prices.",
+ 'tags' => 'Convolutional Neural Network, Equities, Forecasting, Deep Learning'
+ ],
+ [
+ 'name' => 'Leveraged ETFs with Systematic Risk Management',
+ 'link' => 'strategy-library/leveraged-etfs-with-systematic-risk-management',
+ 'sources' => [
+ 'The Lead-Lag Report' => 'https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2741701'
+ ],
+ 'description' => 'We apply Simple Moving Averages to manage the risk of holding leveraged ETFs in an attempt to beat the S&P500',
+ 'tags' => 'Simple Moving Average, Risk Management, S&P500, ETF'
+ ],
+ [
+ 'name' => 'Leveraged ETFs with Systematic Risk Management',
+ 'link' => 'leveraged-etfs-with-systematic-risk-management',
+ 'sources' => [
+ 'The Lead-Lag Report' => 'https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2741701'
+ ],
+ 'description' => 'We apply Simple Moving Averages to manage risk in holding leveraged ETFs in an attempt to by the S&P500',
+ 'tags' => 'Simple Moving Average, Risk Management, S&P500, ETF'
+ ],
+ [
+ 'name' => 'Ichimoku Clouds in the Energy Sector',
+ 'link' => 'strategy-library/ichimoku-clouds-in-the-energy-sector',
+ 'sources' => [
+ 'SSRN' => 'https://ssrn.com/abstract=3520582'
+ ],
+ 'description' => 'A techincal indicator crossover strategy trading the largest energy companies.',
+ 'tags'=>'Intermediate, Technical Indicator, Ichimoku Cloud, Crossover, Equities'
+ ],
+ [
+ 'name' => 'Intraday ETF Momentum',
+ 'link' => 'strategy-library/intraday-etf-momentum',
+ 'sources' => [
+ 'NYU' => 'https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2440866'
+ ],
+ 'description' => "A momentum strategy based on returns of the market open",
+ 'tags'=>'Momentum, Stocks, Universe Selection, Equities, Anomaly'
+ ],
+ [
+ 'name' => 'Intraday Arbitrage Between Index ETFs',
+ 'link' => 'strategy-library/intraday-arbitrage-between-index-etfs',
+ 'sources' => [
+ 'SSRN' => 'https://papers.ssrn.com/sol3/papers.cfm?abstract_id=1709599'
+ ],
+ 'description' => "A strategy that tracks the price paths of two correlated ETFs and takes advantage of mis-pricings that arise when the price paths diverge",
+ 'tags'=>'Intermediate, Equities, Arbitrage, Intraday'
+ ],
+ [
+ 'name' => 'Optimal Pairs Trading',
+ 'link' => 'strategy-library/optimal-pairs-trading',
+ 'sources' => [
+ 'arXiv' => 'https://arxiv.org/pdf/1411.5062.pdf'
+ ],
+ 'description' => "Mathematically Deriving the Optimal Entry and Liquidation Values of a Pairs Trading Process",
+ 'tags'=>'Pairs Trading, Ornstein-Uhlenbeck Process, Optimal Stopping'
+ ],
+ [
+ 'name' => 'G-Score Investing',
+ 'link' => 'strategy-library/g-score-investing',
+ 'sources' => [
+ 'SSRN' => 'https://papers.ssrn.com/sol3/papers.cfm?abstract_id=403180'
+ ],
+ 'description' => "Applying G-Score Investing to Invest in a Portfolio of Technology Stocks",
+ 'tags'=>'Fundamentals, Factor Investing, G-Score Investing, MorningStar data, equities'
+ ],
+ [
+ 'name' => 'SVM Wavelet Forecasting',
+ 'link' => 'strategy-library/svm-wavelet-forecasting',
+ 'sources' => [
+ 'Academia' => 'https://www.academia.edu/37180223/SVR_Wavelet_Adaptive_Model_for_Forecasting_Financial_Time_Series'
+ ],
+ 'description' => "Forecasting EURJPY prices with an SVM Wavelet model",
+ 'tags'=>'Support Vector Machines (SVM), Forex, Forecasting, Wavelet, Discrete Wavelet Transform'
+ ],
+ [
+ 'name' => 'Gradient Boosting Model',
+ 'link' => 'strategy-library/gradient-boosting-model',
+ 'sources' => [
+ 'arXiv' => 'https://ssrn.com/abstract=2323899'
+ ],
+ 'description' => "Forecasts future intraday returns with a gradient boosting model trained on technical indicators",
+ 'tags'=>'Gradient Boost, Regression Trees, Equities, Machine Learning'
+ ],
+ [
+ 'name' => 'Using News Sentiment to Predict Price Direction of Drug Manufacturers',
+ 'link' => 'strategy-library/using-news-sentiment-to-predict-price-direction-of-drug-manufacturers',
+ 'sources' => [
+ 'arXiv' => 'https://arxiv.org/abs/1812.04199'
+ ],
+ 'description' => "Analyzes the news releases of drug manufacturers and places intraday trades for the stocks with positive news.",
+ 'tags'=>'Equities, NLP, News Sentiment, Drug Manufacturers, Tiingo, Intraday'
+ ],
+ [
+ 'name' => 'Gaussian Naive Bayes Model',
+ 'link' => 'strategy-library/gaussian-naive-bayes-model',
+ 'sources' => [
+ 'Academia' => 'https://www.academia.edu/7677227/Forecasting_the_direction_of_stock_market_index_movement_using_three_data_mining_techniques_the_case_of_Tehran_Stock_Exchange'
+ ],
+ 'description' => "Forecasts the next day's return of technology stocks by fitting a gaussian naive bayes model to the historical returns of the technology sector constituents.",
+ 'tags'=>'Equities, Machine Learning, Naive Bayes, Gaussian'
+ ]
+];
+
+?>
+
+ This tutorial performs a simple linear regression to build the Capital Asset Pricing Model(CAPM), a classical model developed by William F. Sharpe and Harry Markowitz. This model yields alpha and beta for each asset and is traded by going long on the stocks ranked with the highest alpha. This tutorial will demonstrate the following:
+
+
+
+
How to use historical data
+
Set an event handler
+
Conduct linear regression
+
Build your own functions in the QuantConnect Algorithm Lab
+
+
+
+ The implementation of the strategy demonstrates that stocks beat the market last month are likely to beat the market again in the subsequent month. This algorithm performs well when the market is smooth. However when the market volatility increases the model fails to capture alpha and it performs poorly. What we learn from this is that market fluctuations decrease the significance level of the linear regression coefficients, especially when we are using daily returns to fit the model.
+
+ The capital asset pricing model (CAPM) describes the relationship between systematic risk and expected return for assets, typically stocks. The formula for calculating the expected return of an asset given its risk is as follows:
+
+ The left side of the equation gives us the difference between the asset return and risk free rate, the "excess return". If we regress the market excess return against the asset excess return the slope represents the "beta" of the asset. Therefore, beta can also be calculated by the equation:
+
+ The formula above indicates that beta can be explained as "correlated relative volatility". To make this simpler, beta can be calculated by doing a simple linear regression which can be viewed as a factor to explain the return, and the tracking error can represent alpha.
+ To make this theory more convenient for our algorithm, we change the above formula into the following form:
+
+ r*(1-β) on the right hand side of the equation is a very small item, making it negligible in the context of the Dow 30 companies. If we regress the stocks return with the return of the benchmark, the slope and intercept will be beta and alpha.
+
+ Our investment logic is simple and straightforward. We assume that stocks which beat the market last month will continue to beat the market. We rank stocks according to their alpha, and each month we "long" the top two stocks. For this strategy to work, we need to do the following at the start of each month:
+
+
+
Get the historical price of Dow 30 stocks in the past 21 trading days and calculate their daily rates of return.
+
Conduct simple linear regression on the return of each stock against a benchmark (S&P 500 index, SPY).
+
Rank the stocks by their intercepts.
+
Liquidate all our positions and purchase the first 2 stocks in our sorted list.
+
+
+ Dow Jones components change very infrequently, with the last change being on March 19th, 2015. To make the implementation easier we have simply listed the current Dow components in this algorithm. This means that the earliest start date of this algorithm is March 19th, 2015.
+
+
Step 1: Setup Event Handler
+
+ In the initialize method we define a Scheduled Event to trigger a monthly re-balancing of the portfolio. For more details about how to use Scheduled Events, you can read the Documentation or see the example ScheduledEventsAlgorithm.
+
+ Each month we get the historical prices of the DOW30 components using the History API. The data is returned from the API as a pandas.DataFrame indexed by Symbol objects. The close data is selected and the data frame is unstack to create columns of Symbol objects.
+
+
+
# Fetch the historical data to perform the linear regression
+history = self.History(
+ self.symbols + [self.benchmark],
+ self.lookback,
+ Resolution.Daily).close.unstack(level=0)
+
+
Step 3: Symbol Selection Function
+
+ We aim to trade the two assets with the highest alpha to the benchmark. In order to conduct linear regression to find the alpha (linear regression intercept), we need to compute returns (percentage change of closing price) benchmark and the asset then conduct a linear regression.
+
+
+
def SelectSymbols(self, history):
+ '''Select symbols with the highest intercept/alpha to the benchmark
+ '''
+ alphas = dict()
+
+ # Get the benchmark returns
+ benchmark = history[self.benchmark].pct_change().dropna()
+
+ # Conducts linear regression for each symbol and save the intercept/alpha
+ for symbol in self.symbols:
+
+ # Get the security returns
+ returns = history[symbol].pct_change().dropna()
+ returns = np.vstack([returns, np.ones(len(returns))]).T
+
+ # Simple linear regression function in Numpy
+ result = np.linalg.lstsq(returns, benchmark)
+ alphas[symbol] = result[0][1]
+
+ # Select symbols with the highest intercept/alpha to the benchmark
+ selected = sorted(alphas.items(), key=lambda x: x[1], reverse=True)[:2]
+ return [x[0] for x in selected]
+
+
Step 4: Rebalance Function:
+
+ This function is where all the action happens, it will be executed on the first trading day of each month as a scheduled event. The algorithm closes all positions of securities that were not selected using Liquidate and go 100% long for both of the selected symbols using SetHoldings.
+
+
+
def Rebalance(self):
+
+ # Fetch the historical data to perform the linear regression
+ history = self.History(
+ self.symbols + [self.benchmark],
+ self.lookback,
+ Resolution.Daily).close.unstack(level=0)
+
+ symbols = self.SelectSymbols(history)
+
+ # Liquidate positions that are not held by selected symbols
+ for holdings in self.Portfolio.Values:
+ symbol = holdings.Symbol
+ if symbol not in symbols and holdings.Invested:
+ self.Liquidate(symbol)
+
+ # Invest 100% in the each of the selected symbols
+ for symbol in symbols:
+ self.SetHoldings(symbol, 1)
+
\ No newline at end of file
diff --git "a/04 Strategy Library/01 CAPM Alpha Ranking Strategy on Dow 30 Companies/03 \346\226\271\346\263\225.cn.html" "b/04 Strategy Library/01 CAPM Alpha Ranking Strategy on Dow 30 Companies/03 \346\226\271\346\263\225.cn.html"
new file mode 100644
index 0000000..b64df7a
--- /dev/null
+++ "b/04 Strategy Library/01 CAPM Alpha Ranking Strategy on Dow 30 Companies/03 \346\226\271\346\263\225.cn.html"
@@ -0,0 +1,95 @@
+
def rebalance(self):
+ # 获得历史股票代码和价格，然后放入元组中
+ history = self.History(self.regression_dates, Resolution.Daily)
+ filter = []
+ for i in self.symbols:
+ filter.append((i,self.get_regression_data(i, history)[0]))
+ # 根据alpha排序筛选
+ filter.sort(key = lambda x : x[1],reverse = True)
+ sorted_symbols = []
+ for i in range(2):
+ sorted_symbols.append(filter[i][0])
+ # 获得所持有股票的代码
+ holding_list = []
+ for i in self.Portfolio:
+ if i.Value.Invested:
+ holding_list.append(i.Value.Symbol)
+ # 如果我们不打算继续持有现有的股份，则将其出售
+ if holding_list:
+ for i in holding_list:
+ if i not in sorted_symbols:
+ self.Liquidate(i)
+ # 做多列表中的两支股票
+ for i in sorted_symbols:
+ self.SetHoldings(i,1)
+
+ We have demonstrated that during a smooth market, the stocks that beat the market last month are likely to beat the market again in the subsequent month. When there is market fluctuation, the significance level of linear regression will reduce and the model performance will decrease. We can understand this by looking at the covariance of the asset(x) and the benchmark (y). As the covariance reduces to zero, the beta will decrease.
+
+ As an experiment, we tested the algorithm on market data from 2015. This was a much more volatile period for the market with a fluctuation that returned a mean close to zero and dropped neaerly 10% from Aug 18th to Aug 25th of that year. The algorithm performed quite poorly in this year with a return rate of -11.58%. The risks associated with this strategy include a high drawdown, lack of hedging and not stop-loss. Since we are using leverage, the risk is increased and it has a margin call in January as a result. We can improve the performance by applying the following techniques:
+
+
+
+
Conduct optimizations: we can implement mean-variance analysis to determine the asset allocation each month and select more stocks to trade. This will lower our risk and manage the portfolio more scientifically.
+
Take beta into consideration: If we want to be more aggressive, we can select targets by a combination of alpha and beta. This means we choose stocks with a high alpha that are more volatile than the market. If we are conservative investors however, we can make the strategy market-neutral, which means the portfolio would not be affected by the market performance. For example, if we long two stocks with beta 1 and -1 respectively at the same position size, our portfolio becomes market-neutral.
+
diff --git a/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/01 Abstract.html b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/01 Abstract.html
new file mode 100755
index 0000000..7850891
--- /dev/null
+++ b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/01 Abstract.html
@@ -0,0 +1,7 @@
+
+ In this tutorial we build a strategy combining momentum and mean reversion for the foreign exchange markets from Alina F. Serban's research which was based on research in the equity market by Ronald J. Balvers and Yangru Wu. Serban creates a momentum factor using returns of the last 3 months, and a mean reversion factor as a deviation from the mean price. Using these factors we use regression to predict the returns of the coming month. We apply the strategy from Serban's paper and update the mean reversion factor for to improve its significance level.
+
+
+
+ In theory when trading foreign exchange the expected return accrued in each currency should be the same when adjusted for exchange rates (uncovered interest parity). This suggests the markets should predominately be mean reverting, however in practice we see short term momentum trends and long term mean reversion. This was phenomenon was first noticed by Chiang and Jiang. We tested the theory on EURUSD, GBPUSD, USDCAD and USDJPY and re-balanced monthly. The model significance level and coefficients are close to those in paper, but the returns and Sharpe Ratios obtained are not as good as what the paper claimed. The algorithm achieved a fairly stable annual return of 11%, 0.8 Sharpe Ratio and 11% drawdown.
+
diff --git a/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/02 Introduction.html b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/02 Introduction.html
new file mode 100755
index 0000000..4a19969
--- /dev/null
+++ b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/02 Introduction.html
@@ -0,0 +1,59 @@
+
+ The strategy is centered on uncovered interest parity (UIP) theory. UIP states that the change in the exchange rate should incorporate any interest rate differentials between the two currencies. By looking for patterns in the deviation from UIP we can potential generate abnormal returns.
+
+
+
Interest Parity Conditions
+
+ UIP states that an investor who borrows money in their home country and lends it in another country with a higher interest rate should expect a zero return due to the changes in exchange rate. In other words:
+
+ Where \(r_t\) is the domestic interest rate, \(r^{i}\) is the foreign interest rate, \(S^{i}\) is the spot exchange rate and \(F^{i}\) is the forward rate. We can also replace F forward rate with expected spot rate:
+
+ Fama and French and Summers constructed a simple model for stock price that is the sum of a random walk and a stationary component - they represent the natural log of the stock price with x. The stationary component represents the temporary swings in stock price (characterized by coefficient \(\delta \)), the parameter \(\mu \) captures the random walk drift component and a coefficient accounts for the momentum effect \(\rho \). Balvers and Wu construct the log of stock prices as:
+
+ Using the equation above Serban adapts it to find the abnormal return in the forex market. The \(\delta \) represents the speed of mean reversion and can differ by country, while the \(\rho \) represents the momentum strength and can vary by country and by lag. The parameter \(\mu \) also varies by country. Accounting for these changes:
+
+ The trading strategy from the paper allows \(\mu \) to change by country, while let \(\rho \) and \(\delta \) stay fixed. By applying Ordinary Least Squared(OLS) regression, the model estimates the return y for each currency. We construct the portfolio by taking a long position on the currency with the highest expected return and taking a short position on the currency with the lowest expected return. We hold these positions for one month, and repeat the process each month. There are two exceptions to this strategy: if all expected returns are positive, we take a long position only, and vice versa.
+ To limit the number of parameters we need to estimate and find a solution easily we only allow \(\mu \) to change by country. According to the paper if we let ρ stay fixed and J =3, we can obtain the highest return for this strategy. If so the equation can be simplified as:
+
+ When applying the above equation, we found that the scale of the mean reversion for each currency are very different, and this difference in scale is large enough to affect the accuracy of our rank. We made an adjustment to standardize the mean-reversion. While calculating \(\mu \) (the mean of the log prices) we also calculated standard deviation σ. In this tutorial we replace \(x-\mu \) with \(\frac{x - \mu}{\sigma } \). This captures the mean reversion factor better than the author's technique.
+
+
+
Data Description
+
+ The paper used monthly exchange rate data for the Canadian Dollar/USD, German Mark/Euro, UK Pound/USD and Japanese Yen/USD, from 1978 to 2008. Due to data availability, we used Euro/USD instead of German Mark/Euro, and the earliest data available starts from 2004. Each time we launch the strategy we use all of the available historical data prior to the start date to build the OLS model and uses that model for the entire backtest. The paper used 1/3 of their data as the training dataset and the rest of the test set. We directly test our model on backtesting, because QuantConnect makes this easier.
+
diff --git a/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/03 Method.html b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/03 Method.html
new file mode 100755
index 0000000..e74071f
--- /dev/null
+++ b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/03 Method.html
@@ -0,0 +1,179 @@
+
+ In order to apply the model, we need to first pull history data to build it. The project can be briefly divided into four parts: the historical data request, model training, prediction and execution.
+
+
+
Step 1: Request Historical Data
+
+ The first function takes two arguments: symbol and number of daily data points requested. This function requests historical QuoteBars and builds it into a pandas DataFrame. For more information about pandas DataFrame, please refer to the help documentation DataFrame. The calculate_return function takes a DataFrame as an argument to calculate the mean and standard deviation of the log prices, and create new columns for the DataFrame (return, reversal factor and momentum) - it prepares the DataFrame for multiple linear regression.
+
+
+
+
def get_history(self,symbol, num):
+ data = {}
+ dates = []
+ history = self.History([symbol], num, Resolution.Daily).loc[symbol]['close'] #request the historical data for a single symbol
+ for time in history.index:
+ t = time.to_pydatetime().date()
+ dates.append(t)
+ dates = pd.to_datetime(dates)
+ df = pd.DataFrame(history)
+ df.reset_index(drop=True)
+ df.index = dates
+ df.columns = ['price']
+ return df
+
+def calculate_return(self,df):
+ #calculate the mean for further use
+ mean = np.mean(df.price)
+ # cauculate the standard deviation
+ sd = np.std(df.price)
+ # pandas method to take the last datapoint of each month.
+ df = df.resample('BM',how = lambda x: x[-1])
+ # the following three lines are for further experiment purpose
+ # df['j1'] = df.price.shift(1) - df.price.shift(2)
+ # df['j2'] = df.price.shift(2) - df.price.shift(3)
+ # df['j3'] = df.price.shift(3) - df.price.shift(4)
+ # take the return as depend variable
+ df['log_return'] = df.price - df.price.shift(1)
+ # calculate the reversal factor
+ df['reversal'] = (df.price.shift(1) - mean)/sd
+ # calculate the momentum factor
+ df['mom'] = df.price.shift(1) - df.price.shift(4)
+ df = df.dropna() #remove nan value
+ return (df,mean,sd)
+
+
+
Step 2: Build Predictive Model
+
+ The concat function requests history and joins the results into a single DataFrame. As \(\mu \) varies by country so we assign the mean and standard deviation to the symbol for each currency for future use. The OLS function takes the resulting DataFrame to conduct an OLS regression. We write it into a function because it's easier to change the formula here if we need.
+
+
+
+
+
def concat(self):
+ # we requested as many daily tradebars as we can
+ his = self.get_history(self.quoted[0].Value,20*365)
+ # get the clean DataFrame for linear regression
+ his = self.calculate_return(his)
+ # add property to the symbol object for further use.
+ self.quoted[0].mean = his[1]
+ self.quoted[0].sd = his[2]
+ df = his[0]
+ # repeat the above procedure for each symbols, and concat the dataframes
+ for i in range(1,len(self.quoted)):
+ his = self.get_history(self.quoted[i].Value,20*365)
+ his = self.calculate_return(his)
+ self.quoted[i].mean = his[1]
+ self.quoted[i].sd = his[2]
+ df = pd.concat([df,his[0]])
+ df = df.sort_index()
+ # remove outliers that outside the 99.9% confidence interval
+ df = df[df.apply(lambda x: np.abs(x - x.mean()) / x.std() < 3).all(axis=1)]
+ return df
+
+def OLS(self,df):
+ res = sm.ols(formula = 'return ~ reversal + mom',data = df).fit()
+ return res
+
+
+
Step 3: Apply Predictive Model
+
+ The predict function uses the history for the last 3 months, merges it into a DataFrame and then calculates the updated factors. Using these updated factors (together with the model we built) we calculate the expected return.
+
+
+
+
def predict(self,symbol):
+ # get current month in string
+ month = str(self.Time).split(' ')[0][5:7]
+ # request the data in the last three months
+ res = self.get_history(symbol.Value,33*3)
+ # pandas method to take the last datapoint of each month
+ res = res.resample('BM',how = lambda x: x[-1])
+ # remove the data points in the current month
+ res = res[res.index.month != int(month)]
+ # calculate the variables
+ res = self.calculate_input(res,symbol.mean,symbol.sd)
+ res = res.ix[0]
+ # take the coefficient. The first one will not be used for sum-product because it's the intercept
+ params = self.formula.params[1:]
+ # calculate the expected return
+ re = sum([a*b for a,b in zip(res[1:],params)]) + self.formula.params[0]
+ return re
+
+def calculate_input(self, df, mean, sd):
+ df['reversal'] = (df.price - mean)/sd
+ df['mom'] = df.price - df.price.shift(3)
+ df = df.dropna()
+ return df
+
+
+
+
+ There are a few points of note:
+
+
+
+
We need historical TradeBars for the last three months. To do this we requested 99 bars and use a pandas DataFrame to extract a data point for the end of each month.
+
We use event schedule to execute the strategy at the first trading day, however, sometimes the first day of the month could be on the 2nd if the 1st falls on a weekend. To fix this we remove the data from the current month, leaving only the last 3 months of data.
+
We start from the second element of res (res[1:]) because res and params are different lengths. This was hard to detect because Python would not throw error when running [a*b for a,b in zip(res,params)] even if the length of the two lists are different.
+
This function also used pandas DataFrame methods extensively. For more information please refer to pandas.
+
+
+
Step 4: Initializing the Model
+
+ In the Initialize function we prepare the data and conduct a linear regression. The class property 'self.formula' is the result of the OLS regression. We will use this object each time we rebalance the portfolio.
+
+
+
+
+
def Initialize(self):
+ self.SetStartDate(2013,6,1)
+ self.SetEndDate(2016,6,1)
+ self.SetCash(10000)
+ self.syls = ['EURUSD','GBPUSD','USDCAD','USDJPY']
+ self.quoted = []
+ for i in range(len(self.syls)):
+ self.quoted.append(self.AddForex(self.syls[i],Resolution.Daily,Market.Oanda).Symbol)
+ df = self.concat()
+ self.Log(str(df))
+ self.formula = self.OLS(df)
+ self.Log(str(self.formula.summary()))
+ self.Log(str(df))
+ self.Log(str(df.describe()))
+ for i in self.quoted:
+ self.Log(str(i.mean) + ' ' + str(i.sd))
+ self.Schedule.On(self.DateRules.MonthStart(), self.TimeRules.At(9,31), Action(self.action))
+
+
+
+
Step 5: Performing Monthly Rebalancing
+
+ Every month we rebalance the portfolio using the Schedule Event helper method. The predicted returns are added to the rank array and then sorted by return. The first element in the list is the best return paired with the associated symbol. When all the expected returns in the rank array are positive we only go long the pair with the highest expected return. When all returns are negative, we only go short the pair with the lowest expected return.
+
+
+
+
+
def action(self):
+ rank = []
+ long_short = []
+ for i in self.quoted:
+ rank.append((i,self.predict(i)))
+# rank the symbols by their expected return
+ rank.sort(key = lambda x: x[1],reverse = True)
+# the first element in long_short is the one with the highest expected return, which we are going to long, and the second one is going to be shorted.
+ long_short.append(rank[0])
+ long_short.append(rank[-1])
+ self.Liquidate()
+
+# the product < 0 means the expected return of the first one is positive and that of the second one is negative--we are going to long and short.
+ if long_short[0][1]*long_short[1][1] < 0:
+ self.SetHoldings(long_short[0][0],1)
+ self.SetHoldings(long_short[1][0],-1)
+ # this means we long only because all of the expected return is positive
+ elif long_short[0][1] > 0 and long_short[1][1] > 0:
+ self.SetHoldings(long_short[0][0],1)
+# short only
+ else:
+ self.SetHoldings(long_short[1][0],-1)
+
+
diff --git a/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/04 Results.html b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/04 Results.html
new file mode 100755
index 0000000..ccd73cf
--- /dev/null
+++ b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/04 Results.html
@@ -0,0 +1,17 @@
+
+ The following regression output is obtained by backtesting the time period from Jun 2013 to Jun 2016.
+ From the regression statistics, the R-squared value is 1.4% which is smaller than the paper value 3.89%.
+ Our momentum coefficient, ρ, is 0.0633 compared to the paper's 0.042. We obtained 1.0350 mean reversion coefficient (1 + 0.0350), and the paper got 0.9859.
+
+
+
+
+
+ From these results we can say the limited sample size does not impair the feasibility of this model. The t-stats of the coefficients are -4.074 and 1.417 for the reversal factor and momentum factor respectively. The p-value of the reversal factor is very small which means this factor has a very high significance level.
+
+
+
Backtest Sensitivity Results
+
+ We performed some rough period sensitivity analysis in different time period(from 2015 to 2018) and summarized the results as the following table:
+
+
diff --git a/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/05 Summary.html b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/05 Summary.html
new file mode 100755
index 0000000..cfa134a
--- /dev/null
+++ b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/05 Summary.html
@@ -0,0 +1,3 @@
+
+ The paper demonstrates there are inefficiencies in the UIP which can be exploited with a hybrid momentum and mean reversion strategy. Although the sample size of the paper is much larger than ours the parameter and significance level of the two models are very close. The strategies we discussed above keep \(\rho \) fixed and only allow \(\mu \) to change by country. If we let \(\rho \) change by lag the significance level of the model might increase, but this could potentially make modeling more difficult by introducing multicollinearity. To test this we wrote this implementation in the algorithm and commented out the lines. If you are interested in exploring this extension to the model you can change these lines to test your strategy.
+
diff --git a/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/06 Algorithm.html b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/06 Algorithm.html
new file mode 100755
index 0000000..9717146
--- /dev/null
+++ b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/06 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/07 References.html b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/07 References.html
new file mode 100644
index 0000000..d1f2696
--- /dev/null
+++ b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/07 References.html
@@ -0,0 +1,18 @@
+
+
+ Alina F. Serban, Combining mean reversion and momentum trading strategies in foreign exchange markets Online Copy
+
+ Ronald J. Balvers, Yangru Wu, Momentum and mean reversion across national equity markets Online Copy
+
+
+ Chiang, T., Jiang, C., 1995. Foreign exchange returns over short and long horizons. International Review of Economics and Finance 4, 267–282. Online Copy
+
+
+ Fama, E., 1984. Forward and spot exchange rates. Journal of Monetary Economics Online Copy 14, 319–338.
+
+
diff --git a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/01 Abstract.html b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/01 Abstract.html
new file mode 100755
index 0000000..d95036a
--- /dev/null
+++ b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/01 Abstract.html
@@ -0,0 +1,7 @@
+
+ In this research, We investigate two pairs trading methods and compare the result. Pairs trading involves in investigating the dependence structure between two highly correlated assets. With the assumption that mean reversion will occur, long or short positions are entered in the opposite direction when there is a price divergence. Typically the asset price distribution is modeled by a Gaussian distribution of return series but the joint normal distribution may fail to catch some key features of the dependence of stock pairs' price like tail dependence. We investigate using copula theory to identify these trading opportunities.
+
+
+
+ We will discuss the basic framework of copula from the mathematical perspective and explain how to apply the approach in pairs trading. The implementation of the algorithm is based on the paper Trading strategies with copulas from Stander Y, Marais D, Botha I(2013). We compare the performance of the copula pairs trading strategy with the co-integration pairs trading method based on the paper Statistical arbitrage trading strategies and high-frequency trading from Hanson T A, Hall J R. (2012). The co-integration technique assumes a co-integration relationship between paired equities to identify profitable trading opportunities. The empirical results suggest that the copula-based strategy is more profitable than the traditional pairs trading techniques.
+
diff --git "a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/01 \346\221\230\350\246\201.cn.html" "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/01 \346\221\230\350\246\201.cn.html"
new file mode 100644
index 0000000..e06b3ac
--- /dev/null
+++ "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/01 \346\221\230\350\246\201.cn.html"
@@ -0,0 +1,7 @@
+
+ 我们将从数学的角度讨论联系的基本框架，并解释如何在配对交易中应用这一方法。算法的实现基于Stander Y, Marais D, BothaI(2013)的论文带有联系函数的交易策略。根据Hanson T A，Hall J R.(2012)的论文统计套利交易策略和高频交易，我们将联系配对交易策略的性能与协整配对交易方法进行了比较。协整法假设配对股票之间存在协整关系，可以识别有利可图的交易机会。实证结果表明，与传统的配对交易策略相比，基于联系的策略更容易获益。
+
diff --git a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/02 Framework of Copula.html b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/02 Framework of Copula.html
new file mode 100755
index 0000000..27a28d6
--- /dev/null
+++ b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/02 Framework of Copula.html
@@ -0,0 +1,71 @@
+
1. Definition
+
+ Given a random vector \(X_1,X_2,...,X_p\), its marginal cumulative distribution functions (CDFs) are \(F_i(x) = P[X_i \leq x]\). By applying the probability integral transform to each component, the marginal distributions of \((U_1,U_2,...,U_p) = (F_1(X_1),F_2(X_2),...,F_p(X_p))\) are uniform (from Wikipedia). Then the copula of \(X_1,X_2,...,X_p\) is defined as the joint cumulative distribution function of \(U_1,U_2,...,U_p\), for which the marginal distribution of each variable U is uniform as \(U(0,1)\).
+
+ Copulas function contains all the dependency characteristics of the marginal distributions and will better describe the linear and non-linear relationship between variables, using probability. They allow the marginal distributions to be modeled independently from each other, and no assumption on the joint behavior of the marginals is required.
+
+
+
2. Bivariate Copulas
+
+ Since this research focuses on bivariate copulas (for pairs trading we have 2 random variables) some probabilistic properties are specified.
+ Let X and Y be two random variables with cumulative probability function \(F_1(X)\) and \(F_2(Y)\). \(U=F_1(X), V=F_2(Y)\) which are uniformly distributed. Then the copula function is \(C(u,v)=P(U\leq u,V\leq v)\). Taking the partial derivative of the copula function over U and V would give the conditional distribution function as follows:
+
+ There are many copula functions that enable us to describe dependence structures between variables, other than the Gaussian assumption. Here we will focus three of these; the Clayton, Gumbel and Frank copula formulas from the Archimedean class.
+ Archimedean copulas are based on the Laplace transforms φ of univariate distribution functions. They are constructed by a particular generator function \(\phi\).
+
+ Genest and MacKay proved that the relation between the copula generator function and Kendall rank correlation tau in the bivariate case can be given by:
+
+ So we can easily estimate the parameter in Archimedean copulas if we know Kendall’s tau rank measure and the generator function. Please refer to step 3 to see the formulas.
+
diff --git "a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/02 \350\201\224\347\263\273\346\241\206\346\236\266.cn.html" "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/02 \350\201\224\347\263\273\346\241\206\346\236\266.cn.html"
new file mode 100644
index 0000000..5fdb07a
--- /dev/null
+++ "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/02 \350\201\224\347\263\273\346\241\206\346\236\266.cn.html"
@@ -0,0 +1,71 @@
+
diff --git a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/03 Part I - Copula Method.html b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/03 Part I - Copula Method.html
new file mode 100755
index 0000000..a16ea55
--- /dev/null
+++ b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/03 Part I - Copula Method.html
@@ -0,0 +1,387 @@
+
+ ETFs have many different stock sectors and asset classes which provide us a wide range of pairs trading candidates. Our data set consists of daily data of the ETFs traded on the NASDAQ or the NYSE.
+
+
+
+ We use the first 3 years of data to choose the best fitting copula and asset pair ("training formation period"). Next, we use a period of more than 9 years from January 2010 to September 2019 ("the trading period"), to execute the strategy. During the trading period we use a rolling 12 month window of data to get the copula parameters ("rolling formation period").
+
+
+
Step 1: Selecting the Paired Stocks
+
+ The general method of pair selection is based on both fundamental and statistical analysis.
+
+
+
1) Assemble a list of potentially related pairs
+
+ Any random pairs could be correlated. It is possible that those variables are not causally related to each other, but because of a spurious relationship due to either coincidence or the presence of a certain third, unseen factor. Thus, it is important for us to start with a list of securities that have something in common. For this demonstration, we choose some of the most liquid ETFs traded on the Nasdaq or the NYSE. The relationship for those potentially related pairs could be due to an index, sector or asset class overlap. e.g. QQQ and XLK are two ETFs which track the market leading indices.
+
+
+
2) Filter the trading pair with statistical correlation
+
+
+ To determine which stock pairs to include in the analysis, correlations between the pre-selected ETF pairs are analyzed. Below are three types of correlation measures we usually use in statistics:
+
\(n\) = number of value in each data set
+\(n_c\) = number of concordant
+\(n_d\) = number of discordant
+\(d_i\) = the difference between the ranks of corresponding values \(x_i\) and \(y_i\)
+
+
+
+
+
+
+ We can get these coefficients in Python using functions from the stats library in SciPy. The correlations have been calculated using daily log stock price returns during the training formation period. We found the 3 correlation techniques give the paired ETFs the same correlation coefficient ranking. The Pearson correlation assumes that both variables should be normally distributed. Thus here we use Kendall rank as the correlation measure and choose the pairs with the highest Kendall rank correlation to implement the pairs trading. We get the daily historical closing price of our ETFs pair by using the History function and converting the prices to a log return series. Let \(P_x\) and \(P_y\) denote the historical stock price series for stock x and stock y. The log returns for the ETFs pair are given by:
+
+
+\[R_x = ln(\frac{P_{x,t}}{P_{x,t-1}}), R_y = ln(\frac{P_{y,t}}{P_{y,t-1}})\] t = 1,2,...,n where n is the number of price data
+
+
+
+
def PairSelection(self, date):
+ '''Selects the pair of stocks with the maximum Kendall tau value.
+ It's called on first day of each month'''
+
+ if date.month == self.month:
+ return Universe.Unchanged
+
+ symbols = [ Symbol.Create(x, SecurityType.Equity, Market.USA)
+ for x in [
+ "QQQ", "XLK",
+ "XME", "EWG",
+ "TNA", "TLT",
+ "FAS", "FAZ",
+ "XLF", "XLU",
+ "EWC", "EWA",
+ "QLD", "QID"
+ ] ]
+
+ logreturns = self._get_historical_returns(symbols, self.lookbackdays)
+
+ tau = 0
+ for i in range(0, len(symbols), 2):
+
+ x = logreturns[str(symbols[i])]
+ y = logreturns[str(symbols[i+1])]
+
+ # Estimate Kendall rank correlation for each pair
+ tau_ = kendalltau(x, y)[0]
+
+ if tau > tau_:
+ continue
+
+ tau = tau_
+ self.pair = symbols[i:i+2]
+
+ return [x.Value for x in self.pair]
+
+
+
+
Step 2: Estimating Marginal Distributions of log-return
+
+ In order to construct the copula, we need to transform the log-return series \(R_x\) and \(R_y\) to two uniformly distributed values u and v. This can be done by estimating the marginal distribution functions of \(R_x\) and \(R_y\) and plugging the return values into a distribution function. As we make no assumptions about the distribution of the two log-return series, here we use the empirical distribution function to approach the marginal distribution \(F_1(R_x)\) and \(F_2(R_y)\). The Python ECDF function from the statsmodel library gives us the Empirical CDF as a step function.
+
+
Step 3: Estimating Copula Parameters
+
+ As discussed above, we estimate the copula parameter theta by the relationship between the copula and the dependence measure Kendall’s tau, for each of the Archimedean copulas.
+
def _parameter(self, family, tau):
+ ''' Estimate the parameters for three kinds of Archimedean copulas
+ according to association between Archimedean copulas and the Kendall rank correlation measure
+ '''
+
+ if family == 'clayton':
+ return 2 * tau / (1 - tau)
+
+ elif family == 'frank':
+
+ '''
+ debye = quad(integrand, sys.float_info.epsilon, theta)[0]/theta is first order Debye function
+ frank_fun is the squared difference
+ Minimize the frank_fun would give the parameter theta for the frank copula
+ '''
+
+ integrand = lambda t: t / (np.exp(t) - 1) # generate the integrand
+ frank_fun = lambda theta: ((tau - 1) / 4.0 - (quad(integrand, sys.float_info.epsilon, theta)[0] / theta - 1) / theta) ** 2
+
+ return minimize(frank_fun, 4, method='BFGS', tol=1e-5).x
+
+ elif family == 'gumbel':
+ return 1 / (1 - tau)
+
+
+
+
Step 4: Selecting the Best Fitting Copula
+
+ Once we get the parameter estimation for the copula functions, we use the AIC criteria to select the copula that provides the best fit in algorithm initialization.
+
+
+\[AIC=-2L(\theta)+2k\]
+
+
+ where \(L(\theta)=\sum_{t=1}^T\log c(u_t,v_t;\theta)\) is the log-likelihood function and k is the number of parameters, here k=1.
+
+
+
+ The density functions of each copula function are as follows:
+
def _lpdf_copula(self, family, theta, u, v):
+ '''Estimate the log probability density function of three kinds of Archimedean copulas
+ '''
+
+ if family == 'clayton':
+ pdf = (theta + 1) * ((u ** (-theta) + v ** (-theta) - 1) ** (-2 - 1 / theta)) * (u ** (-theta - 1) * v ** (-theta - 1))
+
+ elif family == 'frank':
+ num = -theta * (np.exp(-theta) - 1) * (np.exp(-theta * (u + v)))
+ denom = ((np.exp(-theta * u) - 1) * (np.exp(-theta * v) - 1) + (np.exp(-theta) - 1)) ** 2
+ pdf = num / denom
+
+ elif family == 'gumbel':
+ A = (-np.log(u)) ** theta + (-np.log(v)) ** theta
+ c = np.exp(-A ** (1 / theta))
+ pdf = c * (u * v) ** (-1) * (A ** (-2 + 2 / theta)) * ((np.log(u) * np.log(v)) ** (theta - 1)) * (1 + (theta - 1) * A ** (-1 / theta))
+
+ return np.log(pdf)
+
+
+
+
+ The copula that provides the best fit is the one that corresponds to the lowest value of AIC criterion. The chosen pair is "QQQ" & "XLK".
+
+
+
+
Step 5: Generating the Trading Signals
+
+ The copula functions include all the information about the dependence structures of two return series. According to Stander Y, Marais D, Botha I. in Trading strategies with copulas, the fitted copula is used to derive the confidence bands for the conditional marginal distribution function of \(C(v\mid u)\) and \(C(u\mid v)\), that is the mispricing indexes. When the market observations fall outside the confidence band, it is an indication that pairs trading opportunity is available. Here we choose 95% as the upper confidence band, 5% as the lower confidence band as indicated in the paper. The confidence level was selected based on a back-test analysis in the paper that shows using 95% seems to lead to appropriate trading opportunities to be identified.
+
+
+
+ Given current returns \(R_x, R_y\) of stock X and stock Y, we define the "mis-pricing indexes" are:
+
+ For further mathematical proof, please refer to Xie W, Wu Y. Copula-based pairs trading strategy. The conditional probability formulas of bivariate copulas can be derived by taking partial derivatives of copula functions shown in Table 1. The results are as follows:
+
+ After selection of trading pairs and the best-fitted copulas, we take the following steps for trading. Please note we implement the Steps 1, 2, 3 and 4 on the first day of each month using the daily data for the last 12 months, which means our empirical distribution functions and copula parameters theta estimation are updated once a month. In summary each month:
+
+
+
+
During the 12 months' rolling formation period, daily close prices are used to calculate the daily log returns for the pair of ETFs and then compute Kendall's rank correlation.
+
Estimate the marginal distribution functions of log returns of X and Y, which are ecdf_x and ecdf_y separately.
+
Plug Kendall's tau into copula parameter estimation functions to get the value of theta.
+
Run linear regression over the two price series. The coefficient is used to determine how many shares of stock X and Y to buy and sell. For example, if the coefficient is 2, for every X share that is bought or sold, 2 units of Y are sold or bought.
+
+
+
+
+
def SetSignal(self, slice):
+ '''Computes the mispricing indices to generate the trading signals.
+ It's called on first day of each month'''
+
+ if self.Time.month == self.month:
+ return
+
+ ## Compute the best copula
+
+ # Pull historical log returns used to determine copula
+ logreturns = self._get_historical_returns(self.pair, self.numdays)
+ x, y = logreturns[str(self.pair[0])], logreturns[str(self.pair[1])]
+
+ # Convert the two returns series to two uniform values u and v using the empirical distribution functions
+ ecdf_x, ecdf_y = ECDF(x), ECDF(y)
+ u, v = [ecdf_x(a) for a in x], [ecdf_y(a) for a in y]
+
+ # Compute the Akaike Information Criterion (AIC) for different copulas and choose copula with minimum AIC
+ tau = kendalltau(x, y)[0] # estimate Kendall'rank correlation
+ AIC ={} # generate a dict with key being the copula family, value = [theta, AIC]
+
+ for i in ['clayton', 'frank', 'gumbel']:
+ param = self._parameter(i, tau)
+ lpdf = [self._lpdf_copula(i, param, x, y) for (x, y) in zip(u, v)]
+ # Replace nan with zero and inf with finite numbers in lpdf list
+ lpdf = np.nan_to_num(lpdf)
+ loglikelihood = sum(lpdf)
+ AIC[i] = [param, -2 * loglikelihood + 2]
+
+ # Choose the copula with the minimum AIC
+ self.copula = min(AIC.items(), key = lambda x: x[1][1])[0]
+
+ ## Compute the signals
+
+ # Generate the log return series of the selected trading pair
+ logreturns = logreturns.tail(self.lookbackdays)
+ x, y = logreturns[str(self.pair[0])], logreturns[str(self.pair[1])]
+
+ # Estimate Kendall'rank correlation
+ tau = kendalltau(x, y)[0]
+
+ # Estimate the copula parameter: theta
+ self.theta = self._parameter(self.copula, tau)
+
+ # Simulate the empirical distribution function for returns of selected trading pair
+ self.ecdf_x, self.ecdf_y = ECDF(x), ECDF(y)
+
+ # Run linear regression over the two history return series and return the desired trading size ratio
+ self.coef = stats.linregress(x,y).slope
+
+ self.month = self.Time.month
+
+
+
+
+ Finally during the trading period, each day we convert today's returns to u and v by using empirical distribution functions ecdf_x and ecdf_y. After that, two mispricing indexes are calculated every trading day by using the estimated copula C. The algorithm constructs short positions in X and long positions in Y on the days that \(MI_{Y|X}<0.05\) and \(MI_{X|Y}>0.95\). It constructs short position in Y and long positions in X on the days that \(MI_{Y|X}>0.95\) and \(MI_{X|Y}<0.05\).
+
+
+
+
+
def OnData(self, slice):
+ '''Main event handler. Implement trading logic.'''
+
+ self.SetSignal(slice) # only executed at first day of each month
+
+ # Daily rebalance
+ if self.Time.day == self.day:
+ return
+
+ long, short = self.pair[0], self.pair[1]
+
+ # Update current price to trading pair's historical price series
+ for kvp in self.Securities:
+ symbol = kvp.Key
+ if symbol in self.pair:
+ price = kvp.Value.Price
+ self.window[symbol].append(price)
+
+ if len(self.window[long]) < 2 or len(self.window[short]) < 2:
+ return
+
+ # Compute the mispricing indices for u and v by using estimated copula
+ MI_u_v, MI_v_u = self._misprice_index()
+
+ # Placing orders: if long is relatively underpriced, buy the pair
+ if MI_u_v < self.floor_CL and MI_v_u > self.cap_CL:
+
+ self.SetHoldings(short, -self.weight_v, False, f'Coef: {self.coef}')
+ self.SetHoldings(long, self.weight_v * self.coef * self.Portfolio[long].Price / self.Portfolio[short].Price)
+
+ # Placing orders: if short is relatively underpriced, sell the pair
+ elif MI_u_v > self.cap_CL and MI_v_u < self.floor_CL:
+
+ self.SetHoldings(short, self.weight_v, False, f'Coef: {self.coef}')
+ self.SetHoldings(long, -self.weight_v * self.coef * self.Portfolio[long].Price / self.Portfolio[short].Price)
+
+ self.day = self.Time.day
+
+
diff --git "a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/03 \347\254\254I\351\203\250\345\210\206 \342\200\223 \350\201\224\347\263\273\346\263\225.cn.html" "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/03 \347\254\254I\351\203\250\345\210\206 \342\200\223 \350\201\224\347\263\273\346\263\225.cn.html"
new file mode 100644
index 0000000..920e147
--- /dev/null
+++ "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/03 \347\254\254I\351\203\250\345\210\206 \342\200\223 \350\201\224\347\263\273\346\263\225.cn.html"
@@ -0,0 +1,332 @@
+
def _lpdf_copula(self, family, theta, u, v):
+ ''' estimate the log probability density function of three kinds of Archimedean copulas '''
+ if family == 'clayton':
+ pdf = (theta+1) * ((u**(-theta)+v**(-theta)-1)**(-2-1/theta)) * (u**(-theta-1)*v**(-theta-1))
+ elif family == 'frank':
+ num = -theta * (np.exp(-theta)-1) * (np.exp(-theta*(u+v)))
+ denom = ((np.exp(-theta*u)-1) * (np.exp(-theta*v)-1) + (np.exp(-theta)-1))**2
+ pdf = num/denom
+ elif family == 'gumbel':
+ A = (-np.log(u))**theta + (-np.log(v))**theta
+ c = np.exp(-A**(1/theta))
+ pdf = c * (u*v)**(-1) * (A**(-2+2/theta)) * ((np.log(u)*np.log(v))**(theta-1)) * (1+(theta-1)*A**(-1/theta))
+ return np.log(pdf)
+
diff --git a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/04 Part II - Cointegration Method.html b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/04 Part II - Cointegration Method.html
new file mode 100755
index 0000000..d36c895
--- /dev/null
+++ b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/04 Part II - Cointegration Method.html
@@ -0,0 +1,52 @@
+
+ For the cointegration pairs trading method, we choose the same ETF pair "GLD" and "DGL". There is no need to choose a copula function so there is only a 12 month rolling formation period. The trading period is 5 years from January 2011 to May 2017.
+
+
+
Step 1: Generate the Spread Series
+
+ At the start of each month, we generate the log price series of two ETFs with the daily close. Then the spread series is estimated using regression analysis based on log price series data. For equities X and Y, we run linear regression over the log price series and get the coefficient β.
+
+ Using the standard deviation of spread during the rolling formation period, a threshold of one standard deviation
+ is set up for the trading strategy. We enter a trade whenever the spread moves more than one standard deviations
+ away from its mean. Trades are exited when the spread reverts back to the mean trailing spread value. The position
+ sizes are scaled by the coefficient β.
+
price_x = pd.Series([float(i.Close) for i in self.symbols[0].hist_window],
+ index = [i.Time for i in self.symbols[0].hist_window])
+
+price_y = pd.Series([float(i.Close) for i in self.symbols[1].hist_window],
+ index = [i.Time for i in self.symbols[1].hist_window])
+if len(price_x) < 250: return
+spread = self.regr(np.log(price_x), np.log(price_y))
+mean = np.mean(spread)
+std = np.std(spread)
+ratio = floor(self.Portfolio[self.symbols[1]].Price / self.Portfolio[self.symbols[0]].Price)
+if spread[-1] > mean + self.threshold * std:
+ if not self.Portfolio[self.symbols[0]].Quantity > 0 and not self.Portfolio[self.symbols[0]].Quantity < 0:
+ self.Sell(self.symbols[1], 100)
+ self.Buy(self.symbols[0], ratio * 100)
+
+elif spread[-1] < mean - self.threshold * std:
+ if not self.Portfolio[self.symbols[0]].Quantity < 0 and not self.Portfolio[self.symbols[0]].Quantity > 0:
+ self.Sell(self.symbols[0], 100)
+ self.Buy(self.symbols[1], ratio * 100)
+else:
+ self.Liquidate()
+
diff --git a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/05 Summary.html b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/05 Summary.html
new file mode 100755
index 0000000..44ab024
--- /dev/null
+++ b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/05 Summary.html
@@ -0,0 +1,35 @@
+
+ Ultimately pairs trading intends to capture the price divergence of two correlated assets through mean reversion. Our results demonstrate that the copula approach for pairs trading is superior to the conventional cointegration method because it is based on the probability of the dependence structure, vs cointegration which relies on simple linear regression variance from normal pricing. We found through testing the performance of the copula method less sensitive to the starting parameters. Because the cointegration method relies on standard distribution and the ETF pairs had low volatility there were few trading opportunities.
+
+
+
+
+
+
method
+
Transactions
+
Profit
+
Sharpe Ratio
+
Drawdown
+
+
+
+
+
Copula
+
493
+
8.884%
+
0.12
+
26.1%
+
+
+
Cointegration
+
126
+
4.517%
+
0.196
+
3.9%
+
+
+
+
+
+ Generally, ETFs are not very volatile and so mean-reversion did not provide many trading opportunities. There are only 91 trades during 5 years for cointegration method. It is observed that the use of copula in pairs trading provides more trading opportunities as it does not require any rigid assumptions according to Liew R Q, Wu Y. - Pairs trading A copula approach.
+
diff --git "a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/05 \346\200\273\347\273\223.cn.html" "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/05 \346\200\273\347\273\223.cn.html"
new file mode 100644
index 0000000..27fcc84
--- /dev/null
+++ "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/05 \346\200\273\347\273\223.cn.html"
@@ -0,0 +1,35 @@
+
+ 一般情况下，基金的波动性并不大，因此均值回归并不会提供太多交易机会。在5年的时间里，只有39笔交易采用了协整法。根据Liew R Q和Wu Y的《配对交易联系法》，我们发现在配对交易中使用联系法可以提供更多的交易机会，因为它不需要任何严格的假设。
+
diff --git a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/06 Algorithm.html b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/06 Algorithm.html
new file mode 100755
index 0000000..228f289
--- /dev/null
+++ b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/06 Algorithm.html
@@ -0,0 +1,19 @@
+
+ Backtest for copula method
+
+
+
+
+
+
+
+
+
+ Backtest for cointegration method
+
+
+
+
+
+
+
diff --git "a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/06 \347\256\227\346\263\225.cn.html" "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/06 \347\256\227\346\263\225.cn.html"
new file mode 100644
index 0000000..c5d9f52
--- /dev/null
+++ "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/06 \347\256\227\346\263\225.cn.html"
@@ -0,0 +1,19 @@
+
+ 联系法的回溯测试
+
+
+
+
+
+
+
+
+
+ 协整法的回溯测试
+
+
+
+
+
+
+
diff --git a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/07 References.html b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/07 References.html
new file mode 100644
index 0000000..1d7ae89
--- /dev/null
+++ b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/07 References.html
@@ -0,0 +1,32 @@
+
+
+ Stander Y, Marais D, Botha I. Trading strategies with copulas[J]. Journal of Economic and Financial Sciences, 2013, 6(1): 83-107. Online Copy
+
+
+ Hanson T A, Hall J R. Statistical arbitrage trading strategies and high-frequency trading[J]. 2012. Online Copy
+
+
+ Mahfoud M, Michael M. Bivariate Archimedean copulas: an application to two stock market indices[J]. BMI Paper, 2012. Online Copy
+
+
+ Rad H, Low R K Y, Faff R. The profitability of pairs trading strategies: distance, cointegration and copula methods[J]. Quantitative Finance, 2016, 16(10): 1541-1558.online copy
+
+
+ Mahfoud M, Michael M. Bivariate Archimedean copulas: an application to two stock market indices[J]. BMI Paper, 2012. Online Copy
+
+
+ LANDGRAF N, SCHOLTUS K, DIRIS D R B. High-Frequency copula-based pairs trading on US Goldmine Stocks[J]. 2016.
+
+
+ Genest, C. and MacKay, J., 1986, The Joy of Copulas: Bivariate Distributions with Uniform Marginals, The American Statistician, 40, 280-283
+
+
+ Jean Folger, Pairs Trading Example Online Copy
+
+
+ Xie W, Wu Y. Copula-based pairs trading strategy[C] Asian Finance Association (AsFA) 2013 Conference. doi. 2013, 10.
+
+
+ Liew R Q, Wu Y. Pairs trading: A copula approach[J]. Journal of Derivatives & Hedge Funds, 2013, 19(1): 12-30.
+
+
diff --git "a/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/07 \345\217\202\350\200\203\346\226\207\347\214\256.cn.html" "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/07 \345\217\202\350\200\203\346\226\207\347\214\256.cn.html"
new file mode 100644
index 0000000..1d7ae89
--- /dev/null
+++ "b/04 Strategy Library/03 Pairs Trading-Copula vs Cointegration/07 \345\217\202\350\200\203\346\226\207\347\214\256.cn.html"
@@ -0,0 +1,32 @@
+
+
+ Stander Y, Marais D, Botha I. Trading strategies with copulas[J]. Journal of Economic and Financial Sciences, 2013, 6(1): 83-107. Online Copy
+
+
+ Hanson T A, Hall J R. Statistical arbitrage trading strategies and high-frequency trading[J]. 2012. Online Copy
+
+
+ Mahfoud M, Michael M. Bivariate Archimedean copulas: an application to two stock market indices[J]. BMI Paper, 2012. Online Copy
+
+
+ Rad H, Low R K Y, Faff R. The profitability of pairs trading strategies: distance, cointegration and copula methods[J]. Quantitative Finance, 2016, 16(10): 1541-1558.online copy
+
+
+ Mahfoud M, Michael M. Bivariate Archimedean copulas: an application to two stock market indices[J]. BMI Paper, 2012. Online Copy
+
+
+ LANDGRAF N, SCHOLTUS K, DIRIS D R B. High-Frequency copula-based pairs trading on US Goldmine Stocks[J]. 2016.
+
+
+ Genest, C. and MacKay, J., 1986, The Joy of Copulas: Bivariate Distributions with Uniform Marginals, The American Statistician, 40, 280-283
+
+
+ Jean Folger, Pairs Trading Example Online Copy
+
+
+ Xie W, Wu Y. Copula-based pairs trading strategy[C] Asian Finance Association (AsFA) 2013 Conference. doi. 2013, 10.
+
+
+ Liew R Q, Wu Y. Pairs trading: A copula approach[J]. Journal of Derivatives & Hedge Funds, 2013, 19(1): 12-30.
+
+
diff --git a/04 Strategy Library/04 The Dynamic Breakout II Strategy/01 Abstract.html b/04 Strategy Library/04 The Dynamic Breakout II Strategy/01 Abstract.html
new file mode 100755
index 0000000..516dc8f
--- /dev/null
+++ b/04 Strategy Library/04 The Dynamic Breakout II Strategy/01 Abstract.html
@@ -0,0 +1,13 @@
+
+ In this tutorial we will take a close look at the Dynamic Breakout II strategy based on the book Building Winning Trading Systems.
+
+
+ First we decide the look-back period based on the change rate of volatility, then we make trading decisions based on the highest high and lowest low from the look back period as well as a Bollinger Bands indicator. It is an auto adaptive trading system that can adjust its buy and sell rules depending on the performance of these rules in the past. In addition to Forex markets it is widely used in future and equity markets. You can refer to this video to learn more about dynamic break out II.
+
+
+
+ The original Dynamic Break Out system was developed by George Pruitt for Futures Magazine in 1996. The logic behind the dynamic breakout system is that the volatility component changes the lookback period, then the enter and exit points are decided by the highest high and lowest low price over the lookback period. The newer version of the Dynamic Break Out is just like the original, except we introduce the Bollinger Band and adjust the number of look back days using the market volatility, so different market conditions perform better with different parameters. In addition, the stop loss signal is fixed in version one, but in version two the liquidate point is based on the moving average indicator and the length of moving average is dynamically changed with the look-back period.
+
+
+ We backtested the strategy on EURUSD and GBPUSD over 6 years period. The result suggests a drawdown of 20% and the strategy caught the market turning points. It is especially profitable in a trending market.
+
diff --git a/04 Strategy Library/04 The Dynamic Breakout II Strategy/02 Method.html b/04 Strategy Library/04 The Dynamic Breakout II Strategy/02 Method.html
new file mode 100755
index 0000000..9c029fb
--- /dev/null
+++ b/04 Strategy Library/04 The Dynamic Breakout II Strategy/02 Method.html
@@ -0,0 +1,57 @@
+
Step 1: Determine the look back periods
+
+
+ The lookback period is the number of bars back from the most recent bar that the price or indicator looks at to make the momentum calculations.
+ To start the look back period is set to 20 days to determine its buy and sell levels. We change the number of look back days in proportion to changes in market volatility. Through this method the number of look back days changes on a daily basis. At the end of each day, the current market volatility is calculated by the standard deviation of the past 30 day's closing prices.
+
+
+
+
close = self.History(self.syl, 31, Resolution.Daily)['close']
+ todayvol = np.std(close[1:self.numdays+1])
+ yesterdayvol = np.std(close[0:self.numdays])
+ deltavol = (todayvol - yesterdayvol) / todayvol
+ self.numdays = round(self.numdays * (1 + deltavol)) # the number of days must be integer
+
+
+
+
+ Though the look back days are dynamic, it needs to be restricted within an acceptable range of 20 to 60.
+
+
+
Step 2: Choose the algorithm buy/sell point
+
+
+ For a buy setup, the close price of the previous day must be above the upper Bollinger Band. In addition the ask price must be above the highest high of the most recent N days. Where N is the look back days from Step-1.
+ For a sell setup, the close price of previous day must be below the lower Bollinger Band and the ask price must be below the lowest low of the most recent N days. The length of the Bollinger Band calculation is the same number of look back days that is generated by Step-1.
+
+
+ Bollinger Band is a popular technical indicator. k is a constant. Here we choose k=2.
+
+\[ Upper Band = moving\ average + k\times standard\ deviation \]
+
+\[ Lower Band = moving\ average - k\times standard\ deviation \]
+
+ QuantConnect provides more than 100 technical indicators for you to use in your algorithm. These are provided as class objects in Python. A full list of the indicators and their properties can be found in the reference table of the documentation page.
+
+ The exit signal for an existing holding is determined by calculating a simple moving average of closing prices for the past look back days. That is to say, we liquidate a long position if the current price is lower than the moving average of the close price over the look back period, and vice versa for selling a short position.
+
diff --git a/04 Strategy Library/04 The Dynamic Breakout II Strategy/03 Conclusion.html b/04 Strategy Library/04 The Dynamic Breakout II Strategy/03 Conclusion.html
new file mode 100755
index 0000000..ca4ed1c
--- /dev/null
+++ b/04 Strategy Library/04 The Dynamic Breakout II Strategy/03 Conclusion.html
@@ -0,0 +1,10 @@
+
+ For six years backtesting of EURUSD, the overall statistics show an annual rate of return of 2.3% and with a Sharpe Ratio of 0.31. EURUSD has a significant uptrend from 2010 to 2012. This momentum strategy outperforms the market and seems to be profitable from 2010 to 2014. The maximum drawdown occurs in May 2015 to December 2015 and is roughly 14%. From our results we find the strategy works best in an trending forex market.
+
+
+ In contrast, GBPUSD is pretty volatile during the tested period from 2010 to 2016. Our testing demonstrated a negative annual rate of return with a drawdown of approximately 19%.
+ When the volatility decreases, the price tends to continue following the current trend. Volatility causes the the look back days to decrease when computing the bollinger bands, making it easier to enter a trade. If the market volatility increases we increase the look back days in order to filter the fake signals, making it harder to enter a trade.
+
+
+ Here we use the standard deviation of price as a measure of market volatility. To improve the model we could choose other measures of volatility like standard deviation of logarithm return series or other stochastic volatility measures.
+
diff --git a/04 Strategy Library/04 The Dynamic Breakout II Strategy/04 Algorithm.html b/04 Strategy Library/04 The Dynamic Breakout II Strategy/04 Algorithm.html
new file mode 100755
index 0000000..3358861
--- /dev/null
+++ b/04 Strategy Library/04 The Dynamic Breakout II Strategy/04 Algorithm.html
@@ -0,0 +1,18 @@
+
+ Backtest for EURUSD
+
+
+
+
+
+
+
+
+ Backtest for GBPUSD
+
+
+
+
+
+
+
diff --git a/04 Strategy Library/04 The Dynamic Breakout II Strategy/05 References.html b/04 Strategy Library/04 The Dynamic Breakout II Strategy/05 References.html
new file mode 100644
index 0000000..789d29f
--- /dev/null
+++ b/04 Strategy Library/04 The Dynamic Breakout II Strategy/05 References.html
@@ -0,0 +1,9 @@
+
+
+ George Pruitt, John R. Hill, Michael Russak (September 2012). Building Winning Trading Systems, page 126, Online Copy
+
+
+ Robert C. Miner(October 20, 2008). High Probability Trading Strategies: Entry to Exit Tactics for the Forex, Futures, and Stock Markets, page 37, Online Copy
+
+ The Dual Thrust trading algorithm is a famous strategy developed by Michael Chalek. It has been commonly used in futures, forex and equity markets. The idea of Dual Thrust is similar to a typical breakout system, however dual thrust uses the historical price to construct update the look back period - theoretically making it more stable in any given period.
+
+
+ In this tutorial we give a brief introduction to the strategy and show how to implement this algorithm on QuantConnect. After pulling in the historical price of the chosen stock, the range is calculated based on the close, high and low over the most recent N-days. A position is opened when the market moves a certain range from the opening price. We tested the strategy on individual stocks under two market states: a trending market and range bound market. The results suggest this momentum trading system works better in trending market but will trigger some fake buy and sell signals in much more volatile market. Under the range bound market, we can adjust the parameters to get better return. As a comparison of individual stocks, we also implemented the strategy on SPY. The result suggested that the strategy beat the market.
+
+ Firstly we need to initialize the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must be initialized.
+
+ Although this is an intraday strategy, we still want to test the strategy within a long period not just within one day. The scheduling methods sets up an event to fire at a specific date or time and will execute the scheduled event function.
+
+ Here Schedule.On(DateRules, TimeRules, Action()) will trigger every trading day for our stock, at market open. Events are scheduled using date and time rules. Date rules specify on what dates and event will fire. Time rules specify at what time on those dates the event will fire. Inside of the scheduled function, we can pull the recent historical data and current open price each trading day.
+
+
+
Step 2: Implementation of algorithm
+
+
+
+ In order to calculate the range, each trading day we need the close, high and low price data over the most recent N days. In addition, the open price of the current day is required in order to generate the signals. QuantConnect provides History(Symbol, TimeSpan, Resolution) method to get the history data like open, close, high and low for all configured securities over the requested N-days time span. Then the range is calculated by \[range = max(HH-LC, HC-LL)\]. In this implementation we choose N=4. It is less than one week and the range would reflect the recent price change.
+
+ The long signal is calculated by \[cap = open + K_1 \times Range\]. The short signal is calculated by \[floor = open – K_2 \times Range\] where K1 and K2 are the parameters. When K1 is greater than K2, it is much easier to trigger the long signal and vice versa. For demonstration, here we choose K1 = K2 = 0.5. In live trading, we can still use historical data to optimize those parameters or adjust the parameters according to the market trend. K1 should be small than k2 if you are bullish on the market and k1 should be much bigger if you are bearish on the market.
+
+
+
+
+
+ This system is a reversal system, so if the investor holds a short position when the price breaks the cap line, the short margin should be liquidated first before opening a long position. If the investor holds a long position when the price breaks the floor line, the long margin should be liquidated first before opening a new short position.
+
+ We tested this strategy on the S&P 500 ETF SPY from 2004 to 2017. During the backtesting period, SPY resulted in a Sharpe Ratio of -0.37 and the drawdown is 65.7%. This is just a basic implementation and the parameters K1 and K2 are fixed. The strategy can be further extended to Futures and Forex markets. When K1 is smaller than K2, buy signals are prone to trigger and vice versa. To improve the model we can apply technical indicators to judge the trend of price and adjust the value of two parameters dynamically and apply risk control in the position sizing.
+
+
diff --git a/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/01 Abstract.html b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/01 Abstract.html
new file mode 100755
index 0000000..1a715ed
--- /dev/null
+++ b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/01 Abstract.html
@@ -0,0 +1,10 @@
+
+ In this tutorial we use regression to predict the return from the stock market and compare it to the short-term U.S. T-bill rate. It is based on the paper?"Striking Oil: Another Puzzle?". by Gerben, Ben and Benjamin (2007).
+ If the predicted return is larger than the risk-free rate, the portfolio is fully invested in stock; if the predicted return is lower than the risk-free rate, the portfolio is invested in short-term U.S T-bills. The backtesting period starts in 1980 and is divided into an in-sample period where regression analysis is made and an out?of sample period where the regression result is embedded "statically" into the strategy.
+
+
+ In our implementation of the strategy we adapt the method of the original paper to make it more applicable to the current market. We have set our backtesting period to be from 2010 to 2017 and we refresh our regression analysis each month to form a rolling dynamic projection. This is because?empirical evidence shows?us the correlation between oil and stocks is not as strong as in the 1980's. We use?the price of S&P GSCI? Crude Oil Total Return Index ETNs to represent spot oil price, and import T-bill data from Quandl by defining a custom class.?We use the "Schedule" API to trigger an event every month automatically?and the "History" function to retrieve data for regression analysis.
+
+
+ Our analysis shows this strategy under performs the market in recent years. In the 9 year analysis period the algorithm was mostly long the S&P500 index and only 9 trades were performed as the markets were strongly bullish. The trades could potentially simply be due to the weakening of the relationship between stocks and oil.
+
diff --git a/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/02 Background.html b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/02 Background.html
new file mode 100755
index 0000000..368ea3b
--- /dev/null
+++ b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/02 Background.html
@@ -0,0 +1,15 @@
+
+ We assume the predicted return of the stock is proportional to the return of oil. This can be represented by the regression equation:
+
+
+\[r^{stock}_t=a_0+a_1r^{oil}_{t-1}+e_t\]
+
+
+ with
+
+
+\[e_t=r^{stock}_t-E_{t-1}[r^{stock}_t]\].
+
+
+ The independent variable is the return of the oil and the dependent variable is the return of the stock. We use the monthly returns over a regression period of 2 years, giving us 22 observations to regress.?Every month regression analysis is conducted, and we use the estimated coefficient from the regression to compute the expected stock return with the given return of oil.
+
diff --git a/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/03 Method.html b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/03 Method.html
new file mode 100755
index 0000000..46a7747
--- /dev/null
+++ b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/03 Method.html
@@ -0,0 +1,109 @@
+
+ The algorithm implementation consists of mainly three parts: Defining the custom imported data, initialization of the strategy parameters, and monthly re-balancing of the portfolio.
+
+
+
Step 1: Defining Custom Imported Data
+
+ We import T-Bill data from Quandl - a marketplace for financial, economic and alternative data. This requires defining a small class that tells QuantConnect how to interpret?the Quandl data.
+
+
+
+
+
class TBill(PythonData):
+ def GetSource(self, config, date, isLiveMode):
+ return SubscriptionDataSource("https://www.quandl.com/api/v3/datasets/USTREASURY/BILLRATES.csv?api_key=XXXXXXXXX&order=asc", SubscriptionTransportMedium.RemoteFile)
+ def Reader(self, config, line, date, isLiveMode):
+ tbill = TBill()
+ tbill.Symbol = config.Symbol
+ # Example Line Format:
+ # Date 4 Wk Bank Discount Rate
+ # 2017-06-01 0.8
+ if not (line.strip() and line[0].isdigit()): return None
+ try:
+ data = line.split(',')
+ value = float(data[1])*0.01
+ value = decimal.Decimal(value)
+ if value == 0: return None
+ tbill.Time = datetime.strptime(data[0], "%Y-%m-%d")
+ tbill.Value = value
+ tbill["Close"] = float(value)
+ return tbill;
+ except ValueError:
+ return None
+
+
+
+ We first provide the source of the data as a URL to Quandl's API in the GetSource method. We need to make sure the data is?organized in ascending order which is done with the?"order=asc" parameter.?You need to substitute the API key in the URL for your personal Quandl API token.
+ The Reader method parses a line of the data file. When using custom data you need to minimally set?the Time property?and Value property. In this example we find the value property from the headings in the spreadsheet is the second column and we reference it with data[1]. We set the Close property to the same value.
+
+
+
+ In our "Initialize" function we use the following commands to add the custom data into our portfolio.
+
+ In our?"Initialize" function we set the cash amount, start-end date as well as other parameters that are specific to this strategy.?We set two parameters for the regression analysis period:
+
+
+
+
+
self.regPeriod = 24
+self.daysInMonth = 21
+
+
+
+ The variable "regPeriod" indicates how many months we are going to take into consideration in our regression analysis. We assume 21 days per month and request a historical period of approximately 2 years. We jump back in steps of 21 days and assume it is roughly 1 month of return.
+ We need to set up "Schedule" function in "Initialize" so as to trigger the monthly re-balancing function every month.
+
+ Every month we reconstruct the regression analysis to determine whether to be 100% long stocks or T-Bill contracts. We perform this re-balancing in the MonthlyReg function at the start of each month.?We use the History function to retrieve historical data for oil and stocks?and then divide the T-Bill rate by 12 to make it comparable to the monthly expected return of stocks.
+
+ Finally, we compare the expected return of stocks with risk-free rate. If the former is larger than the latter, we invest fully in stocks; otherwise we liquidate our holdings. Because we cannot purchase T-Bill contracts the performance is likely slightly underestimated.
+
+
+
+
+
if yPred > rf:
+ self.SetHoldings(self.spy, 1)
+else:
+ self.Liquidate(self.spy)
+
diff --git a/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/04 Summary.html b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/04 Summary.html
new file mode 100755
index 0000000..5751224
--- /dev/null
+++ b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/04 Summary.html
@@ -0,0 +1,7 @@
+
+ We backtested this strategy over the period beginning in 2010 and ending in 2017. It has a sharpe ratio of 0.72 beating the benchmark's 0.6 over a similar period.
+ Although the annual return closely matches that of the paper,?it is largely a coincidence of the strong bull market in recent years.?If we look at the monthly regression results, we could find that in most cases, the p-value is not small enough to reject the null hypothesis that there is no correlation between oil and stocks. So the investment decisions based on the insignificant statistical results are almost meaningless. The performance of this strategy cannot effectively beat the benchmark, mostly?due to?the weakened correlation between oil and stocks.
+
+
+ Further research and backtesting could be conducted on assets other than oil that have a stronger relationship with stocks.
+
diff --git a/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/05 Algorithm.html b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/05 Algorithm.html
new file mode 100755
index 0000000..0115518
--- /dev/null
+++ b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/05 Algorithm.html
@@ -0,0 +1,9 @@
+
+ Strategy code, as well as backtesting result, is attached below. We also put other choices of implementation in the comments.
+
+
+
+
+
+
+
diff --git a/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/06 References.html b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/06 References.html
new file mode 100644
index 0000000..2ce7aae
--- /dev/null
+++ b/04 Strategy Library/06 Can Crude Oil Predict Equity Returns/06 References.html
@@ -0,0 +1,5 @@
+
+
+
diff --git a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/01 Abstract.html b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/01 Abstract.html
new file mode 100755
index 0000000..83bdc3c
--- /dev/null
+++ b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/01 Abstract.html
@@ -0,0 +1,11 @@
+
+ In this tutorial we implement a high frequency and dynamic pairs trading strategy based on market-neutral statistical arbitrage strategy using a two-stage correlation and cointegration approach. This strategy is based on George J. Miao's work. We applied this trading strategy to the U.S. bank sector stocks, backtested this strategy with 10-minute stock data from 2012 to 2013. Our trading strategy yields a compounding annual return up to 29.4% and a 0.968 sharpe ratio.
+
+
+
+ This strategy is especially profitable when the market is performing poorly. The profit is resulted from mispricing, and mispricings are likely to happen when the market goes down or volatility increases.
+
+
+
+ To explore this strategy further, we design this strategy to be flexible. We can change the data resolution into 5 minutes, 10 minutes or even 30 minutes by simply changing a parameter. It's also essential to choose optimized entering, closing and stop loss threshold. Everyone can has his/her own version of this strategy.
+
diff --git "a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/01 \346\221\230\350\246\201.cn.html" "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/01 \346\221\230\350\246\201.cn.html"
new file mode 100644
index 0000000..9aa9136
--- /dev/null
+++ "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/01 \346\221\230\350\246\201.cn.html"
@@ -0,0 +1,11 @@
+
+ 在本教程中，我们使用两阶段关联法和协整法，基于市场中性统计套利策略实施了高频动态配对交易策略。这种策略基于George J. Miao的研究。我们将这一交易策略应用于美国银行板块股票，使用2012年至2013年的10分钟股票数据对这一策略进行了回溯测试。我们交易策略所产生的复合年回报率高达29.4%，夏普指数为0.968。
+
diff --git a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/02 Introduction.html b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/02 Introduction.html
new file mode 100755
index 0000000..85d9f93
--- /dev/null
+++ b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/02 Introduction.html
@@ -0,0 +1,117 @@
+
+ High Frequency Trading(HFT) is a type of quantitative trading characterized by short holding period and the use of sophisticated computer method to trade securities rapidly. It aims to capture small profit on every short-term trade.(Cartea & Penalva, 2012).
+ Statistical arbitrage is a situation where there is a statistical mispricing of one or more assets based on the expected values of these assets. When a profit situation takes place from pricing inefficiencies between securities, traders can identify the statistical arbitrage situation through mathematical models. Statistical arbitrage depends heavily on the ability of market prices to return to a historical or predicted mean. The Law of One Price(LOP) lays the foundation for this assumption. LOP states that two stocks with the same payoff in every state of nature must have the same current value (Gatev, Goetzmann, & Rouwenhorst, 2006) Thus, two stock prices spread between close substitute assets should have a stable, long-term equilibrium price over time.
+
+
+
Data Description
+
+ In order to have more pairs with high correlation, we select stocks in a specific industry. Economically, we prefer traditional sectors because the companies in these sector are more likely to be close substitutes. If we selected N stocks, the number of pairs can be calculated by \(\textrm{C}_{n}^{2} = \frac{n*(n-1)}{2}\). In the demonstrated strategy we used 80 stocks, so we have 3160 pairs in total. We used minute data and aggregate them into lower resolution, thus 1 minute is the highest resolution for this strategy.
+
+
+
Correlation Approach
+
+ Correlations measure the relationship between two stocks that have price trends. They tend to move together, and thus are correlated. Correlation filter is the first step to screen the candidate pairs.
+ Consider two stocks A and B, a correlation coefficient between the stocks was a statistic that provide a measure of how the two stocks A and B were associated. The correlation coefficient \(\rho\) of stock A and stock B was obtained by
+
+ Where \(\bar{A}\) and \(\bar{B}\) are the mean prices of stock A and stock B respectively, N denoted a trading data range. \(\rho\) is in the range of [-1,1]. The more positive \(\rho\) is, the more positive the association of stock A and stock B is.
+
+
+
+ However, the pairs trading based on a correlation approach alone would have a disadvantage of instabilities over time. Correlation coefficients do not necessarily imply mean-reversion between the prices of the two stock pairs. In order to overcome the above issue, a cointegration approach was further used as the second-step of the selection process for the pairs.
+
+
+
Cointegration Approach
+
+ The Cointegration concept, an innovative mathematical model in economics developed by Nobel laureates Engle and Granger. Cointegration states that, in some instances, despite two given non-stationary time series, a specific linear combination of the two time series is actually stationary. In other word, the two time series move together in a lockstep pattern.
+
+
+
+ The definition of cointegration is the following: assume that \(x_t\) and \(y_t\) are two time series that were non-stationary. If there exists a parameter \(\gamma\) such that the following equation:
+
+
+\[z_t = y_t - \gamma x_t\]
+
+
+ It is a stationary process, then \(x_t\) and \(y_t\) would be cointegrated. This process is a powerful tool for investigating common asset trends in multivariate time series.
+
+
+ In our case, Let \(p_t^A\) and \(p_t^B\) be the prices of two stocks A and B respectively. If it is assumed that {\({p_t^A, p_t^B}\)} is individually non-stationary, there exists the parameter \(\gamma\) such that the following equation was a stationary process
+
+ where \(\mu\) is a mean of the cointegration model. \(\epsilon_t\) is a stationary, mean-revering process and was referred to as a cointegration residual. The parameter \(\gamma\) is known as a cointegration coefficient. The equation above represents a model of cointegrated pair for stocks A and B.
+
+
+
+ It's essential to understand how the conitegration residual together with the cointegration coefficient determines our trading direction. If \(\epsilon\) is positive, in a given confidence interval, this is a signal that stock A is relatively overpriced and stock B is relatively underpriced, and we are going to long B and short A; If If \(\epsilon\) is negative, we are going to long A and short B.
+
+
+
Cointegration Verification(optional reading part)
+
+ In the Engle-Granger method(Engle & Granger, 1987), we first set up a cointegration regression between stock A and stock B as stated in the equation above, and then estimate the regression parameters \(\mu\) and \(\gamma\) using an ordinary least squares(OLS). Subsequently, we tested the regression residual \(epsilon_t\) to determine whether or not it was stationary.
+
+
+
+ The most popular stationary test in the area of cointegration, the Augmented Dickey Fuller (ADF) test, was used on the regression residual \(\epsilon\) to determine whether it had a unit root.
+
+
+ Testing for the presence of the unit root in the regression residual using the ADF test was given by
+
+ where \(\alpha\) is a constant, \(\beta\) is the coefficient on a time trend, p is the lag of order of the autoregressive process, \(\mu_t\) is an error term and serially uncorrelated.
+
+
+
+ The number of lag order p in the equation is usually unknown and therefore had to be estimated. To determine the number of lag p, the information criteria for lag order selection was used. Here we choose Bayesian Information Criterion(BIC)
+
+ The unit root test for the regression residual \(\epsilon\) using the ADF test was then carried out under the null hypothesis \(H_0 : \gamma = 0\) versus the alternative hypothesis \(H_1 : \gamma < 0\). A statistical value of the ADF test was obtained by
+
+
+\[ADF test = \frac{\hat{\gamma }}{SE(\hat{\gamma })}\]
+
+
+ The test result in the equation above is compared with the critical value of the ADF test. If the test result is less than the critical value, then the null hypothesis is rejected. This means the regression residual \(\epsilon\) is stationary. Thus, the two stock prices {\({p_t^A, p_t^B}\)} are cointegrated.
+
+
Pairs Trading Strategy
+
+ The pairs trading strategy uses trading signals based on the regression residual \(\epsilon\) and were modeled as a mean-reverting process.
+
+
+
+ In order to select potential stocks for pairs trading, the two-stage correlation and cointegration approach was used. The first step is to identify potential stock pairs from the same sector, where the stock pairs are selected with correlation coefficient of at least 0.9 using the correlation approach. The second step is to check the the cointegration of the pairs passed the correlation test. If the test value of cointegration is equal or less than -3.34, which is the critical value at a 95% confidence lever, the null hypothesis \(H_0 : \gamma = 0\) is rejected, thus the residual \(\epsilon\) is stationary, and the pair passed the cointegration test. The third step is to rank all of the stock pairs that passed the two-stage test according to their cointegration test values. The smaller the cointegration test value is, the higher rank the stock pair is assigned to. Financial selection of the stock pairs from the top rank is used for pairs trading.
+
+
+ The final step of the strategy is to define trading rules. To open a pairs trading, the regression residual \(\epsilon_t\) must cross over and down the positive \(\sigma\) standard deviation above the mean or cross down and over the negative \(\sigma\) standard deviation below the mean. If the residual is positive, we short stock B and long stock A; if the residual is negative, we short Stock A and long Stock B. When the regression residual (\epsilon_t\) returned to a certain level, the pairs trading is closed. Further more, in order to prevent the loss of too much on a single pairs trading, a stop-loss is used to close the pairs when the residual hit \(4\epsilon\) positive or negative standard deviation.
+
+
+
+ In the training period, each of the training data contained a 3-month period, which is a dynamic rolling window size. Immediately after the training period, we begin our one-month trading period, and the dynamic rolling window automatically shift ahead to record the new prices of the stocks in each pair. After the first trading period, we use the updated stock prices to select our pairs for trading again, and begin another trading period.
+
+
+
Parameter Adjustment
+
+ The performance of the strategy is sensitive to the parameters. There are mainly four parameter to adjust: Opening Threshold, Closing Threshold, Stop-loss Threshold and data resolution.
+
+
+ Opening threshold represents by how many times the residual \(\epsilon\) exceed the standard deviation, which is calculated by \(\frac{\epsilon - \bar{\epsilon}}{\sigma}\). By default we set it to 2.32 and -2.32, which is the critical value for 99% confidence interval if we assume the residual follows normal distribution.
+ Closing threshold is calculated in the same way as opening threshold, we set it to 0.5 by default to close early to prevent further divergence.
+
+
+ Stop-loss Threshold is set to 4.5. This depends on the level of mispricing we can bear. The higher degree our tolerance to risk is, the higher we can set this parameter. However, if we set this number too low, we may have too many pairs closed before reversion to stop loss.
+
diff --git "a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/02 \347\256\200\344\273\213.cn.html" "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/02 \347\256\200\344\273\213.cn.html"
new file mode 100644
index 0000000..f0b6f74
--- /dev/null
+++ "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/02 \347\256\200\344\273\213.cn.html"
@@ -0,0 +1,115 @@
+
diff --git a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/03 Method.html b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/03 Method.html
new file mode 100755
index 0000000..0b619ee
--- /dev/null
+++ b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/03 Method.html
@@ -0,0 +1,252 @@
+
+ In this trading strategy we would define a class named 'pairs'. We manage pairs instead of stocks directly to make it's more convenient for us to calculate correlation and cointegration, update stock prices in the pair and trade on the selected pairs.
+
+
+
Step 1: Pairs Class Definition
+
+ The pairs is made up of two stocks, stock A and stock B. This class has several properties. The basic properties include symbols of stock A and stock B, the pandas DataFrame that contains time and prices of the two stocks, the current error, the error of the last datapoint, and the lists to record stock prices for update purpose. Instead of updating the DataFrame every 5 minutes, we record the prices in lists to update the DataFrame monthly. This would speed up the algorithm at least 10 times because manipulating DataFrame is very time consuming. The cor_update method is used every month to update the correlation between the two stocks in this pair. The cointegration_test method is also used monthly to do OLS regression, conduct ADF test, and calculate the mean and standard deviation of the residual. The method also assign these calculated values as properties to the pair object.
+
+
+
+
+
class pairs(object):
+ def __init__(self, a, b):
+ self.a = a
+ self.b = b
+ self.name = str(a) + ':' + str(b)
+ self.df = pd.concat([a.df,b.df],axis = 1).dropna()
+ # The number of bars in the rolling window would be determined by the resolution, so we get this
+ information from the shape of the DataFrame here.
+ self.num_bar = self.df.shape[0]
+ self.cor = self.df.corr().ix[0][1]
+ # Set the initial signals to be 0
+ self.error = 0
+ self.last_error = 0
+ self.a_price = []
+ self.a_date = []
+ self.b_price = []
+ self.b_date = []
+
+ def cor_update(self):
+ self.cor = self.df.corr().ix[0][1]
+
+ def cointegration_test(self):
+ self.model = sm.ols(formula = '%s ~ %s'%(str(self.a),str(self.b)), data = self.df).fit()
+ # This line conduct ADF test on the residual. ts.adfuller() returns a tuple and the first element in
+ the tuple is the test value.
+ self.adf = ts.adfuller(self.model.resid,autolag = 'BIC')[0]
+ self.mean_error = np.mean(self.model.resid)
+ self.sd = np.std(self.model.resid)
+
+ def price_record(self,data_a,data_b):
+ self.a_price.append(float(data_a.Close))
+ self.a_date.append(data_a.EndTime)
+ self.b_price.append(float(data_b.Close))
+ self.b_date.append(data_b.EndTime)
+
+ def df_update(self):
+ new_df = pd.DataFrame({str(self.a):self.a_price,str(self.b):self.b_price},index =
+ [self.a_date]).dropna()
+ self.df = pd.concat([self.df,new_df])
+ self.df = self.df.tail(self.num_bar)
+ # after updating the DataFrame, we empty the lists for the incoming data
+ for list in [self.a_price,self.a_date,self.b_price,self.b_date]:
+ list = []
+
+
+
Step 2: Generate and Clean Pairs
+
+ The function generate_pairs generates pairs using the stock symbols. self.pair_threshold and self.pair_num are pre-determined to control the number of candidate pairs. The pairs in self.pair_list would be kept and updated throughout our backtesting period. we set self.pair_threshold to 0.88 and self.pair_num to 120 to limit the number of pairs in the list. If we put too many pairs in the list, the backtesting would be too time consuming.
+ The function pair_clean is called after the two-stage screen. If the first pair contains stock A and stock B, and the second pair contains stock B and stock C, we would remove the second pair because the overlapped signal would disturb the balance of our portfolio.
+
+
+
+
+
def generate_pairs(self):
+ for i in range(len(self.symbols)):
+ for j in range(i+1,len(self.symbols)):
+ self.pair_list.append(pairs(self.symbols[i],self.symbols[j]))
+
+ self.pair_list = [x for x in self.pair_list if x.cor > self.pair_threshold]
+
+ self.pair_list.sort(key = lambda x: x.cor, reverse = True)
+
+ if len(self.pair_list) > self.pair_num:
+ self.pair_list = self.pair_list[:self.pair_num]
+
+def pair_clean(self,list):
+ l = []
+ l.append(list[0])
+ for i in list:
+ symbols = [x.a for x in l] + [x.b for x in l]
+ if i.a not in symbols and i.b not in symbols:
+ l.append(i)
+ else:
+ pass
+ return l
+
+
+
+
Step 3: Warming up Period
+
+ This part is under the OnData step. We set self.num_bar equals to the number of TradeBar in three months, which is determined by the resolution. During this period we fill the stock prices in lists, and assign each stock's price list to the symbol as a property. We would also remove the symbol from the symbol list if it has no data.
+
+
+
+
+
if len(self.symbols[0].prices) < self.num_bar:
+ for symbol in self.symbols:
+ if data.ContainsKey(i) is True:
+ symbol.prices.append(float(data[symbol].Close))
+ symbol.dates.append(data[symbol].EndTime)
+ else:
+ self.Log('%s is missing'%str(symbol))
+ self.symbols.remove(symbol)
+ self.data_count = 0
+ return
+
+
Step 4: Pairs Selection
+
+ This process is also under the OnData step. This step would generate pairs if it is the first trading period of this algorithm. If it's not, it will update the DataFrame and correlation coefficient of each pair in self.pair_list. After that the pairs have a correlation coefficient higher than 0.9 would be selected into self.selected_pair. Then all the pairs in self.selected_pair would be tested on their cointegration, and the pairs with a test value less than -3.34 would be selected to the final list. This step will also limit the number of stocks in the final list, by default we set self.selected_num to 10. self.count is a flag to count the number of datapoint we received. Once it reach 1-month amount, that means one trading period is passed and it would be set to 0.
+
+
+
+
+
if self.count == 0 and len(self.symbols[0].prices) == self.num_bar:
+ if self.generate_count == 0:
+ for symbol in self.symbols:
+ symbol.df = pd.DataFrame(symbol.prices, index = symbol.dates, columns = ['%s'%str(symbol)])
+
+ self.generate_pairs()
+ self.generate_count +=1
+ self.Log('pair list length:'+str(len(self.pair_list)))
+
+ for pair in self.pair_list:
+ pair.cor_update()
+ # Update the DataFrame and correlation selection
+ if len(self.pair_list[0].a_price) != 0:
+ for pair in self.pair_list:
+ pair.df_update()
+ pair.cor_update()
+
+ self.selected_pair = [x for x in self.pair_list if x.cor > 0.9]
+ # Cointegration test
+ for pair in self.selected_pair:
+ pair.cointegration_test()
+
+ self.selected_pair = [x for x in self.selected_pair if x.adf < self.BIC]
+ self.selected_pair.sort(key = lambda x: x.adf)
+ # If no pair passed the two-stage test, return.
+ if len(self.selected_pair) == 0:
+ self.Log('no selected pair')
+ self.count += 1
+ return
+ # clean the pair to avoid overlapping stocks.
+ self.selected_pair = self.pair_clean(self.selected_pair)
+ # assign a property to the selected pair, this is a signal that would be used for trading.
+ for pair in self.selected_pair:
+ pair.touch = 0
+ self.Log(str(pair.adf) + pair.name)
+ # limit the number of selected pairs.
+ if len(self.selected_pair) > self.selected_num:
+ self.selected_pair = self.selected_pair[:self.selected_num]
+
+ self.count +=1
+ self.data_count = 0
+ return
+
+
+
+
Step 5: Trade Period
+
+ It would be too long to read if we paste all the code in trading period together. Thus we would separate the code into three part: updating pairs, opening pairs trading and closing pairs trading. But all those lines are under OnData step and are under the condition: if self.count != 0 and self.count < self.one_month. This means it's in the trading period.
+
+
+
Updating Pairs
+
+ This step would update the stock prices in each pair. It would also update the signal called 'last_error' and immediately after this the pairs would receive new signals.
+
+
+
+
+
num_select = len(self.selected_pair)
+for pair in self.pair_list:
+ if data.ContainsKey(pair.a) is True and data.ContainsKey(pair.b) is True:
+ i.price_record(data[i.a],data[i.b])
+ else:
+ self.Log('%s has no data'%str(pair.name))
+ self.pair_list.remove(pair)
+
+for pair in self.selected_pair:
+ pair.last_error = pair.error
+
+for pair in self.trading_pairs:
+ pair.last_error = pair.error
+
+
Opening Pairs Trading
+
+ For each pair in self.selected_pair, we receive the current prices of the stocks, and then use the cointegration model to calculate the residual \(\epsilon\), which is assigned to the pair as a property named 'error'. self.trading.pairs is a list to store the trading pairs. Once a pairs trading is open, this pair would be add to the list, and it would be removed when the trading is closed. The property 'touch' is signal. If the residual \(\epsilon\) cross over the positive threshold standard deviation(we set \(\ 2.23*sigma\) here), the signal would become +1; while if it cross down the negative threshold deviation(\(\ -2.23*sigma\), the signal would become -1. For those pairs with +1 signal, if the error cross down positive threshold, there is a signal to open a trade. We long stock B and short stock A. For those pairs with -1 signal, if the error cross over negative threshold, we long Stock A and short stock B.
+ When we opening a trade, we need to record the current model, current mean and standard deviation of the residual. This is necessary because if we enter a new trading period and the trade has not been closed yet, the cointegration model, mean and standard deviation of the pairs would be changed. We need to use the original thresholds to close the trades. while adding the pairs into self.trading_pairs, we also need to set the signal 'touch' to 0 for further use.
+
+
+
+
+
for i in self.selected_pair:
+ price_a = float(data[i.a].Close)
+ price_b = float(data[i.b].Close)
+ i.error = price_a - (i.model.params[0] + i.model.params[1]*price_b)
+ if (self.Portfolio[i.a].Quantity == 0 and self.Portfolio[i.b].Quantity == 0) and i not in
+ self.trading_pairs:
+ if i.touch == 0:
+ if i.error < i.mean_error - self.open_size*i.sd and i.last_error > i.mean_error -
+ self.open_size*i.sd:
+ i.touch += -1
+ elif i.error > i.mean_error + self.open_size*i.sd and i.last_error < i.mean_error + self.open_size*i.sd: i.touch += 1 else: pass elif i.touch == -1: if i.error > i.mean_error - self.open_size*i.sd and i.last_error < i.mean_error -
+ self.open_size*i.sd:
+ self.Log('long %s and short %s'%(str(i.a),str(i.b)))
+ i.record_model = i.model
+ i.record_mean_error = i.mean_error
+ i.record_sd = i.sd
+ self.trading_pairs.append(i)
+ self.SetHoldings(i.a, 5.0/(len(self.selected_pair)))
+ self.SetHoldings(i.b, -5.0/(len(self.selected_pair)))
+ i.touch = 0
+ elif i.touch == 1:
+ if i.error < i.mean_error + self.open_size*i.sd and i.last_error > i.mean_error +
+ self.open_size*i.sd:
+ self.Log('long %s and short %s'%(str(i.b),str(i.a)))
+ i.record_model = i.model
+ i.record_mean_error = i.mean_error
+ i.record_sd = i.sd
+ self.trading_pairs.append(i)
+ self.SetHoldings(i.b, 5.0/(len(self.selected_pair)))
+ self.SetHoldings(i.a, -5.0/(len(self.selected_pair)))
+ i.touch = 0
+ else:
+ pass
+ else:
+ pass
+
+
+
+
Closing Pairs Trading
+
+ This part controls pairs trading exit. It works similar to the opening part. It uses the recorded original model and thresholds to determine whether or not we should close the position. If the residual \(\epsilon\) reaches our closing threshold, we liquidate stock A and stock B to close. If the residual continue to deviate from the mean and goes too far, we would also close the position to stop loss. When we close a pairs trading, we also remove the pairs from self.trading_pairs.
+
+
+
+
+
for i in self.trading_pairs:
+ price_a = float(data[i.a].Close)
+ price_b = float(data[i.b].Close)
+ i.error = price_a - (i.record_model.params[0] + i.record_model.params[1]*price_b)
+ if ((i.error < i.record_mean_error + self.close_size*i.record_sd and i.last_error >i.record_mean_error + self.close_size*i.record_sd) or (i.error > i.record_mean_error -
+ self.close_size*i.record_sd and i.last_error i.record_mean_error +
+ self.stop_loss*i.record_sd:
+ self.Log('close %s to stop loss'%str(i.name))
+ self.Liquidate(i.a)
+ self.Liquidate(i.b)
+ self.trading_pairs.remove(i)
+ else:
+ pass
+
diff --git "a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/03 \346\226\271\346\263\225.cn.html" "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/03 \346\226\271\346\263\225.cn.html"
new file mode 100644
index 0000000..a69dc45
--- /dev/null
+++ "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/03 \346\226\271\346\263\225.cn.html"
@@ -0,0 +1,248 @@
+
def generate_pairs(self):
+ for i in range(len(self.symbols)):
+ for j in range(i+1,len(self.symbols)):
+ self.pair_list.append(pairs(self.symbols[i],self.symbols[j]))
+
+ self.pair_list = [x for x in self.pair_list if x.cor > self.pair_threshold]
+
+ self.pair_list.sort(key = lambda x: x.cor, reverse = True)
+
+ if len(self.pair_list) > self.pair_num:
+ self.pair_list = self.pair_list[:self.pair_num]
+
+def pair_clean(self,list):
+ l = []
+ l.append(list[0])
+ for i in list:
+ symbols = [x.a for x in l] + [x.b for x in l]
+ if i.a not in symbols and i.b not in symbols:
+ l.append(i)
+ else:
+ pass
+ return l
+
if len(self.symbols[0].prices) < self.num_bar:
+ for symbol in self.symbols:
+ if data.ContainsKey(i) is True:
+ symbol.prices.append(float(data[symbol].Close))
+ symbol.dates.append(data[symbol].EndTime)
+ else:
+ self.Log('%s is missing'%str(symbol))
+ self.symbols.remove(symbol)
+ self.data_count = 0
+ return
num_select = len(self.selected_pair)
+for pair in self.pair_list:
+ if data.ContainsKey(pair.a) is True and data.ContainsKey(pair.b) is True:
+ i.price_record(data[i.a],data[i.b])
+ else:
+ self.Log('%s has no data'%str(pair.name))
+ self.pair_list.remove(pair)
+
+for pair in self.selected_pair:
+ pair.last_error = pair.error
+
+for pair in self.trading_pairs:
+ pair.last_error = pair.error
for i in self.trading_pairs:
+ price_a = float(data[i.a].Close)
+ price_b = float(data[i.b].Close)
+ i.error = price_a - (i.record_model.params[0] + i.record_model.params[1]*price_b)
+ if ((i.error < i.record_mean_error + self.close_size*i.record_sd and i.last_error >i.record_mean_error + self.close_size*i.record_sd) or (i.error > i.record_mean_error -
+ self.close_size*i.record_sd and i.last_error i.record_mean_error +
+ self.stop_loss*i.record_sd:
+ self.Log('close %s to stop loss'%str(i.name))
+ self.Liquidate(i.a)
+ self.Liquidate(i.b)
+ self.trading_pairs.remove(i)
+ else:
+ pass
+
diff --git a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/04 Result.html b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/04 Result.html
new file mode 100755
index 0000000..b94900f
--- /dev/null
+++ b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/04 Result.html
@@ -0,0 +1,20 @@
+
+ We used 10-minute resolution data to backtest the strategy from Jan 2013 to Dec 2016. To demonstrate the in sample training results, we randomly selected a training period that from 2016-09-07 to 2013-11-30.
+
+
+ The following table demonstrates the top 10 selected pairs in the training period mentioned above. We can see that the pairs with the highest correlation coefficient doesn't not necessarily has the best ADF test value. We made the rank by ADF test value because it's more robust.
+
+
+
+
+
+ The upper part of the following chart plots the stock prices of pair ING vs TCB. The lower part plots by how many times standard deviation the residual deviate from its mean. There are 5 trading opportunities if we set the opening threshold to be 2.32.
+
+
+
+
+
+ The following chart is the density plot of the residual error. From the shape we can see the error is approximately normal distributed.
+
+
+
diff --git "a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/04 \347\273\223\346\236\234.cn.html" "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/04 \347\273\223\346\236\234.cn.html"
new file mode 100644
index 0000000..9361eda
--- /dev/null
+++ "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/04 \347\273\223\346\236\234.cn.html"
@@ -0,0 +1,20 @@
+
+
+
diff --git a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/05 Summary.html b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/05 Summary.html
new file mode 100755
index 0000000..ac06d78
--- /dev/null
+++ b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/05 Summary.html
@@ -0,0 +1,6 @@
+
+ The strategy is considered to be market neutral strategy because it a long/short strategy betting on price convergence. Out backtested beta is -0.112, which is within our expectation.
+ Theoretically, the higher resolution we use, the higher win rate is because on one hand the higher resolution would increase the number of datapoint in our training period, which would make it's harder to past the two-stage test; on the other hand the higher resolution data would let us capture minor profit more accurately. However, there is a trade off between performance and backtesting time. The higher resolution will lead backtesting time to increase drastically.
+ The number of stocks in the initialize step would also affect our performance. Theoretically, the more stock we have, we better pairs we are likely to pick. But too many stocks would also be time consuming.
+ what's worth mentioning is that the optimized parameters are different for each sector. It depends on the features of the price patterns in the specific industry. Plotting the pairs prices and the residual to observe is good option to adjust the thresholds.
+
diff --git "a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/05 \346\200\273\347\273\223.cn.html" "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/05 \346\200\273\347\273\223.cn.html"
new file mode 100644
index 0000000..fa65597
--- /dev/null
+++ "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/05 \346\200\273\347\273\223.cn.html"
@@ -0,0 +1,3 @@
+
diff --git a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/06 Algorithm.html b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/06 Algorithm.html
new file mode 100755
index 0000000..3d55776
--- /dev/null
+++ b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/06 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git "a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/06 \347\256\227\346\263\225.cn.html" "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/06 \347\256\227\346\263\225.cn.html"
new file mode 100644
index 0000000..3d55776
--- /dev/null
+++ "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/06 \347\256\227\346\263\225.cn.html"
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/07 References.html b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/07 References.html
new file mode 100644
index 0000000..b50463a
--- /dev/null
+++ b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/07 References.html
@@ -0,0 +1,16 @@
+
+
+
+ George J. Miao High Frequency and Dynamic Pairs Trading Based on Statistical Arbitrage Using a Two-Stage Correlation and Cointegration Approach Online Copy
+
+
+ Cartea & Penalva, 2012, Where is the value in high frequency trading? Online Copy
+
+
+ Gatev, Goetzmann, & Rouwenhorst, 2006, Pairs trading: Performance of a relative-value arbitrage rule. The Review of Financial Studies, 19(3), 797–827. Online Copy
+
+
+ Engle and Granger, Co-integration and error correction: Representation, estimation, and testing. Econometrica, 55(2), 251–276. Online Copy
+
+
+
diff --git "a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/07 \345\217\202\350\200\203\346\226\207\347\214\256.cn.html" "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/07 \345\217\202\350\200\203\346\226\207\347\214\256.cn.html"
new file mode 100644
index 0000000..b50463a
--- /dev/null
+++ "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/07 \345\217\202\350\200\203\346\226\207\347\214\256.cn.html"
@@ -0,0 +1,16 @@
+
+
+
+ George J. Miao High Frequency and Dynamic Pairs Trading Based on Statistical Arbitrage Using a Two-Stage Correlation and Cointegration Approach Online Copy
+
+
+ Cartea & Penalva, 2012, Where is the value in high frequency trading? Online Copy
+
+
+ Gatev, Goetzmann, & Rouwenhorst, 2006, Pairs trading: Performance of a relative-value arbitrage rule. The Review of Financial Studies, 19(3), 797–827. Online Copy
+
+
+ Engle and Granger, Co-integration and error correction: Representation, estimation, and testing. Econometrica, 55(2), 251–276. Online Copy
+
+
+
diff --git a/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/01 Abstract.html b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/01 Abstract.html
new file mode 100755
index 0000000..e664e2f
--- /dev/null
+++ b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/01 Abstract.html
@@ -0,0 +1,7 @@
+
+ Trend estimation is a family of methods to detect and predict tendencies and trends in price series just using the history information. Moving average is a commonly used trend following trading tool. Lots of momentum trading strategies in the Forex market are based on the moving average rule, in which signals are triggered if the close is above or below the moving average. But MA has the time lag, therefore can't be used to predict the turning points of market price changes.
+
+
+ In this tutorial, I developed a trend following strategy which is proposed in the paper Harris R D F, Yilmaz F(2009).
+ This strategy exploits short-term momentum in the non-linear trend component of the exchange rate which is generated by Hodrick-Prescott Filter (rather than the exchange rate itself) and uses the MA(1, 2) rule to measure this momentum. The strategy was tested on seven kinds of exchange rates and the results shows less robustness and the performance is sensitive to the change of model parameters.
+
diff --git a/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/02 Introduction.html b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/02 Introduction.html
new file mode 100755
index 0000000..0ff3a93
--- /dev/null
+++ b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/02 Introduction.html
@@ -0,0 +1,56 @@
+
+ Hodrick-Prescott Filter decomposes a time series\(y_t\) into two components: the cyclical part(which is short-term) and the trend part(which is long term).
+
+
+\[y_t=x _t +c_t\]
+
+
+ The filter is the solution to the following optimization problem for \(x_t\)
+
+ The second term is the discrete derivative of the trend xt which characterizes the smoothness of the curve. We can rewrite the above formula in vector form:
+
+ where \({\bf y}=(y_1,y_2,...,y_n),{\bf x}=(x_1,x_2,...,x_n)\in {\rm I\!R}^n\),\(\parallel\cdot\parallel_2\) is the Euclidean norm. D is the (n-2)*n matrix:
+
+ The solution of this optimization problem is given by solving the following linear system:
+
+
+\[y=(I+2\lambda D^TD)^{-1}x\]
+
+
+
def hpfilter(self,X, lamb=1600):
+ X = np.asarray(X, float)
+ if X.ndim > 1:
+ X = X.squeeze()
+ nobs = len(X)
+ I = sparse.eye(nobs,nobs)
+ offsets = np.array([0,1,2])
+ data = np.repeat([[1.],[-2.],[1.]], nobs, axis=1)
+ K = sparse.dia_matrix((data, offsets), shape=(nobs-2,nobs))
+ use_umfpack = True
+ self.trend = spsolve(I+lamb*K.T.dot(K), X,use_umfpack=use_umfpack)
+ cycle = X - self.trend
+
+
diff --git a/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/03 Method.html b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/03 Method.html
new file mode 100755
index 0000000..d23890a
--- /dev/null
+++ b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/03 Method.html
@@ -0,0 +1,85 @@
+
+ This low-frequency momentum trading strategies are applied to daily data on seven kinds of exchange rates. We use five years history data before January 2011 for initial estimation of the trend model. Daily exchange rates for the period January 2011 to May 2017 is used for out of sample trading.
+
+
+
+
+
def Initialize(self):
+ self.SetStartDate(2011,1,1)
+ self.SetEndDate(2017,5,30)
+ self.SetCash(100000)
+ self.numdays = 360*5 # set the length of training period
+ self.syl = self.AddSecurity(SecurityType.Forex, "EURUSD", Resolution.Daily).Symbol
+ self.n,self.m = 2, 1
+ self.trend = None
+ self.SetBenchmark(self.syl)
+ self.MA_rules = None
+ history = self.History(self.numdays,Resolution.Daily)
+ self.close = [slice[self.syl].Close for slice in history]
+
+
+
+
Step 1: Calibrating the Filter Smoothing Parameter λ
+
+ The Ravn–Uhlig rule is commonly used to set the smoothing parameter λ in HP filter and must be greater than 0. It is adjusted by the changing frequency of observations and must be greater than 0. Hodrick and Prescott (1997) recommended setting λ to 1,600 for quarterly data. The Ravn–Uhlig rule sets \(\lambda = 1600p^4\) , where p is the number of periods per quarter. As for our daily exchange rate data, we should have set λ to be \(1600\times (30 \times 4)^4\). But when we use this value as the λ, the curve is almost a straight line since the trend becomes smoother as λ → ∞. In order to avoid excessive smoothing, we gradually decrease the λ and draw the smoothing curve. Below is the chart of EURUSD daily price from the year 2010 to 2011. t100 denotes the trend component after filter with the parameter λ=100.
+
+
+
+
+
+ If we just plot the curve for the first 100 days, we find that the smaller the λ, the more apparent the trend. The curve does not change too much as the λ smaller than 100. Thus here we choose λ=100 to extract the trend of daily price data. This trend is our low-frequency component.
+
+
+
+
+
Out-of-sample EUR/USD Trend Estimation
+
+
+
Step 2: Setting up the Moving Average Rule
+
+
+ Moving average (MA) rules are very commonly used to generate buy and sell signals from data on the spot exchange rate. The MA rule compares a short-run moving average of the current and lagged exchange rate with a long-run moving average.
+
+ For HP filter, the non-linear trend is estimated recursively as the paper did. The initial estimation was undertaken using 3 years history data before 2011. The estimation period is then rolled forward each day through the trading period from January 2011 to May 2017.
+
+
+
Step 3: Generating the Trading Signals
+
+ We generate buy and sell signals by applying an MA(1, 2) rule to the estimated low-frequency component. For MA(m,n), m must be 1 which denotes the current value of low-frequency component. n should be small since large n would generate large time lag, the judgment of turning points is not accurate.
+
+
+
+ A buy signal is generated when the current day’s low-frequency trend is higher than the last day’s low-frequency trend and a sell signal is generated when it is lower.
+
+ The above charts are the in-sample trading signals after applying MA rules on the low-frequency component. The trend curve is more smooth with larger λ. Thus when we applied MA rules, a less smooth trend will trigger more trading opportunities.
+
diff --git a/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/04 Summary.html b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/04 Summary.html
new file mode 100755
index 0000000..2e4457d
--- /dev/null
+++ b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/04 Summary.html
@@ -0,0 +1,67 @@
+
+
+
+
Strategy Performance for different currencies in Forex
+
+
+
+
+
Currency
+
USDCAD
+
EURUSD
+
USDCHF
+
EURGBP
+
CADUSD
+
USDNOK
+
USDZAR
+
+
+
Sharp Ratio
+
0.361
+
0.375
+
0.131
+
0.337
+
0.052
+
0.054
+
0.195
+
+
+
Total Trades
+
14
+
11
+
12
+
11
+
6
+
16
+
9
+
+
+
Annual Return
+
3.128%
+
3.272%
+
1.162%
+
2.689%
+
0.043%
+
0.093%
+
2.201%
+
+
+
Max Drawdown
+
10.3%
+
8.3%
+
24.8%
+
17.6%
+
22.5%
+
30.3%
+
23%
+
+
+
+
+
+ The table reports the strategy performance statistics during six and a half years backtesting period. From the table we can see, most of them have the higher maximum drawdown. The number of total trades is small because we applied MA rules on the smoothed trend component. As the author indicated in the paper, we still find that the performance of this strategy is very sensitive to the choice of lag parameters in MA rules and in a non-monotonic way.
+
+
+
+ The strategy does not generate more stable profits in Forex market generally. That might because that the HP filter technique was designed to be viewed as a trend curve through the entire set of data. When we applied it in trading strategy, the entry of new data into the filter model can cause the trend line to change the trend through past data, makes it harder to identify the trend accurately.
+
diff --git a/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/05 Algorithm.html b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/05 Algorithm.html
new file mode 100755
index 0000000..f9505bd
--- /dev/null
+++ b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/05 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/06 References.html b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/06 References.html
new file mode 100644
index 0000000..3574dd3
--- /dev/null
+++ b/04 Strategy Library/08 The Momentum Strategy Based on the Low Frequency Component of Forex Market/06 References.html
@@ -0,0 +1,8 @@
+
+
+ Harris R D F, Yilmaz F. A momentum trading strategy based on the low-frequency component of the exchange rate[J]. Journal of Banking & Finance, 2009, 33(9): 1575-1585. online copy
+
+
+ Dao T L. Momentum Strategies with L1 Filter[J]. Browser Download This Paper, 2014. online copy
+
+
diff --git a/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/01 Abstract.html b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/01 Abstract.html
new file mode 100755
index 0000000..371a2b4
--- /dev/null
+++ b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/01 Abstract.html
@@ -0,0 +1,3 @@
+
+ In recent years, factor investing gained significant popularity among global institutional investors. In this tutorial, we first developed a factor selection model to test if factors have the ability to differentiate potential winners and losers in the stock market. Then we use those preselected factors to implement the factor ranking stock selection algorithm based on Factor Based Stock Selection Model for Turkish Equities, 2015, Ayhan Yüksel.
+
diff --git "a/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/01 \346\221\230\350\246\201.cn.html" "b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/01 \346\221\230\350\246\201.cn.html"
new file mode 100644
index 0000000..64620eb
--- /dev/null
+++ "b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/01 \346\221\230\350\246\201.cn.html"
@@ -0,0 +1,3 @@
+
diff --git a/Strategy Tutorials/Tutorial09 Stock Selection Strategy Based on Fundamental Factors.html b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/02 Factor Selection.html
old mode 100644
new mode 100755
similarity index 51%
rename from Strategy Tutorials/Tutorial09 Stock Selection Strategy Based on Fundamental Factors.html
rename to 04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/02 Factor Selection.html
index aad7b2f..663d5e1
--- a/Strategy Tutorials/Tutorial09 Stock Selection Strategy Based on Fundamental Factors.html
+++ b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/02 Factor Selection.html
@@ -1,10 +1,13 @@
-
Abstract
-In recent years, factor investing gained significant popularity among global institutional investors. In this tutorial, we first developed a factor selection model to test if factors have the ability to differentiate potential winners and losers in the stock market. Then we use those preselected factors to implement the factor ranking stock selection algorithm based on Factor Based Stock Selection Model for Turkish Equities, 2015, Ayhan Yüksel[ref]Factor Based Stock Selection Model for Turkish Equities, 2015, Ayhan Yüksel Online Copy[/ref]
-
Part 1. Factor Selection
-QuantConnect provides Morningstar fundamentals data for US Equities. Valuation Ratios is daily data. For others like operation ratios and financial statements data are available for multiple periods depending on the property. Please refer to Data Library for detailed factors available.
+
+ QuantConnect provides Morningstar fundamentals data for US Equities. Valuation Ratios is daily data. For others like operation ratios and financial statements data are available for multiple periods depending on the property. Please refer to Data Library for detailed factors available.
+
+
+ The algorithm is designed to test the significance of one factor each time.
+
-The algorithm is designed to test the significance of one factor each time.
-
def Initialize(self):
+
+
+
def Initialize(self):
self.SetStartDate(2005,01,01) #Set Start Date
self.SetEndDate(2012,03,01) #Set End Date
self.SetCash(50000) #Set Strategy Cash
@@ -13,33 +16,48 @@
Part 1. Factor Selection
self.AddEquity("SPY") # add benchmark
self.numOfCourseSymbols = 200
self.numOfPortfolio = 5
- self._changes = SecurityChanges.None
+ self._changes = None
self.flag1 = 1 # variable to control the monthly rebalance of coarse and fine selection function
self.flag2 = 0 # variable to control the monthly rebalance of OnData function
self.flag3 = 0 # variable to record the number of rebalancing times
# store the monthly returns of different portfolios in a dataframe
self.df_return = pd.DataFrame(index = range(self.numOfPortfolio+1))
# schedule an event to fire at the first trading day of SPY
- self.Schedule.On(self.DateRules.MonthStart("SPY"), self.TimeRules.AfterMarketOpen("SPY"), Action(self.Rebalancing))
-1. First, we sort the stocks by daily dollar volume and take the top stocks with the highest dollar volumes as our candidates. There is a convenient way using our universe selection API. Universes are refreshed every day by default, but can be refreshed as often as required. This is controlled by the variable UniverseSettings.Resolution. You can refer to the documentation for more details. Here we use Scheduled events API to trigger code to run at the first trading day each month and use three flag variables to control the rebalancing of CoarseSelection, FineSelection and Ondata functions.
+
+ 1. First, we sort the stocks by daily dollar volume and take the top stocks with the highest dollar volumes as our candidates. There is a convenient way using our universe selection API. Universes are refreshed every day by default, but can be refreshed as often as required. This is controlled by the variable UniverseSettings.Resolution. You can refer to the documentation for more details. Here we use Scheduled events API to trigger code to run at the first trading day each month and use three flag variables to control the rebalancing of CoarseSelection, FineSelection and Ondata functions.
+
+
+ Coarse Universe selection is the built-in universe data provided by QuantConnect which allows you to filter the universe of over 16000 symbols to perform rough filtering before your algorithm. Because coarse selection function takes all the equities including ETFs which have no fundamental data into account, we need the property x.HasFundamentalData to exclude them from our candidate stocks pool.
+
+
-Coarse Universe selection is the built-in universe data provided by QuantConnect which allows you to filter the universe of over 16000 symbols to perform rough filtering before your algorithm. Because coarse selection function takes all the equities including ETFs which have no fundamental data into account, we need the property x.HasFundamentalData to exclude them from our candidate stocks pool.
-
# sort the data by daily dollar volume and take the top entries
+
# sort the data by daily dollar volume and take the top entries
def CoarseSelectionFunction(self, coarse):
if self.flag1:
CoarseWithFundamental = [x for x in coarse if x.HasFundamentalData]
sortedByVolume = sorted(CoarseWithFundamental, key=lambda x: x.DollarVolume, reverse=True)
top = sortedByVolume[:self.numOfCourseSymbols]
- list = List[Symbol]()
- for x in top:
- list.Add(x.Symbol)
- return list
+ return [i.Symbol for i in top]
else:
- return(List[Symbol]())
+ return []
-2. We extract the factor values of candidate stocks at the beginning of each month and sort the stocks in ascending order of their factor values. Here we use 12-months' total risk-based capital data x.FinancialStatements.TotalRiskBasedCapital.TwelveMonths as an example. It is the sum of Tier 1 and Tier 2 Capital. x.Symbol.Value can give the string symbol of selected stock x. Then we save those sorted symbols as self.symbol.
-
def FineSelectionFunction(self, fine):
+
+
+
+ 2. We extract the factor values of candidate stocks at the beginning of each month and sort the stocks in ascending
+ order of their factor values. Here we use 12-months' total risk-based capital data
+ x.FinancialStatements.TotalRiskBasedCapital.TwelveMonths as an example.
+ It is the sum of Tier 1 and Tier 2 Capital. x.Symbol.Value
+ can give the string symbol of selected stock x. Then we save those sorted symbols as self.symbol.
+
self.symbol = [str(x.Symbol.Value) for x in sorted_fine]
# factor_value = [x.ValuationRatios.PERatio for x in sorted_fine]
self.flag3 = self.flag3 + 1
- return (List[Symbol]())
+ return []
else:
- return (List[Symbol]())
+ return []
+
+
Step 2: Compute the monthly return of portfolios
-1. At the end of each month, we extract the one-month history close prices of each stock and compute the monthly returns.
-
sorted_symbol = self.symbol
+
+ 1. At the end of each month, we extract the one-month history close prices of each stock and compute the monthly returns.
+
+
+
+
+
sorted_symbol = self.symbol
self.AddEquity("SPY") # add benchmark
for x in sorted_symbol:
self.AddEquity(x)
@@ -77,12 +102,16 @@
Step 2: Compute the monthly return of portfolios
# the length of monthly_return list should be divisible by the number of portfolios
monthly_return = monthly_return[:int(math.floor(len(monthly_return) / self.numOfPortfolio) * self.numOfPortfolio)]
-
-
-
+
+
+
+
+ 2. We divide the stocks into 5 portfolios and compute the average monthly returns of each portfolio. Then we add the monthly return of benchmark "SPY" at the last line of the data frame df_return.
+
-2. We divide the stocks into 5 portfolios and compute the average monthly returns of each portfolio. Then we add the monthly return of benchmark "SPY" at the last line of the data frame df_return.
-
reshape_return = np.reshape(monthly_return, (self.numOfPortfolio, len(monthly_return)/self.numOfPortfolio))
# calculate the average return of different portfolios
port_avg_return = np.mean(reshape_return,axis=1).tolist()
# add return of "SPY" as the benchmark to the end of the return list
@@ -93,14 +122,21 @@
Step 3: Generate the metrics to test the factor significance
-After getting the monthly returns of portfolios and the benchmark, we compute the average annual return and excess return over benchmark of each portfolio across the whole backtesting period. Then We generate three metrics to judge the significance of each factor.
-
+
+ After getting the monthly returns of portfolios and the benchmark, we compute the average annual return and excess return over benchmark of each portfolio across the whole backtesting period. Then We generate three metrics to judge the significance of each factor.
+
+
+
The first metrics is the correlation between the portfolio' returns and their rank. The absolute value of the correlation coefficient should larger than 0.8.
If the return of the rank first portfolio larger than the portfolio at the bottom of the return rankings, we define it the win portfolio and the loss portfolio and vice versa. The win probability is the probability that the win portfolio return outperform the benchmark return. The loss probability is the probability that the loss portfolio return underperform the benchmark. If the factor is significant, both loss and win probability should greater than 0.4.
The excess return of win portfolio should be greater than 0.25, while the excess return of loss portfolio should be lower than 0.05.
Step 3: Generate the metrics to test the factor significance
return test_result
+
@@ -197,19 +234,7 @@
Step 3: Generate the metrics to test the factor significance
-
-
-We choose 4 factors: FCFYield, PriceChange1M, BookValuePerShare and RevenueGrowth.
-
Part 2. Stock Selection
-
Step 1: Rank the stocks by factor values
-First, we remove the stocks without fundamental data or have zero factor value. For each pre-selected factor, we rank the stocks by those factor values. The order is descending if the factor correlation is negative, it is ascending if the factor correlation is positive.
-
-The second step is using different selected factor variables to calculate an equally weighted composite factor score for each stock.
-
-
First, according to the factor order, we place our universe stocks into 5 distinct quintile portfolios, named P1, P2, P3, P4 and P5. The ranking of portfolios sets out the preference of the factor model, i.e. the first portfolio (P1) corresponds to the “most preferred” stocks, while the fifth (P5) corresponds to the “least preferred” stocks.Suppose there are n stocks in total. Then the stocks fall into the first rank portfolio will have score p, the stocks fall into the second rank portfolio will get score p-1 and so on. Then we can get a score for every stock. We did the same calculation for each factor.
-
Second, we calculate a “Composite Factor Score” by combining the six-factor scores and using an equal weighting scheme. Then we get composite factor score for each stock.
-
Third, we then rank the stocks in our universe according to their Composite Factor Scores and choose the highest ranked 20 stocks to construct our portfolios at the beginning of each month.
-
At the end of each month, we repeat the above steps to construct the new portfolio and adjust the holding stocks.
-
-
Algorithm
-
+
+
+ We choose 4 factors: FCFYield, PriceChange1M, BookValuePerShare and RevenueGrowth.
+
diff --git "a/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/02 \350\246\201\347\264\240\351\200\211\346\213\251.cn.html" "b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/02 \350\246\201\347\264\240\351\200\211\346\213\251.cn.html"
new file mode 100644
index 0000000..b8cefb8
--- /dev/null
+++ "b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/02 \350\246\201\347\264\240\351\200\211\346\213\251.cn.html"
@@ -0,0 +1,236 @@
+
# 按照每日美元交易量对数据进行排序，并取排名最上面的条目
+def CoarseSelectionFunction(self, coarse):
+ if self.flag1:
+ CoarseWithFundamental = [x for x in coarse if x.HasFundamentalData]
+ sortedByVolume = sorted(CoarseWithFundamental, key=lambda x: x.DollarVolume, reverse=True)
+ top = sortedByVolume[:self.numOfCourseSymbols]
+ return [i.Symbol for i in top]
+ else:
+ return []
+
diff --git a/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/03 Stock Selection.html b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/03 Stock Selection.html
new file mode 100755
index 0000000..62400c9
--- /dev/null
+++ b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/03 Stock Selection.html
@@ -0,0 +1,17 @@
+Next we will select the stocks.
+
Step 1: Rank the stocks by factor values
+
+ First, we remove the stocks without fundamental data or have zero factor value. For each pre-selected factor, we rank the stocks by those factor values. The order is descending if the factor correlation is negative, it is ascending if the factor correlation is positive.
+
+ The second step is using different selected factor variables to calculate an equally weighted composite factor score for each stock.
+
+
+
+
First, according to the factor order, we place our universe stocks into 5 distinct quintile portfolios, named P1, P2, P3, P4 and P5. The ranking of portfolios sets out the preference of the factor model, i.e. the first portfolio (P1) corresponds to the “most preferred” stocks, while the fifth (P5) corresponds to the “least preferred” stocks.Suppose there are n stocks in total. Then the stocks fall into the first rank portfolio will have score p, the stocks fall into the second rank portfolio will get score p-1 and so on. Then we can get a score for every stock. We did the same calculation for each factor.
+
Second, we calculate a “Composite Factor Score” by combining the six-factor scores and using an equal weighting scheme. Then we get composite factor score for each stock.
+
Third, we then rank the stocks in our universe according to their Composite Factor Scores and choose the highest ranked 20 stocks to construct our portfolios at the beginning of each month.
+
At the end of each month, we repeat the above steps to construct the new portfolio and adjust the holding stocks.
+
diff --git "a/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/03 \350\202\241\347\245\250\351\200\211\346\213\251.cn.html" "b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/03 \350\202\241\347\245\250\351\200\211\346\213\251.cn.html"
new file mode 100644
index 0000000..00bbed2
--- /dev/null
+++ "b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/03 \350\202\241\347\245\250\351\200\211\346\213\251.cn.html"
@@ -0,0 +1,17 @@
+接下来我们将选择股票。
+
diff --git a/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/04 Algorithm.html b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/04 Algorithm.html
new file mode 100755
index 0000000..8586edb
--- /dev/null
+++ b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git "a/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/04 \347\256\227\346\263\225.cn.html" "b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/04 \347\256\227\346\263\225.cn.html"
new file mode 100644
index 0000000..d1a72fa
--- /dev/null
+++ "b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/04 \347\256\227\346\263\225.cn.html"
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/05 References.html b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/05 References.html
new file mode 100644
index 0000000..4d6f9c3
--- /dev/null
+++ b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/05 References.html
@@ -0,0 +1,5 @@
+
+
+ Factor Based Stock Selection Model for Turkish Equities, 2015, Ayhan Yüksel Online Copy
+
+
diff --git "a/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/05 \345\217\202\350\200\203\346\226\207\347\214\256.cn.html" "b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/05 \345\217\202\350\200\203\346\226\207\347\214\256.cn.html"
new file mode 100644
index 0000000..4d6f9c3
--- /dev/null
+++ "b/04 Strategy Library/09 Stock Selection Strategy Based on Fundamental Factors/05 \345\217\202\350\200\203\346\226\207\347\214\256.cn.html"
@@ -0,0 +1,5 @@
+
+
+ Factor Based Stock Selection Model for Turkish Equities, 2015, Ayhan Yüksel Online Copy
+
+
diff --git a/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/01 Abstract.html b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/01 Abstract.html
new file mode 100755
index 0000000..e1419ee
--- /dev/null
+++ b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/01 Abstract.html
@@ -0,0 +1,8 @@
+
+ In this tutorial, we implement a version of the short-term reversal strategy published by De Groot, Huij, & Zhou
+ (2012). The strategy works by observing the returns of each security in the universe over the previous month. Every
+ week, the algorithm longs the worst performers and shorts the top performers. The original strategy outlined in the
+ literature considers the entire universe of stocks when trading. To reduce trading costs, we limit our universe to
+ the most liquid large cap stocks. Our analysis shows the strategy underperforms the S&P 500 index during all our
+ backtest periods except the 2020 market crash.
+
diff --git a/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/02 Method.html b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/02 Method.html
new file mode 100755
index 0000000..8b9f021
--- /dev/null
+++ b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/02 Method.html
@@ -0,0 +1,141 @@
+
+ The strategy code mainly consists of four parts: Initialization, Universe Selection, OnData, and OnSecuritiesChanged.
+
+
+
Algorithm Initialization
+
+ When initializing the algorithm, we add a coarse universe selection method and specify several parameters to use
+ when selecting securities.
+
+ The coarse universe selection method creates a RateOfChange
+ indicator for each of the top 100
+ most liquid securities in the market. Upon creation, the indicator is manually warmed-up with historical closing
+ prices. After the indicators are ready, the universe selects the securities with the 10 best and 10 worst
+ RateOfChange values.
+
+
+
+class ShortTimeReversal(QCAlgorithm):
+ # ...
+
+ def SelectCoarse(self, coarse):
+
+ # We should keep a dictionary for all securities that have been selected
+ for cf in coarse:
+ symbol = cf.Symbol
+ if symbol in self.roc_by_symbol:
+ self.roc_by_symbol[symbol].Update(cf.EndTime, cf.AdjustedPrice)
+
+ # Refresh universe each week
+ week_number = self.Time.date().isocalendar()[1]
+ if week_number == self.week:
+ return Universe.Unchanged
+ self.week = week_number
+
+ # sort and select by dollar volume
+ sortedByDollarVolume = sorted(coarse, key=lambda x: x.DollarVolume, reverse=True)
+ selected = {cf.Symbol: cf for cf in sortedByDollarVolume[:self.dollar_volume_selection_size]}
+
+ # New selections need a history request to warm up the indicator
+ symbols = [k for k in selected.keys()
+ if k not in self.roc_by_symbol or not self.roc_by_symbol[k].IsReady]
+
+ if symbols:
+ history = self.History(symbols, self.lookback, Resolution.Daily)
+ if history.empty:
+ self.Log(f'No history for {", ".join([x.Value for x in symbols])}')
+ history = history.close.unstack(0)
+
+ for symbol in symbols:
+
+ if symbol not in history:
+ continue
+
+ # Create and warm-up the RateOfChange indicator
+ roc = RateOfChange(self.lookback)
+ for time, price in history[symbol].dropna().iteritems():
+ roc.Update(time, price)
+
+ if roc.IsReady:
+ self.roc_by_symbol[symbol] = roc
+
+ # Sort the symbols by their ROC values
+ selectedRateOfChange = {}
+ for symbol in selected.keys():
+ if symbol in self.roc_by_symbol:
+ selectedRateOfChange[symbol] = self.roc_by_symbol[symbol]
+ sortedByRateOfChange = sorted(selectedRateOfChange.items(), key=lambda kv: kv[1], reverse=True)
+
+ # Define the top and the bottom to buy and sell
+ self.rocTop = [x[0] for x in sortedByRateOfChange[:self.roc_selection_size]]
+ self.rocBottom = [x[0] for x in sortedByRateOfChange[-self.roc_selection_size:]]
+
+ return self.rocTop + self.rocBottom
+
+
+
+
+
The OnData Method
+
+ As new data is passed to the OnData method, we issue orders to form a long-short portfolio. We long the securities
+ with the lowest RateOfChange values and short those with the largest values. After rebalancing, we clear the
+ `rocTop` and `rocBottom` lists to ensure we don’t trade again until the universe is refreshed.
+
+
+
+class ShortTimeReversal(QCAlgorithm):
+ # ...
+
+ def OnData(self, data):
+ # Rebalance
+ for symbol in self.rocTop:
+ self.SetHoldings(symbol, -0.5/len(self.rocTop))
+ for symbol in self.rocBottom:
+ self.SetHoldings(symbol, 0.5/len(self.rocBottom))
+
+ # Clear the list of securities we have placed orders for
+ # to avoid new trades before the next universe selection
+ self.rocTop.clear()
+ self.rocBottom.clear()
+
+
+
+
The OnSecuritiesChanged Method
+
+ We are rebalancing the portfolio on a weekly basis, but securities can leave our defined universe between rebalance
+ days. To accommodate this, we liquidate any securities that are removed from the universe in the
+ OnSecuritiesChanged method.
+
+
+
+class ShortTimeReversal(QCAlgorithm):
+ # ...
+
+ def OnSecuritiesChanged(self, changes):
+ for security in changes.RemovedSecurities:
+ self.Liquidate(security.Symbol, 'Removed from Universe')
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/04 Algorithm.html b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/04 Algorithm.html
new file mode 100755
index 0000000..c2e37d5
--- /dev/null
+++ b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/05 Relative Performance.html b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/05 Relative Performance.html
new file mode 100644
index 0000000..3d18c34
--- /dev/null
+++ b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/05 Relative Performance.html
@@ -0,0 +1,56 @@
+
+ Although this strategy passes several of the
+ metrics required for Alpha Streams
+ and the Quant League competition, it requires further work to pass the following requirements:
+
+
+
+
PSR >= 80%
+
Emits insights
+
Max drawdown <= 10%
+
Handles dividends and splits
+
Minute or second data resolution
+
diff --git a/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/08 Conclusion.html b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/08 Conclusion.html
new file mode 100644
index 0000000..ae81428
--- /dev/null
+++ b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/08 Conclusion.html
@@ -0,0 +1,16 @@
+
+ The short-term reversal strategy implemented in this tutorial produced a lower Sharpe ratio than the S&P
+ 500 index ETF benchmark over all our testing periods except during the 2020 market crash. To continue the
+ development of this strategy, future areas of research include:
+
+
+
+ To continue the development of this strategy, future areas of research include:
+
+
+
+
Increasing the data resolution and adding risk management logic.
+
Applying the strategy to a different universe of securities.
+
Testing other lookback periods for the RateOfChange indicator. Some researchers exclude the most-recent month’s price action from the indicator’s calculation.
+
Adjusting the weight for each insight emitted from the alpha model. Perhaps the most extreme performer of all the securities the alpha model is about to long (short) should be given the largest weight of all the securities the model is about to long (short).
+
\ No newline at end of file
diff --git a/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/09 References.html b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/09 References.html
new file mode 100644
index 0000000..2a52089
--- /dev/null
+++ b/04 Strategy Library/10 Short-Term Reversal Strategy in Stocks/09 References.html
@@ -0,0 +1,6 @@
+
+
+ de Groot, Wilma and Huij, Joop and Zhou, Weili, Another Look at Trading Costs and Short-Term Reversal
+ Profits (July 1, 2011). Online copy
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/100 Trading with WTI BRENT Spread/01 Introduction.html b/04 Strategy Library/100 Trading with WTI BRENT Spread/01 Introduction.html
new file mode 100644
index 0000000..d18875d
--- /dev/null
+++ b/04 Strategy Library/100 Trading with WTI BRENT Spread/01 Introduction.html
@@ -0,0 +1,5 @@
+
+ The WTI-Brent spread is the difference between the prices of two types of crude oil: West Texas Intermediate (WTI) on the long side and Brent Crude (Brent) on the short side.
+ For years, the price difference between the two has only been a few dollars on average. As both oils are very similar, their spread shows signs of strong predictability and usually oscillates around some average value.
+ Therefore, it is possible to use deviations from the fair spread value to bet on convergence back to fair value. Here we present a trading strategy based on the price deviations of the spread.
+
diff --git "a/04 Strategy Library/100 Trading with WTI BRENT Spread/01 \347\256\200\344\273\213.cn.html" "b/04 Strategy Library/100 Trading with WTI BRENT Spread/01 \347\256\200\344\273\213.cn.html"
new file mode 100644
index 0000000..1645559
--- /dev/null
+++ "b/04 Strategy Library/100 Trading with WTI BRENT Spread/01 \347\256\200\344\273\213.cn.html"
@@ -0,0 +1,3 @@
+
diff --git a/04 Strategy Library/100 Trading with WTI BRENT Spread/02 Method.html b/04 Strategy Library/100 Trading with WTI BRENT Spread/02 Method.html
new file mode 100644
index 0000000..fdcce3d
--- /dev/null
+++ b/04 Strategy Library/100 Trading with WTI BRENT Spread/02 Method.html
@@ -0,0 +1,121 @@
+
+ We download the WTI and Brent crude oil price from Macrotrends and import the csv file with the custom data downloader.
+ The unit is dollars per barrel.
+
+
+
+ class WTI(PythonData):
+ "Class to import WTI Spot Price(Dollars per Barrel) data from Dropbox"
+
+ def GetSource(self, config, date, isLiveMode):
+ return SubscriptionDataSource("https://www.dropbox.com/s/jpie3z6j0stp97d/wti-crude-oil-prices-10-year-daily.csv?dl=1", SubscriptionTransportMedium.RemoteFile)
+
+ def Reader(self, config, line, date, isLiveMode):
+ if not (line.strip() and line[1].isdigit()): return None
+ index = WTI()
+ index.Symbol = config.Symbol
+ try:
+ data = line.split(',')
+ index.Time = datetime.strptime(data[0], "%Y-%m-%d")
+ index.Value = Decimal(data[1])
+ except:
+ return None
+ return index
+
+ class BRENT(PythonData):
+ "Class to import BRENT Spot Price(Dollars per Barrel) data from Dropbox"
+
+ def GetSource(self, config, date, isLiveMode):
+ return SubscriptionDataSource("https://www.dropbox.com/s/w380c4n7xjmdqxl/brent-crude-oil-prices-10-year-daily.csv?dl=1", SubscriptionTransportMedium.RemoteFile)
+
+ def Reader(self, config, line, date, isLiveMode):
+ if not (line.strip() and line[1].isdigit()): return None
+ index = BRENT()
+ index.Symbol = config.Symbol
+ try:
+ data = line.split(',')
+ index.Time = datetime.strptime(data[0], "%Y-%m-%d")
+ index.Value = Decimal(data[1])
+ except:
+ return None
+ return index
+
+
+
+ The spread is defined as the difference between WTI price and Brent price. Next, we need to calculate the moving average of the spread series.
+ using the the indicator SimpleMovingAverage. As the indicator uses the price difference instead of the price series,
+ we need to manually initialize the indicator with the history request.
+
+ The fair value is calculated every day. If the current spread value is above SMA 20 then we enter a short position in the spread on close (betting that the spread will decrease to fair value represented by SMA 20).
+ The trade is closed at the close of the trading day when the spread crosses below fair value. If the current spread value is below SMA 20 then we enter a long position betting that the spread will increase and the trade is closed at the close of the trading day when the spread crosses above fair value.
+
+
+
+
+def OnData(self, data):
+ if not (data.ContainsKey("WTI") and data.ContainsKey("BRENT")): return
+ self.Plot("Spread Plot", "Spread", data["WTI"].Price - data["BRENT"].Price)
+
+ self.SpreadSMA.Update(self.Time, data["WTI"].Price - data["BRENT"].Price)
+ if not self.SpreadSMA.IsReady: return
+ spread = self.Securities["WTI"].Price - self.Securities["BRENT"].Price
+ fair_value =self.Securities["WTI"].Price - Decimal(self.regr.predict([[self.Securities["WTI"].Price]])[0])
+
+ if spread > self.SpreadSMA.Current.Value and not (self.Portfolio["WTI"].IsShort and self.Portfolio["BRENT"].IsLong):
+ self.SetHoldings("WTI", -0.5)
+ self.SetHoldings("BRENT", 0.5)
+ self.Plot("Spread Plot", "Long Spread Trade", data["WTI"].Price - data["BRENT"].Price)
+
+ elif spread < self.SpreadSMA.Current.Value and not (self.Portfolio["WTI"].IsLong and self.Portfolio["BRENT"].IsShort):
+ self.SetHoldings("WTI", 0.5)
+ self.SetHoldings("BRENT", -0.5)
+ self.Plot("Spread Plot", "Short Spread Trade", data["WTI"].Price - data["BRENT"].Price)
+
+ if self.Portfolio["WTI"].IsShort and self.Portfolio["BRENT"].IsLong and spread < fair_value:
+ self.Liquidate()
+
+ if self.Portfolio["WTI"].IsLong and self.Portfolio["BRENT"].IsShort and spread > fair_value:
+ self.Liquidate()
+
+
+
+ To demonstrate the trend of the spread series, we add the spread plot and mark the spread long/short point on the spread curve.
+
+ The expiration date for an options contract is the time when the contract is no longer valid.
+ The expiration date for listed stock options in the United States is usually the third Friday of the contract month, which is the month when the contract expires.
+ When that Friday falls on a holiday, the expiration date is on Thursday immediately before the third Friday.
+ The options expiration week is a week before options expiration.
+
+
+ During option-expiration weeks, a reduction occurs in option open interest as the near-term options approach their expiration and then expire.
+ According to a research from Chris and Licheng Returns and option activity over the option-expiration week for S&P 100 stocks,
+ Large-cap stocks with actively traded options tend to have higher average weekly returns during option-expiration weeks. In this algorithm, we'll use the real market data to explore the option expiration week effect.
+
+ S&P 100 index includes 102 leading U.S. stocks with exchange-listed options. The constituents represent almost 51% of the market capitalization of the U.S. equity market.
+ Here we trade the S&P 100 index ETF as a portfolio of U.S. large-cap stocks.
+
+
+ In the next step, we add the options to get their expiration dates. The range of expiration dates should bigger enough to include the
+ the contract which expires in this month.
+
+ To get a list of expiration dates from the contracts in the current option chain, we can use TradingCalendar object.
+ It allows us to filter the calendar days by the type TradingDayType.OptionExpiration and the start as well as the end date.
+ The expiry at the top of the list is the most recent expiration date.
+
+
+ The long position is opened at the start of the expiration week. Therefore, we use the scheduled event to fire the rebalance method every Monday.
+ If the current Monday is in the expiration week, we long the S&P 100 index ETF.
+
+
+
+def Rebalance(self):
+ calendar = self.TradingCalendar.GetDaysByType(TradingDayType.OptionExpiration, self.Time, self.EndDate)
+ expiries = [i.Date for i in calendar]
+ if len(expiries) == 0: return
+ self.lastest_expiry = expiries[0]
+
+ if (self.lastest_expiry - self.Time).days <= 5:
+ self.SetHoldings("OEF", 1)
+
+
+
+ The algorithm stays in cash during days out of the options expiration week.
+
diff --git a/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/01 Abstract.html b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/01 Abstract.html
new file mode 100644
index 0000000..7d69c19
--- /dev/null
+++ b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/01 Abstract.html
@@ -0,0 +1,7 @@
+
+ In this tutorial, we implement an intraday arbitrage strategy that capitalizes on deviations between two closely correlated
+ index ETFs. Even though at times both ETFs may hold different constituents and different weights of securities while tracking
+ the index, they are both highly correlated and extremely liquid. Researchers have shown these two properties are essential to
+ an arbitrage system's success. The algorithm we implement here is inspired by the work of Kakushadze and Serur (2018) and
+ Marshall, Nguyen, and Visaltanachoti (2010).
+
diff --git a/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/02 Background.html b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/02 Background.html
new file mode 100644
index 0000000..8c03fe6
--- /dev/null
+++ b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/02 Background.html
@@ -0,0 +1,9 @@
+
+ Marshall et al (2010) define an arbitrage opportunity as when the bid price of ETF A (B) diverts high enough away from the ask
+ price of ETF B (A) such that their quotient reaches a threshold. In their paper, an arbitrage opportunity is only acted upon
+ when the threshold is satisfied for 15 seconds. When these criteria are met, the algorithm enters the arbitrage trade by going
+ long ETF B (A) and short ETF A (B). When the spread reverts back to where the bid of ETF B (A) >= the ask of ETF A (B) for 15
+ seconds, the positions are liquidated. An overview of the trade process is illustrated in the image below.
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/03 Method.html b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/03 Method.html
new file mode 100644
index 0000000..ecac338
--- /dev/null
+++ b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/03 Method.html
@@ -0,0 +1,129 @@
+
Universe Selection
+
+ We implement a manual universe selection model that includes our two ETFs, SPY and IVV. The attached research notebook finds
+ the correlation of daily returns to be >0.99.
+
+
+
+tickers = ['IVV', 'SPY']
+symbols = [ Symbol.Create(t, SecurityType.Equity, Market.USA) for t in tickers ]
+self.SetUniverseSelection( ManualUniverseSelectionModel(symbols) )
+
+
+
+
Spread Adjustments
+
+ Plotting the ratio of the security prices shows its trending behavior.
+
+
+
+ Without adjusting this ratio over time, an arbitrage system would be stuck in a single trade for majority of the backtest. To
+ resolve this, we subtract a trailing mean from each data point.
+
+
+
+ Both of the above plots can be reproduced in the attached research notebook. During backtesting, this adjustment is done
+ during trading by setting up a
+ QuoteBarConsolidator for each security in our
+ universe. On each new consolidated QuoteBar, we
+ update the trailing window of L1 data, then calculate the latest spread adjustment values.
+
+
+
+# In OnSecuritiesChanged
+for symbol in self.symbols:
+ self.consolidators[symbol] = QuoteBarConsolidator(1)
+ self.consolidators[symbol].DataConsolidated += self.CustomDailyHandler
+ algorithm.SubscriptionManager.AddConsolidator(symbol, self.consolidators[symbol])
+
+def CustomDailyHandler(self, sender, consolidated):
+ # Add new data point to history while removing expired history
+ self.history[consolidated.Symbol]['bids'] = np.append(self.history[consolidated.Symbol]['bids'][1:], consolidated.Bid.Close)
+ self.history[consolidated.Symbol]['asks'] = np.append(self.history[consolidated.Symbol]['asks'][1:], consolidated.Ask.Close)
+
+ self.update_spread_adjusters()
+
+def update_spread_adjusters(self):
+ for i in range(2):
+ numerator_history = self.history[self.symbols[i]]['bids']
+ denominator_history = self.history[self.symbols[abs(i-1)]]['asks']
+ self.spread_adjusters[i] = (numerator_history / denominator_history).mean()
+
+
+
+
+
Alpha Construction
+
+ The ArbitrageAlphaModel monitors the intraday bid and ask prices of the securities in the universe. In the constructor, we
+ can specify the model parameters. In this tutorial, we select a shorter window an arbitrage opportunity must be active before
+ we act on it by setting `order_delay` to 3.
+
+ To emit insights, we check if either side of the arbitrage strategy warrants an entry. If no new entries are to be made, the
+ algorithm then looks to exit any current positions. With this design, we can flip our long/short bias without first
+ flattening our position. We use a practically-infinite insight durations as we do not know how long the algorithm will be in
+ an arbitrage trade.
+
+
+
+# Search for entries
+for i in range(2):
+ if quotebars[abs(i-1)].Bid.Close / quotebars[i].Ask.Close - self.spread_adjusters[abs(i-1)] >= self.pct_threshold:
+ self.entry_timer[i] += 1
+ if self.entry_timer[i] == self.order_delay:
+ self.exit_timer = [0, 0]
+ if self.long_side == i:
+ return []
+ self.long_side = i
+ return [Insight.Price(self.symbols[i], timedelta(days=9999), InsightDirection.Up),
+ Insight.Price(self.symbols[abs(i-1)], timedelta(days=9999), InsightDirection.Down)]
+ else:
+ return []
+ self.entry_timer[i] = 0
+
+# Search for an exit
+if self.long_side >= 0: # In a position
+ if quotebars[self.long_side].Bid.Close / quotebars[abs(self.long_side-1)].Ask.Close - self.spread_adjusters[self.long_side] >= 0: # Exit signal
+ self.exit_timer[self.long_side] += 1
+ if self.exit_timer[self.long_side] == self.order_delay: # Exit signal lasted long enough
+ self.exit_timer[self.long_side] = 0
+ i = self.long_side
+ self.long_side = -1
+ return [Insight.Price(self.symbols[i], timedelta(days=9999), InsightDirection.Flat),
+ Insight.Price(self.symbols[abs(i-1)], timedelta(days=9999), InsightDirection.Flat)]
+ else:
+ return []
+return []
+
diff --git a/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/04 Algorithm.html b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/04 Algorithm.html
new file mode 100644
index 0000000..c59088b
--- /dev/null
+++ b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/05 Relative Performance.html b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/05 Relative Performance.html
new file mode 100644
index 0000000..2d3e6c9
--- /dev/null
+++ b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/05 Relative Performance.html
@@ -0,0 +1,93 @@
+
+ We analyze the performance of this strategy by comparing it to the S&P 500 ETF benchmark, SPY. We notice that the
+ strategy has a lower Sharpe ratio over all of our testing periods than the benchmark, except for the Fall 2015
+ crisis where it achieved a 2.8 Sharpe ratio. The strategy also has a lower annual standard deviation of returns
+ when compared to the SPY, implying more consistent returns over time. A breakdown of the strategy's performance
+ across all our testing periods is displayed in the table below.
+
+ The lack of performance for this arbitrage strategy is mostly attributed to the fees it incurs while trading. This
+ is common for an intraday arbitrage strategy, but we discuss ways to reduces these fees in the conclusion of this
+ tutorial. After removing the costs of commissions, crossing the spread, and slippage, the strategy outperforms the
+ SPY over the entire backtesting period. Without these costs, the strategy generates a 1.09 Share ratio while the
+ SPY generates a 0.732 Sharpe ratio. See the backtest performance without fees below.
+
+
+
+
+
+
+
+
+
diff --git a/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/06 Market & Competition Qualification.html b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/06 Market & Competition Qualification.html
new file mode 100644
index 0000000..c76ecb6
--- /dev/null
+++ b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/06 Market & Competition Qualification.html
@@ -0,0 +1,19 @@
+
+ Although this strategy passes several of the
+ metrics required for Alpha Streams
+ and the Quant League competition, it requires further work to pass the following requirements:
+
+
+
+
+
Profitable
+
PSR >= 80%
+
Max drawdown duration <= 6 months
+
Insights contain the following properties: Symbol, Duration, Direction, and Weight
+
Alphas need to place at least 10 trades per month for the majority of the backtest
+
+
+
+ The algorithm currently places trades during 12 unique months throughout the backtest. Since the backtest spans
+ across 61 months, it places trades through a minority of the backtest.
+
diff --git a/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/07 Conclusion.html b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/07 Conclusion.html
new file mode 100644
index 0000000..3df342d
--- /dev/null
+++ b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/07 Conclusion.html
@@ -0,0 +1,10 @@
+
+ The intraday arbitrage strategy we built and tested throughout this tutorial underperforms the SPY benchmark in
+ terms of Sharpe ratio when including trading costs. Without these costs, we found the strategy outperforms the SPY
+ in terms of Sharpe ratio. In our implementation, we specified the alpha model to initiate trading when atleast a
+ 0.02% profit threshold is reached for 3 seconds. Both of these parameters are set lower than the strategy examined
+ in Marshall et al (2010) for demonstration purposes. Increasing the profit threshold will lead to more profitable,
+ but fewer, trades that may overcome the cost of trading. We leave this area of study for future research.
+ Additional areas of future research include increasing the resolution of data from second to tick and incorportating
+ an execution model that utilizes limit orders to reduce fees.
+
diff --git a/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/08 References.html b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/08 References.html
new file mode 100644
index 0000000..a684227
--- /dev/null
+++ b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/08 References.html
@@ -0,0 +1,8 @@
+
+
+ Marshall, Ben R. and Nguyen, Nhut (Nick) Hoang and Visaltanachoti, Nuttawat, ETF Arbitrage: Intraday Evidence (November 16, 2010). Online copy
+
+
+ Kakushadze, Zura and Serur, Juan Andrés, 151 Trading Strategies (August 17, 2018). Z. Kakushadze and J.A. Serur. 151 Trading Strategies. Cham, Switzerland: Palgrave Macmillan, an imprint of Springer Nature, 1st Edition (2018), XX, 480 pp; ISBN 978-3-030-02791-9. Online copy
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/01 Abstract.html b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/01 Abstract.html
new file mode 100644
index 0000000..a6cf634
--- /dev/null
+++ b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/01 Abstract.html
@@ -0,0 +1,6 @@
+
+ In this tutorial, we apply Deep Learning Classification in an attempt to forecast the movement of future stock prices.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/02 Introduction.html b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/02 Introduction.html
new file mode 100644
index 0000000..1fa0f4e
--- /dev/null
+++ b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/02 Introduction.html
@@ -0,0 +1,8 @@
+
+ Various time series forecasting models (SMA, EMA, etc.) have been applied to stocks to forecast price movements.
+ More recently, with the advent of Neural Networks, which have seen applications in several fields, ranging from
+ medicine to fraud detection, researchers have tried to apply Neural Networks to the markets in an attempt to forecast price
+ movements. Convolutional Neural Networks (CNNs) are a class of Neural Networks most widely known for their use in
+ image classification, and now, researchers are applying CNNs to extract patterns, also known as features, from times-series
+ data to forecast future stock prices.
+
diff --git a/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/03 Method.html b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/03 Method.html
new file mode 100644
index 0000000..e56515f
--- /dev/null
+++ b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/03 Method.html
@@ -0,0 +1,283 @@
+
Overview
+
+ Our strategy is to develop a Temporal Convolutional Neural Network model and train our model on historical OHLCV data
+ to predict the movement of future prices. Then, when trading, we take the most recent data, feed it into our model, and
+ bet on the direction of the price movement based on our model prediction. We will walk through the code required
+ for building the Neural Network Architecture and for preparing the data for our model, as this part is the harder part to understand.
+
+
+
Inputs/Outputs
+
+
+ Before we build our Neural Network Architecture, we need to understand the inputs and outputs to our model.
+ The input to the model will be the OHLC+Volume data for t-14 to t time steps (past 15 time steps). The output is a
+ direction (Up, Down, Stationary) of the movement of the average close of the t+1 to t+5 time steps (5 future timestamps).
+ The movement is considered stationary if the abs(% change 5-step average close) < .01%. These three directions will
+ form the labels for which our model will try to classify, thus we have a classification problem.
+
+
+
+
Neural Network Model Architecture
+
+
+ Now, we will need to build our Neural Network Architecture, which we will build using Keras,
+ a high-level Python Deep Learning API. To begin, we will need a few import statements:
+
+
+
+
+ import tensorflow as tf
+ from tensorflow.keras.layers import Input, Conv1D, Dense, Lambda, Flatten, Concatenate
+ from tensorflow.keras import Model
+ from tensorflow.keras import metrics
+ from tensorflow.keras.losses import CategoricalCrossentropy
+ from tensorflow.keras import utils
+ from sklearn.preprocessing import StandardScaler
+ import numpy as np
+ import math
+
+
+
+
+
+ We start with an Input Layer, where training and testing data are initially accepted. With 15 time steps and 5 input
+ variables (OHLCV), our input shape will be 15 x 5.
+
+
+
+
+ inputs = Input(shape=(15, 5))
+
+
+
+
+
+ We then feed this Layer into our Convolutional Layer, where we extract features, which will serve as
+ the Neural Network's method of extracting patterns from the time-series data.
+
+ input_vars define the variables we want to use to make our predictions. The class Direction
+ defines a few integers that we will label our data with (labels are needed for classification problems). The reason
+ we use integers instead of strings is because Keras, like most ML libraries, only work with numerical data. Moving on,
+ rolling_avg_window_size is the number of time steps used for the calculate the average of future closing prices,
+ described earlier in
+ Inputs/Outputs (t+1 to t+5 is 5 time steps, thus this value accordingly is set to 5).
+ The constant stationary_threshold defines the threshold for a change in price to be considered
+ stationary, and this change also described in Inputs/Outputs. The shift is the shift needed to align
+ the average value (mentioned earlier), in our pandas DataFrame to make it easier for us to slice our DataFrame into pieces
+ manageable for our Neural Network model. The scaler object will be used later to scale our data.
+ The purpose of the variables will become clearer in use.
+
+ Next, say we are at time t in the pandas DataFrame, to calculate the average closing prices of t+1 to t+5, and calculate
+ the percent change from the close at t, we use the following lines of code:
+
+ The rolling mean should be self explanatory for those familiar with pandas (if not, I hope by now readers realize
+ this is a more advanced resource).
+ Here, .shift(shift) aligns the five time step rolling average 'close_avg' column to the end of the last
+ time step we want to use as an input for prediction, and this action will make slicing up the DataFrame into input
+ and labeled data for our model much easier.
+
+
+
+ To label our data, we need to first define a function that we will use with the DataFrame's apply() method.
+ Usually, lambda functions are used for this purpose, however, our function's logic will not fit inside a lambda.
+
+ With our labels in place, we can now slice up our DataFrame into pieces manageable for our model and collect them into
+ lists:
+
+
+
+
+ data = []
+ labels = []
+
+ for i in range(len(df)-self.n_tsteps+1+shift):
+ label = df['movement_labels'].iloc[i+self.n_tsteps-1]
+ data.append(df[input_vars].iloc[i:i+self.n_tsteps].values)
+ labels.append(label)
+
+ data = np.array(data)
+
+
+
+
+ Here, we iterate numerically through the DataFrame, with a carefully calculated value in our range()
+ function to make sure we do access an out-of-bounds index. We cast the list of numpy arrays to a numpy array because
+ Keras works best with numpy arrays.
+
+
+
+ Now, we need to scale our data. It is good practice to scale data when using Machine Learning models so that the
+ range of values is normalized across the features.
+
+
+
+
+ dim1, dim2, dim3 = data.shape
+ data = data.reshape(dim1*dim2, dim3)
+ data = scaler.fit_transform(data)
+ data = data.reshape(dim1, dim2, dim3)
+
+
+
+
+ The reason we reshape the data before the scaling is because sklearn is only able to handle 2D data, but right after,
+ we can return the data to the original shape with another reshaping.
+
+
+
+ Finally, since Keras requires the labels to be dummified (which essentially turns a list of labels into a matrix of
+ 1s and 0s, where the index of the 1 is equal to the value of the integer label), we use the following:
+
+ Specifying num_classes to 3 ensures our matrix will have three columns, one for each label (Up, Down, Stationary).
+
+
+
+ We have now finished the walk through of the difficult parts of the code.
+
+
+
Trading
+
+
+ After we feed in the prepared data into the model (the corresponding code, as well as the rest of the code, can be
+ found in Algorithm) we can
+ use our model to make predictions. We take the most recent 15 bars of OHLCV data and apply our model on it to make
+ a prediction. If the model predicts with above 55% confidence that the future direction is up (resp. down), we emit
+ an Price Insight with direction InsightDirection.Up (resp. InsightDirection.Down). Since we are
+ betting on the direction of the average of the future five closing prices, it would be intuitive to emit an Insights
+ in the respective direction for timedeltas of one through five. However, we choose to only emit an Insight
+ with a timedelta with a random integer between one and five to constrain the number of insights we emit.
+
+ As an additional note, we decided to set the trading fees to zero (the default fee
+ is one dollar per trade), or else our algorithm will only lose money due to the frequency at which we trade.
+
+
+
+
The Rest
+
+
+ We have covered the difficult aspects of the code, as well as give an overview of our strategy. The rest of the
+ necessary code to execute the strategy can be found in Algorithm.
+
+
+
+
+
diff --git a/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/04 Algorithm.html b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/04 Algorithm.html
new file mode 100644
index 0000000..0a1b0bd
--- /dev/null
+++ b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/05 Results.html b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/05 Results.html
new file mode 100644
index 0000000..a9d5b42
--- /dev/null
+++ b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/05 Results.html
@@ -0,0 +1,6 @@
+
+ Since our algorithm is non-deterministic, users should expect to see different results in repeated backtests. From
+ running our algorithm ten times, we achieved Sharpe Ratios with an average of .211, a maximum of 0.917, and minimum
+ of -0.312, and a standard deviation of 0.327. As we traded three technology stocks, we compare our results to QQQ.
+ Comparing our algorithm to QQQ, our average Sharpe of .211 is significantly lower than the 0.967 Sharpe of QQQ.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/06 References.html b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/06 References.html
new file mode 100644
index 0000000..dedbeb6
--- /dev/null
+++ b/04 Strategy Library/1024 Forecasting Stock Prices using a Temporal CNN Model/06 References.html
@@ -0,0 +1,7 @@
+
+
+ Nikolaos Passalis, Anastasios Tefas, Juho Kanniainen, Moncef Gabbouj, Alexandros Iosifidis:
+ "Temporal Logistic Neural Bag-of-Features for Financial Time series Forecasting leveraging Limit Order Book Data", 2019;
+ https://arxiv.org/pdf/1901.08280.pdf.
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/01 Abstract.html b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/01 Abstract.html
new file mode 100644
index 0000000..6e0ee07
--- /dev/null
+++ b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/01 Abstract.html
@@ -0,0 +1,3 @@
+
+ In this tutorial, we attempt to beat the returns of the S&P500 Index using leverage and systematic risk management.
+
diff --git a/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/02 Introduction.html b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/02 Introduction.html
new file mode 100644
index 0000000..0b1b370
--- /dev/null
+++ b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/02 Introduction.html
@@ -0,0 +1,9 @@
+
+ When measuring the profitability of a strategy, it is usually not enough to be profitable, as it should also beat
+ the benchmark, for which the SP500 Index is most commonly used. If not, what would be the reason to not just invest
+ in a low-cost SP500 index instead (not accounting for risk)? However, what if we could beat the SP500 with the SP500?
+ This is what Gayed et al. proposed with their strategy of using Leveraged SP500 indices with Systematic Risk Management.
+ They propose that Moving Averages are a good method to assess volatility in the market, and they use it to manage risk,
+ which is especially important since the effects of price swings in a leveraged ETF are magnified due to the leverage.
+ With this method, we hope to outperform the SP500 while at the same time, attempt to reduce drawdown.
+
diff --git a/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/03 Method.html b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/03 Method.html
new file mode 100644
index 0000000..a43a70e
--- /dev/null
+++ b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/03 Method.html
@@ -0,0 +1,12 @@
+
+ We develop hold/liquidate positions based on the 200-day Simple Moving Average (SMA) of our ETF, for which we use SSO,
+ a 2x leveraged SP500 index ETF. With 200 days instead of using fewer days, say 50, we reduce the number of trades per year,
+ thereby reducing transaction costs and the effects of slippage. Moving on, if the current price of SOO is above the 200-day SMA,
+ we hold SSO, and if SSO dips below our 200-day SMA, we sell liquidate our position and rotate our position into short-term
+ treasuries, which is done through SHY, an ETF that tracks 1-3 year U.S. Treasury Bonds. If we are holding SHY, and the
+ current price of SSO moves above the 200-day SMA, then we rotate back into SSO and liquidate SHY.
+
+
+
+
+
diff --git a/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/04 Algorithm.html b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/04 Algorithm.html
new file mode 100644
index 0000000..3b0ead5
--- /dev/null
+++ b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/05 Results.html b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/05 Results.html
new file mode 100644
index 0000000..ade26d7
--- /dev/null
+++ b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/05 Results.html
@@ -0,0 +1,4 @@
+
+ We use the S&P 500 as our benchmark, which we track by using the SPY ETF. Our strategy yielded a Sharpe Ratio of .732
+ over the past five years, while buying and holding SPY for the same period yielded a Sharpe Ratio of .572.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/06 References.html b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/06 References.html
new file mode 100644
index 0000000..c1ce885
--- /dev/null
+++ b/04 Strategy Library/1025 Leveraged ETFs with Systematic Risk Management/06 References.html
@@ -0,0 +1,7 @@
+
+
+ Gayed, Michael and Bilello, Charles, Leverage for the Long Run - A Systematic Approach to Managing Risk and
+ Magnifying Returns in Stocks (March 3, 2016). 2016 Charles H. Dow Award.
+ Online Copy.
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1026 Intraday ETF Momentum/01 Abstract.html b/04 Strategy Library/1026 Intraday ETF Momentum/01 Abstract.html
new file mode 100644
index 0000000..c9aef2c
--- /dev/null
+++ b/04 Strategy Library/1026 Intraday ETF Momentum/01 Abstract.html
@@ -0,0 +1,7 @@
+
+ In this tutorial, we implement an intraday momentum strategy that trades some of the most actively traded ETFs.
+ Specifically, we observe the return generated from the first half-hour of the trading day to predict the sign of
+ the trading day's last half-hour return. Researchers have shown that this momentum pattern is statistically and
+ economically significant, even after accounting for trading fees. The algorithm we design here is a recreation of
+ the research completed by Gao, Han, Li, and Zhou (2017).
+
+ News items are usually released before the opening bell. As it takes time for traders to digest and interpret the
+ news, the first half-hour of trading typically has relatively higher levels of volume and volatility. Additionally,
+ as traders attempt to mitigate overnight risk by unloading positions near the close, the last half-hour of trading
+ also sees these higher levels of volume and volatility. These characteristics can be observed from the image below,
+ which is reproducible in the attached research notebook.
+
+
+
+
+
+ Bogousslavsky (2016) points out that some investors are late-informed or simply prefer to delay their trading until
+ the market close. As a result, a positive correlation exists between the direction of the opening and closing
+ periods. Gao et al (2017) find that when trading this momentum strategy, the average annual return over their
+ sample period was 6.67% for SPY, 11.72% for IWM, and 24.22% for IYR. Equal-weighting these returns leads to a
+ combined average annual return of 14.2%.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1026 Intraday ETF Momentum/03 Method.html b/04 Strategy Library/1026 Intraday ETF Momentum/03 Method.html
new file mode 100644
index 0000000..29481ab
--- /dev/null
+++ b/04 Strategy Library/1026 Intraday ETF Momentum/03 Method.html
@@ -0,0 +1,143 @@
+
Universe Selection
+
+ We implement a manual universe selection model that supplies a subset of the proposed ETFs in the attached research
+ paper. Gao et al (2017) select the following tickers: DIA, QQQ, IWM, EEM, FXI, EFA, VWO, XLF, IYR, and TLT. In an
+ effort to increase the backtest performance, we narrow our universe to SPY, IWM, and IYR.
+
+
+
+tickers = ['SPY', # S&P 500
+ 'IWM', # Russell 2000
+ 'IYR' # Real Estate ETF
+]
+symbols = [ Symbol.Create(ticker, SecurityType.Equity, Market.USA) for ticker in tickers ]
+self.SetUniverseSelection( ManualUniverseSelectionModel(symbols) )
+self.UniverseSettings.Resolution = Resolution.Minute
+
+
+
+
Alpha Construction
+
+ The IntradayMomentumAlphaModel emits insights to take positions for the last `return_bar_count` minutes of the day
+ in the direction of the return for the first `return_bar_count` minutes of the day. During construction, we create
+ a dictionary to store IntradayMomentum data for each symbol, define a method to determine the sign of returns, and
+ specify the value of `return_bar_count`. In this tutorial, we follow Gao et al (2017) in setting `return_bar_count`
+ to 30 by default.
+
+ When a new security is added to the universe, we create an IntradayMomentum object for it to store information
+ needed to calculate morning returns. The management of the IntradayMomentum objects occurs in the alpha model's
+ OnSecuritiesChanged method.
+
+
+
+def OnSecuritiesChanged(self, algorithm, changes):
+ for security in changes.AddedSecurities:
+ self.intraday_momentum_by_symbol[security.Symbol] = IntradayMomentum(security, algorithm)
+
+ for security in changes.RemovedSecurities:
+ self.intraday_momentum_by_symbol.pop(security.Symbol, None)
+
+
+
+
+ The definition of the IntradayMomentum class is shown below. We save a reference to the security's exchange so we
+ can access the market hours of the exchange when generating insights.
+
+ With each call to the alpha model's Update method, we count the number of bars the algorithm has received for each
+ symbol. If we've reached the end of the morning window, we calculate the morning return. If we are at the
+ beginning of the close window, we emit an insight in the direction of the morning window's return. If we are at
+ the end of the day, we save the closing price and reset the counter for the number of bars seen today.
+
+
+
+def Update(self, algorithm, slice):
+ insights = []
+
+ for symbol, intraday_momentum in self.intraday_momentum_by_symbol.items():
+ if slice.ContainsKey(symbol) and slice[symbol] is not None:
+ intraday_momentum.bars_seen_today += 1
+
+ # End of the morning return
+ if intraday_momentum.bars_seen_today == self.return_bar_count:
+ intraday_momentum.morning_return = (slice[symbol].Close - intraday_momentum.yesterdays_close) / intraday_momentum.yesterdays_close
+
+ ## Beginning of the close
+ next_close_time = intraday_momentum.exchange.Hours.GetNextMarketClose(slice.Time, False)
+ mins_to_close = int((next_close_time - slice.Time).total_seconds() / 60)
+
+ if mins_to_close == self.return_bar_count + 1:
+ insight = Insight.Price(intraday_momentum.symbol,
+ next_close_time,
+ self.sign(intraday_momentum.morning_return))
+ insights.append(insight)
+ continue
+
+ # End of the day
+ if not intraday_momentum.exchange.DateTimeIsOpen(slice.Time):
+ intraday_momentum.yesterdays_close = slice[symbol].Close
+ intraday_momentum.bars_seen_today = 0
+
+ return insights
+
+
+
+
Trade Execution
+
+ The attached research paper holds positions for the last 30 minutes of the trading day, exiting at the market close.
+ In order to accomplish this, we create a custom execution model. The model defined below submits a market order for
+ the entry while also submitting a market on close order in the same time step.
+
+
+
+class CloseOnCloseExecutionModel(ExecutionModel):
+ def __init__(self):
+ self.targetsCollection = PortfolioTargetCollection()
+ self.invested_symbols = []
+
+ def Execute(self, algorithm, targets):
+ # for performance we check count value, OrderByMarginImpact and ClearFulfilled are expensive to call
+ self.targetsCollection.AddRange(targets)
+ if self.targetsCollection.Count > 0:
+ for target in self.targetsCollection.OrderByMarginImpact(algorithm):
+ # calculate remaining quantity to be ordered
+ quantity = OrderSizing.GetUnorderedQuantity(algorithm, target)
+ if quantity == 0:
+ continue
+
+ algorithm.MarketOrder(target.Symbol, quantity)
+ algorithm.MarketOnCloseOrder(target.Symbol, -quantity)
+
+ self.targetsCollection.ClearFulfilled(algorithm)
+
\ No newline at end of file
diff --git a/04 Strategy Library/1026 Intraday ETF Momentum/05 Conclusion.html b/04 Strategy Library/1026 Intraday ETF Momentum/05 Conclusion.html
new file mode 100644
index 0000000..bad583b
--- /dev/null
+++ b/04 Strategy Library/1026 Intraday ETF Momentum/05 Conclusion.html
@@ -0,0 +1,106 @@
+
+ We conclude that the momentum pattern documented by Gao et al (2017) produces lower returns over our testing period.
+ Comparing the strategy to the S&P 500 benchmark, the strategy has a lower Sharpe ratio during the backtesting
+ period and during the recovery from the 2020 stock market crash. However, the strategy greatly outperforms the
+ benchmark during the downfall of the 2020 crash, achieving a 4.8 Sharpe ratio. Throughout all of the time periods
+ we tested, the strategy had a lower annual standard deviation than the benchmark, meaning more consistent returns.
+ A breakdown of the results from all of the testing periods can be seen in the table below.
+
+ We find the lack of performance for this strategy is not largely attributed to the inclusion of transaction costs
+ in our analysis while Gao et al (2017) decide to ignore them. Even with ignoring the transaction fees, spread costs,
+ and slippage, the strategy still has a lower Sharpe ratio than the S&P 500 and doesn't match the results found in the
+ original research paper. Refer to the backtest results.
+
+
+
+ Throughout their research paper, Gao et al (2017) provide several suggestions to increase the return generated by
+ this momentum pattern. These areas of future research include:
+
+
+
+
+ Trading only on days with economic news events by utilizing the
+ TradingEconomics data set.
+ Gae et al (2017) suggest using the Michigan Consumer Sentiment Index, and news released on gross domestic
+ product or the consumer price index.
+
+
Restricting trading to times of greater volatility or during financial crises.
+
Incorporating a volume threshold the morning session must pass to signal a trade for the close.
+
Increasing diversification by extending the universe to include ETFs from other sectors.
+
+ Considering the return from multiple n-minute periods throughout the day to predict the return of the closing
+ period.
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1026 Intraday ETF Momentum/06 References.html b/04 Strategy Library/1026 Intraday ETF Momentum/06 References.html
new file mode 100644
index 0000000..a3127a1
--- /dev/null
+++ b/04 Strategy Library/1026 Intraday ETF Momentum/06 References.html
@@ -0,0 +1,6 @@
+
+
+ Gao, Lei and Han, Yufeng and Li, Sophia Zhengzi and Zhou, Guofu, Market Intraday Momentum (June 19, 2017).
+ Online copy
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/01 Abstract.html b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/01 Abstract.html
new file mode 100644
index 0000000..d02e534
--- /dev/null
+++ b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/01 Abstract.html
@@ -0,0 +1,9 @@
+
+ Several studies have found that press releases and other media can impact the perspective of investors. In this
+ tutorial, we implement an intraday strategy to capitalize on the upward drift in the stock prices of drug
+ manufacturers following positive news releases. Our findings show that when combining the effect with the
+ day-of-the-week anomaly documented by Berument & Kiymaz (2001), there is enough directional accuracy for the
+ trading system to remain profitable throughout the 2020 stock market crash. However, the algorithm
+ underperforms the S&P 500 market index ETF, SPY, over the same time period. The algorithm we design here is
+ inspired by the work of Isah, Shah, & Zulkernine (2018).
+
diff --git a/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/02 Background.html b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/02 Background.html
new file mode 100644
index 0000000..60fe4eb
--- /dev/null
+++ b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/02 Background.html
@@ -0,0 +1,14 @@
+
+ The use of alternative data sets to forecast stock prices has increased in recent years as the fundamental and
+ technical analysis spaces increase in competition. Utilizing Natural Language Processing (NLP) techniques to
+ analyze the sentiment of news releases and other text related to publicly traded companies has caught the interest
+ of many quant researchers. Such online information is frequently released and can be interpreted in a virtually
+ unlimited number of ways, leading to a novel approach to determining the "societal mood" (Isah et al, 2018, p. 2)
+ towards a company.
+
+
+
+ There are several ways to implement a NLP system. In this tutorial, we utilize a dictionary to quantify the
+ sentiment of news releases. The dictionary provided herein was sourced from Isah et al (2018), where it's use
+ achieved a 70% accuracy when targeting several hand-picked stocks in India's pharmaceutical industry.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/03 Method.html b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/03 Method.html
new file mode 100644
index 0000000..ac080d3
--- /dev/null
+++ b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/03 Method.html
@@ -0,0 +1,183 @@
+
Universe Selection
+
+ We implement a universe selection model that provides the trading system with companies classified by
+ MorningStar as being in the drug
+ manufacturing industry group. We narrow our universe to include only the drug manufacturers with the greatest PE
+ ratios and dollar volume.
+
+
+
+def SelectCoarse(self, algorithm, coarse):
+ has_fundamentals = [c for c in coarse if c.HasFundamentalData]
+ sorted_by_dollar_volume = sorted(has_fundamentals, key=lambda c: c.DollarVolume, reverse=True)
+ return [ x.Symbol for x in sorted_by_dollar_volume[:self.coarse_size] ]
+
+def SelectFine(self, algorithm, fine):
+ drug_manufacturers = [f for f in fine if f.AssetClassification.MorningstarIndustryGroupCode == MorningstarIndustryGroupCode.DrugManufacturers]
+ sorted_by_pe = sorted(drug_manufacturers, key=lambda f: f.ValuationRatios.PERatio, reverse=True)
+ return [ x.Symbol for x in sorted_by_pe[:self.fine_size] ]
+
+
+
+
+
Alpha Construction
+
+ The DrugNewsSentimentAlphaModel emits insights to take long intraday positions for securities that have positive
+ news sentiment. During construction of the model, we:
+
+
+
+
Create a dictionary to store SymbolData for each symbol
+
Gather the sentiment dictionary provided by Isah et al (2018)
+
Determine the maximum number of grams we need to analyze news articles
+
Define a method to determine the sign of sentiment
+
Specify the value of `bars_before_insight`
+
+
+
+ The `bars_before_insight` parameter determines how many bars the alpha model should observe after the market opens
+ before emitting insights. Isah et al (2018) batch the news released by each company into 30-minute intervals
+ before analyzing the sentiment of the batch. In this tutorial, we follow a similar procedure by setting
+ `bars_before_insight` to 30.
+
+ When a new security is added to the universe, we create a SymbolData object for it to store information unique to
+ each security. The management of the SymbolData objects occurs in the alpha model's OnSecuritiesChanged method.
+
+
+
+
+def OnSecuritiesChanged(self, algorithm, changes):
+ for security in changes.AddedSecurities:
+ self.symbol_data_by_symbol[security.Symbol] = SymbolData(security, algorithm)
+
+ for security in changes.RemovedSecurities:
+ symbol_data = self.symbol_data_by_symbol.pop(security.Symbol, None)
+ if symbol_data:
+ algorithm.RemoveSecurity(symbol_data.tiingo_symbol)
+
+
+
+
+ The definition of the SymbolData class is shown below. We add properties to it to track the cumulative sentiment
+ of news releases over time and the number of bars the alpha model has received for each security since the market
+ open. In the constructor, we save a reference to the security's exchange so we can access the market hours of the
+ exchange when generating insights. This is also where we initialize the
+ Tiingo news feed for each security.
+
+ As new Tiingo objects are provided to the alpha model's Update method, we update the cumulative sentiment for each
+ security. The cumulative sentiment counter is reset at each market close. Therefore, when we emit insights
+ 30-minutes after the open, we are considering the sentiment of the news articles released from the previous close
+ to the current time. We employ the findings of Berument & Kiymaz (2001), restricting the alpha model's trading to
+ Wednesday, the most profitable day of the week. Positions are entered 30-minutes after the open and exited at the
+ close.
+
+
+
+
+def Update(self, algorithm, data):
+ insights = []
+
+ for symbol, symbol_data in self.symbol_data_by_symbol.items():
+
+ # If it's after-hours or within 30-minutes of the open, update
+ # cumulative sentiment for each symbol
+ if symbol_data.bars_seen_today < self.bars_before_insight:
+ tiingo_symbol = symbol_data.tiingo_symbol
+ if data.ContainsKey(tiingo_symbol) and data[tiingo_symbol] is not None:
+ article = data[tiingo_symbol]
+ symbol_data.cumulative_sentiment += self.CalculateSentiment(article)
+
+ if data.ContainsKey(symbol) and data[symbol] is not None:
+ symbol_data.bars_seen_today += 1
+
+ # 30-mintes after the open, emit insights in the direction of the cumulative sentiment.
+ # Only emit insights on Wednesdays to capture the analomaly documented by Berument and
+ # Kiymaz (2001).
+ if symbol_data.bars_seen_today == self.bars_before_insight and data.Time.weekday() == 2:
+ next_close_time = symbol_data.exchange.Hours.GetNextMarketClose(data.Time, False)
+ direction = self.sign(symbol_data.cumulative_sentiment)
+ if direction == 0:
+ continue
+ insight = Insight.Price(symbol,
+ next_close_time - timedelta(minutes=2),
+ direction)
+ insights.append(insight)
+
+ # At the close, reset the cumulative sentiment
+ if not symbol_data.exchange.DateTimeIsOpen(data.Time):
+ symbol_data.cumulative_sentiment = 0
+ symbol_data.bars_seen_today = 0
+
+ return insights
+
+
+
+
+
Calculating Sentiment
+
+ We define the following helper method to return the sentiment of a Tiingo news article by analyzing the article's
+ title and description. The `sentiment_by_phrase` dictionary was retrieved from queensbamlab's
+ NewsSentiment GitHub repository. Although we have
+ adjusted the dictionary to lowercase and removed some redundancies, this is the same dictionary used by Isah et
+ al (2018). "The dictionary was created by leveraging author's domain expertise and thorough analysis of news
+ articles over the years" (p. 3).
+
+
+
+
+def CalculateSentiment(self, article):
+ sentiment = 0
+ for content in (article.Title, article.Description):
+ words = content.lower().split()
+ for num_words in range(1, self.max_phrase_words + 1):
+ for gram in ngrams(words, num_words):
+ phrase = ' '.join(gram)
+ if phrase in self.sentiment_by_phrase.keys():
+ sentiment += self.sentiment_by_phrase[phrase]
+ return sentiment
+
+
diff --git a/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/04 Algorithm.html b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/04 Algorithm.html
new file mode 100644
index 0000000..43dfb6f
--- /dev/null
+++ b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/05 Conclusion.html b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/05 Conclusion.html
new file mode 100644
index 0000000..8f0a19e
--- /dev/null
+++ b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/05 Conclusion.html
@@ -0,0 +1,27 @@
+
+ We conclude that deploying the sentiment analysis strategy on the US drug manufacturing industry does not provide
+ as accurate of results as found by Isah et al (2018). Only after restricting trading to the most profitable day of
+ the week (Berument & Kiymaz, 2001) does the strategy achieve profitability over our testing period. Overall, the
+ strategy produces a Sharpe ratio of 0.116, while the
+ SPY benchmark
+ produces a 0.971 Sharpe ratio during the same period. We attribute the decrease in performance to the commissions
+ and spread costs simulated by LEAN.
+
+
+
+To continue the development of this strategy, future areas of research include:
+
+
+
+
Adding a threshold parameter the cumulative sentiment counter must pass to signal trades
+
+ Only analyzing the sentiment of articles which contain keywords like "US, "USA", 'Q1', and others in their
+ titles
+
+
+ Stemming and removing
+ punctuation from articles before calculating their sentiment
+
+
Adding phrases to the sentiment dictionary or adjust the sentiment values
+
Adding other data feeds beside just Tiingo
+
\ No newline at end of file
diff --git a/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/06 References.html b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/06 References.html
new file mode 100644
index 0000000..8f8f421
--- /dev/null
+++ b/04 Strategy Library/1027 Using News Sentiment to Predict Price Direction of Drug Manufacturers/06 References.html
@@ -0,0 +1,11 @@
+
+
+ Shah, Dev, Haruna Isah, and Farhana Zulkernine. “Predicting the Effects of News Sentiments on the Stock Market.”
+ 2018 IEEE International Conference on Big Data (Big Data) (2018).
+ Online copy
+
+
+ Berument, Hakan and Kiymaz, Halil, The Day of the Week Effect on Stock Market Volatility (2001). Journal of
+ Economics and Finance, Vol.25, No.2, pp. 181-193. Online copy
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/01 Abstract.html b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/01 Abstract.html
new file mode 100644
index 0000000..587ce33
--- /dev/null
+++ b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/01 Abstract.html
@@ -0,0 +1,8 @@
+
+ Gurrib (2020) is the first published research paper to analyze the predictive power of Ichimoku Clouds for the
+ largest 10 stocks in the US energy sector. In this tutorial, we implement a similar strategy while reducing the
+ effect of look-ahead bias integrated into the original study. Our findings show that while the strategy has an
+ impressive 176 Sharpe ratio during the downfall of the 2020 oil price war, the strategy has worse performance than
+ found by Gurrib (2020). We discover that throughout a 5 year backtest, the strategy fails to beat the benchmark of
+ a popular energy sector ETF.
+
diff --git a/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/02 Introduction.html b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/02 Introduction.html
new file mode 100644
index 0000000..c5efef1
--- /dev/null
+++ b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/02 Introduction.html
@@ -0,0 +1,35 @@
+
+ A vast amount of research studies have been published which document mixed results when utilizing technical
+ analysis to forecast future prices of securities. The Ichimoku Cloud, one of the most widely-used technical
+ indicators in Japan, was first publicized by Goichi Hosoda. In 1996, Hidenobu Sasaki reworked the framework to
+ form the current charting analysis tool. This indicator is composed of 5 lines in a time series, each of which
+ are described mathematically in
+ online resources.
+
+
+
+ Gurrib (2020) finds that applying a simple trading strategy using the time series of the Ichimoku Cloud can
+ increase the mean return of a basket containing the top energy stocks from 21.5% (buy-and-hold) to 194% over a 7
+ year period. The components of the Ichimoku Cloud that Gurrib (2020) utilizes in this strategy are the Chikou
+ Span, Senkou Span A, and Senkou Span B. The Senkou Span lines form the top and bottom of the Ichimoku Cloud. The
+ strategy that we trade off of these lines is defined as follows:
+
+
+
+
Long when the Chikou line crosses the top of the cloud from below.
+
Short when the Chikou line crosses the bottom of the cloud from above.
+
+
+
+ For better understanding, here is a visualization of the price of XOM, it's Ichimoku Cloud time series, and the
+ resulting buy/sell signals.
+
+
+
+
+
+ Note: all of the plots throughout this tutorial are reproducible in the attached research notebook, along with
+ some descriptive statistics for securities in the universe.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/03 Method.html b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/03 Method.html
new file mode 100644
index 0000000..8669ce3
--- /dev/null
+++ b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/03 Method.html
@@ -0,0 +1,150 @@
+
Universe Selection
+
+ Gurrib (2020) selects a universe of the 10 largest-weighed constituents of the S&P Composite 1500 Energy Index
+ over the testing period. This inherently incorporates lookahead-bias into the study as the security weights are
+ sourced over the period the trading simulation occurs. Furthermore, since the publication of Gurrib (2020), some
+ of the securities have even been delisted. Thus, to eliminate lookahead-bias and avoid delistings, we implement a
+ universe selection model that provides the trading system with the 10 largest companies in the energy sector as of
+ the current date in the backtest. Since the largest companies change infrequently, we only refresh the universe on
+ a monthly basis.
+
+
+
+
+def SelectCoarse(self, algorithm, coarse):
+ if algorithm.Time.month == self.month:
+ return Universe.Unchanged
+ return [ x.Symbol for x in coarse if x.HasFundamentalData ]
+
+def SelectFine(self, algorithm, fine):
+ self.month = algorithm.Time.month
+
+ energy_stocks = [ f for f in fine if f.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.Energy ]
+ sorted_by_market_cap = sorted(energy_stocks, key=lambda x: x.MarketCap, reverse=True)
+ return [ x.Symbol for x in sorted_by_market_cap[:self.fine_size] ]
+
+
+
+
+
Alpha Construction
+
+ The IchimokuCloudCrossOverAlphaModel emits insights to hold a long position after the Chikou Span crosses over the
+ top of the cloud for a given security. Additionally, the strategy is made symmetrical by entering short positions
+ after the Chikou Span crosses below the bottom of the cloud. During construction of this alpha model, we simply
+ set up a dictionary to hold a SymbolData object for each symbol in the universe.
+
+ The SymbolData class constructor is shown below. We first set up two class variables, `previous_location` and
+ `direction`. The former enables the algorithm to signal when the Chikou Span crosses over the boundaries of the
+ Ichimoku Cloud. The latter is added to ensure we continue to emit daily insights in the proper direction. Inside
+ the `__init__` method is where we create the
+ IchimokuKinkoHyo indicator and warm
+ it up.
+
+ We define the following helper method to return the location of the Chikou Span with respect to the cloud. The
+ alpha model utilizes this helper method to determine when the Chikou Span is exiting the Ichimoku Cloud.
+
+ As new TradeBars are provided to the
+ alpha model's Update method, we update the Ichimoku indicator of each symbol. We then emit insights for the
+ symbols that have their Chikou Span breaking out of their respective Ichimoku Cloud in a new direction. To
+ maintain positions while we wait for another crossover in the Ichimoku Cloud, we emit insights on a daily basis
+ with 1-day duration.
+
+
+
+
+def Update(self, algorithm, data):
+ insights = []
+
+ for symbol, symbol_data in self.symbol_data_by_symbol.items():
+ if not data.ContainsKey(symbol) or data[symbol] is None:
+ continue
+
+ # Update indicator with the latest TradeBar
+ symbol_data.ichimoku.Update(data[symbol])
+
+ # Determine insight direction
+ current_location = symbol_data.get_location()
+ if symbol_data.previous_location is not None: # Indicator is ready
+ if symbol_data.previous_location != 1 and current_location == 1:
+ symbol_data.direction = InsightDirection.Up
+ if symbol_data.previous_location != -1 and current_location == -1:
+ symbol_data.direction = InsightDirection.Down
+
+ symbol_data.previous_location = current_location
+
+ # Emit insight
+ if symbol_data.direction:
+ insight = Insight.Price(symbol, timedelta(days=1), symbol_data.direction)
+ insights.append(insight)
+
+ return insights
+
diff --git a/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/04 Algorithm.html b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/04 Algorithm.html
new file mode 100644
index 0000000..56ab2db
--- /dev/null
+++ b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/05 Relative Performance.html b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/05 Relative Performance.html
new file mode 100644
index 0000000..07a20e4
--- /dev/null
+++ b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/05 Relative Performance.html
@@ -0,0 +1,94 @@
+
+ To analyze the value of this trading strategy, we compare its performance to buying and holding a popular ETF
+ tracking the energy sector. In this study, we use XLE, the Energy Select Sector SPDR® Fund, as the benchmark. We
+ can see from the plot below how the portfolio would have performed just had we had just invested in the benchmark.
+
+
+
+
+
+ We now analyze the Sharpe ratio and annual standard deviation of returns for both the strategy and the benchmark.
+ From the table below, we can see the results of the strategy and the benchmark over the entire backtest period, the
+ Fall 2015 crisis, and the 2020 oil price war. The strategy has a lower Sharpe ratio than the benchmark across all
+ of the time periods we tested, except for the crash during the 2020 oil price war, where it generated an impressive
+ 176 Sharpe ratio. We can also see the strategy has a lower annual standard deviation accross all of the time
+ frames, implying that the strategy has more consistent returns than the benchmark.
+
+ We find the lack of performance for this strategy is not largely attributed to the transaction costs. After
+ ignoring the transaction fees, spread costs, and slippage, the strategy still has a lower Sharpe ratio than the
+ benchmark and doesn't match the results found in the original research paper. See the backtest results
+ here.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/06 Market & Competition Qualification.html b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/06 Market & Competition Qualification.html
new file mode 100644
index 0000000..e63b0d3
--- /dev/null
+++ b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/06 Market & Competition Qualification.html
@@ -0,0 +1,13 @@
+
+ Although this strategy passes several of the
+ metrics required for Alpha Streams
+ and the Quant League competition, it requires further work to pass the following requirements:
+
+
+
+
Profitable
+
PSR >= 80%
+
Max drawdown duration <= 6 months
+
Insights contain the following properties: Symbol, Duration, Direction, and Weight
+
Minute or second data resolution
+
\ No newline at end of file
diff --git a/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/07 Conclusion.html b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/07 Conclusion.html
new file mode 100644
index 0000000..452f0d8
--- /dev/null
+++ b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/07 Conclusion.html
@@ -0,0 +1,21 @@
+
+ While the strategy examined herein produces a 176 Sharpe ratio throughout the downfall of the 2020 oil price war
+ and stock market crash, we conclude the strategy does not currently provide as profitable of results as documented
+ by Gurrib (2020). The strategy experiences a -0.234 Sharpe ratio over the entire backtest period. To continue the
+ development of this strategy, future areas of research include:
+
+
+
+
+ Only trading when a bullish or bearish trend are confirmed. Gurrib (2020) provides conditions for evaluating
+ the trend.
+
+
Adjusting the data resolution used within the indicator.
+
Considering fundamental or alternative data points before placing trades.
+
Adjusting the parameters of the Ichimoku indicator.
+
+ Replacing the portfolio construction model with one that only allocates 10% of the capital base to each security.
+ This will violate the requirements of the Alpha Streams and Quant League competition, but it will reduce the
+ transaction costs and provide a more accurate equity curve of the underlying strategies performance.
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/08 References.html b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/08 References.html
new file mode 100644
index 0000000..37c3e11
--- /dev/null
+++ b/04 Strategy Library/1028 Ichimoku Clouds in the Energy Sector/08 References.html
@@ -0,0 +1,6 @@
+
+
+ Gurrib, Ikhlaas, Can the Leading Us Energy Stock Prices Be Predicted Using Ichimoku Clouds? (January 16, 2020).
+ Online Copy
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1029 Optimal Pairs Trading/01 Abstract.html b/04 Strategy Library/1029 Optimal Pairs Trading/01 Abstract.html
new file mode 100644
index 0000000..f913c9e
--- /dev/null
+++ b/04 Strategy Library/1029 Optimal Pairs Trading/01 Abstract.html
@@ -0,0 +1,4 @@
+
+ In this tutorial, we apply Ornstein-Uhlenbeck model to a Pairs Trading process and derive the Optimal Entry and Liquidation
+ levels.
+
+ Pairs trading is holding one stock while simultaneously shorting another stock, typically in an attempt to profit
+ from the convergence of the spread between these two stocks. One method of execution is to apply a Kalman Filter,
+ which we have implemented in this post.
+ However, today, we will model the portfolio values of holding positions in
+ a pair of stocks as an Ornstein-Uhlenbeck (OU) process in order to derive the optimal values to enter and liquidate
+ the position in the pair of stocks. Let (number) refer to the corresponding equation in the given paper, which can
+ be found under the References section. For example, (2.1) refers to equation 2.1 in the paper.
+
Say there are two arbitrary stocks A and B. For each value β in .01, .02, .03, …, 1.00:
+
+
We compute the portfolio values over 252 days of the pairs trade by computing the value of holding $1 of A minus the value of holding $β B (we short B) on each of the 252 days
+
Then we compute the OU coefficients (θ, µ, σ) of the 252 portfolio values using the Maximum Likelihood Estimation method, maximizing the average log-likelihood defined by this function:
and Δt = 1 ÷ (days between the start and end dates of the portfolio values),
+
We then select the β, which we differentiate as β*, that maximizes the average log-likelihood defined in the equation in step 2, while keeping the corresponding θ*, µ*, σ* values. The implementation of finding θ*, µ*, and σ* can be found in ou_mle.py in the Algorithm section.
+
+
+
Deriving the Optimal Entry and Liquidation Levels
+
With the OU coefficients in hand, we can now calculate the optimal entry level, the portfolio value at which we buy, and liquidation level, the portfolio value at which we sell. We don’t buy the portfolio of $1 of A and -$β* of B immediately (note: to scale up a position, for each additional dollar we invest in A, we short an additional -$β* of B). Instead, we wait until our portfolio reaches the computed entry level, before we buy the portfolio of the pair of stocks. Once we bought this portfolio, we wait until the portfolio value reaches the computed liquidation level before we liquidate our portfolio. By waiting for our optimal entry and liquidation values to be reached, we can mathematically maximize our expected gain. To compute the optimal entry and liquidation levels, we first need to define a few equations:
Where constants c = the cost of transaction and r = investor’s subject discount rate. We choose to set c = r = .05 as these were the values given in the paper.
+
With these equations, we can now solve for the optimal liquidation level, which we denote as b*, as well as the optimal entry level, which we denote at d*. Note: the reason we derive the optimal liquidation level first is because we use b* in the computation of d*.
+
As deriving b* and d* require the derivative of the functions given above, given an arbitrary function input x and an arbitrary function f(x), we approximate f’(x) with the following equation equation:
+\[f'(x) = \frac{f(x+h)-f(x)}{h}\]
+
where h is some arbitrarily small value (we set h = 1 x 10-4 in our implementation).
+
To find b*, we solve for b in the following equation:
+\[F(b)=(b-c)F'(b)\quad(4.3)\]
+
We solve this equation by getting all terms to one side:
+\[F(b)-(b-c)F'(b)=0\]
+
Finding the root of the above equation results in b*.
+
Now to derive d*, we solve for d in the following equation:
+\[G(d)(V'(d)-1)=G'(d)(V(d)-d-c)\]
+
Again, we will move all terms to one side:
+\[G(d)(V'(d)-1)-G'(d)(V(d)-d-c)=0\]
+
And finding the root of this equation results in d*.
+
The full method of finding b* and d* can be found in the OptimalStopping.py
+ file in the Algorithm section.
+
+
Trading
+
+ Our trading logic is very simple. First, we feed in 252 points of the most recent data for the daily closing prices
+ for stocks A and B. We then train our model on these data points, and we get the
+ b*, d*, and β* values. We then keep track of a hypothetical portfolio of holding $1
+ of A and -$β* of B. Once the value of our hypothetical portfolio is less than or equal to b*,
+ we allocate 1.0 of our capital to long of A and short B using (β* x capital used for A) worth of stock.
+ Once the hypothetical portfolio value we tracking reaches d*, we liquidate our positions. We repeat these
+ trading rules when possible. On the first day of every quarter, we retrain our model with the most recent 252 points of data to
+ update our b*, d*, and β* values.
+
diff --git a/04 Strategy Library/1029 Optimal Pairs Trading/05 Video Walkthrough.html b/04 Strategy Library/1029 Optimal Pairs Trading/05 Video Walkthrough.html
new file mode 100644
index 0000000..1e7e3ae
--- /dev/null
+++ b/04 Strategy Library/1029 Optimal Pairs Trading/05 Video Walkthrough.html
@@ -0,0 +1,5 @@
+
\ No newline at end of file
diff --git a/04 Strategy Library/1029 Optimal Pairs Trading/06 Results.html b/04 Strategy Library/1029 Optimal Pairs Trading/06 Results.html
new file mode 100644
index 0000000..3eb8a0f
--- /dev/null
+++ b/04 Strategy Library/1029 Optimal Pairs Trading/06 Results.html
@@ -0,0 +1,8 @@
+
+ Our algorithm yielded a Sharpe ratio of 0.898 over a five year period, while holding SPY over the same period
+ yielded a Sharpe ratio of 0.667. However it should be noted, due to the fact the algorithm had to wait periods
+ of time before our optimal entry and liquidation levels were reached, our algorithm only made twelve trades over the
+ entire backtest duration. To increase the number of trades, we can add additional pairs, such as GLD-GDX. We encourage
+ our users to clone this algorithm and and to experiment with different ideas for pairs and to play with the parameters
+ of the algorithm.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1029 Optimal Pairs Trading/07 References.html b/04 Strategy Library/1029 Optimal Pairs Trading/07 References.html
new file mode 100644
index 0000000..10b2dac
--- /dev/null
+++ b/04 Strategy Library/1029 Optimal Pairs Trading/07 References.html
@@ -0,0 +1,7 @@
+
+
+ Leung, Tim and Li, Xin, Optimal Mean Reversion Trading with Transaction Costs and Stop-Loss Exit (April 26, 2015).
+ International Journal of Theoretical and Applied Finance, Vol. 18, No. 3, 2015.
+ Online Copy.
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1030 G-Score Investing/01 Abstract.html b/04 Strategy Library/1030 G-Score Investing/01 Abstract.html
new file mode 100644
index 0000000..248865d
--- /dev/null
+++ b/04 Strategy Library/1030 G-Score Investing/01 Abstract.html
@@ -0,0 +1,3 @@
+
+ In this tutorial, we apply G-Score Investing to choose a Universe of stocks to invest in.
+
+ Analyzing a company’s fundamentals is a method of trading that doesn’t
+ rely purely on price and volume data. We will apply the use of computers to automate
+ the analysis of this data, and we will do so using a method of
+ Factor Investing,
+ the process of using different attributes, in this case, fundamental data, to choose
+ stocks to purchase. More specifically, we will use G-Score investing, and evaluate companies
+ on seven factors that we will detail later. We specifically choose companies with Book-to-Market
+ due to abnormal returns as a result of the Risk Premium Effect.
+
+ We first sort all companies that have fundamental data by their Book-to-Market ratio, and narrow our universe to the
+ bottom quartile. We measure the Book-to-Market ratio using
+ fine.FinancialStatements.BalanceSheet.NetTangibleAssets.TwelveMonths divided by
+ fine.MarketCap. In this strategy, we will use Technology as the industry of choice, thus, we further
+ narrow this universe to Technology stocks only.
+
+
+
+ For each of the conditions that are described below, if met, one point will be added to the G-Score.
+ Thus, with seven factors, our G-Score can range from 0 to 7. We evaluate a company based on the following:
+
+
+
+
+
+ The Return on Assets (ROA) is greater than the contemporaneous industry median. In other words, the ROA for
+ the analyzed company is greater than the median of the ROAs of all companies in the same industry
+ We measure this value using fine.OperationRatios.ROA.OneYear
+
+
+ The Cash Flow Return on Assets (CFROA) is greater than the contemporaneous industry median
+ We measure this value using fine.FinancialStatements.CashFlowStatement.OperatingCashFlow.TwelveMonths
+ divided by fine.FinancialStatements.BalanceSheet.TotalAssets.TwelveMonths
+
+
+ The CFROA is greater than the ROA
+
+
+ The Variance of the ROA (VARROA) is lower than the contemporaneous industry median
+ We measure this by storing the past twelve values of fine.OperationRatios.ROA.ThreeMonths in a
+ RollingWindow and computing the variance of the values in the RollingWindow
+
+
+ The Research and Development Expenditure (R&D) is higher than the contemporaneous industry median
+ We measure this using fine.FinancialStatements.IncomeStatement.ResearchAndDevelopment.TwelveMonths
+
+
+ The Capital Expenditure (CapEx) is higher than the contemporaneous industry median
+ We measure this using fine.FinancialStatements.CashFlowStatement.CapExReported.TwelveMonths
+
+
+ The Advertisement Expenditure (Ad) is higher than the contemporaneous industry median
+ We measure this using fine.FinancialStatements.IncomeStatement.SellingGeneralAndAdministration.TwelveMonths
+
+
+
+
+ The fundamental data used in our algorithms is sourced from MorningStar, and to read more about our fundamental data,
+ please visit the Fundamentals section of our
+ documentation.
+
+
+
+ Once we have computed the G-Scores for each of the securities, we long the securities with G-Scores of 5 or higher.
+
+ Since we use Technology as the industry, we decided to use Nasdaq-100, or ^NDX, as the benchmark, which we track
+ using the QQQ ETF. Our algorithm achieves a Sharpe Ratio of 0.778 from April 2016 to September 2020, and so it is
+ outperformed by simply holding QQQ, which yielded a Sharpe Ratio of 1.22 over the same period.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1030 G-Score Investing/06 References.html b/04 Strategy Library/1030 G-Score Investing/06 References.html
new file mode 100644
index 0000000..f21473a
--- /dev/null
+++ b/04 Strategy Library/1030 G-Score Investing/06 References.html
@@ -0,0 +1,6 @@
+
+
+ Mohanram, Partha S., Separating Winners from Losers Among Low Book-to-Market Stocks Using Financial Statement
+ nalysis (April 2004). Online Copy.
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1031 SVM Wavelet Forecasting/01 Abstract.html b/04 Strategy Library/1031 SVM Wavelet Forecasting/01 Abstract.html
new file mode 100644
index 0000000..a93480f
--- /dev/null
+++ b/04 Strategy Library/1031 SVM Wavelet Forecasting/01 Abstract.html
@@ -0,0 +1,3 @@
+
+ In this tutorial, we apply an SVM Wavelet model in an attempt to forecast EURJPY prices.
+
+ Several methods have been developed to forecast time-series, from ARIMA to Neural Networks. In this strategy, we
+ combine a Support Vector Machine (SVM) and Wavelets in an attempt to forecast EURJPY. Although SVMs are generally
+ used for classification problems, such as classifying proteins, they can also be applied in regression problems, valued
+ for their ability to handle non-linear data. Furthermore, Wavelets are often applied in Signal Processing applications. Wavelets allow us
+ to decompose a time-series into multiple components, where each individual component can be denoised using thresholding, and this
+ leads to a cleaner time-series after the components are recombined. To use these two models in conjunction, we first
+ decompose the EURJPY data into components using Wavelet decomposition, then we apply the SVM to forecast one time-step
+ ahead of each of the components. After we recombine the components, we get the aggregate forecast of our SVM-Wavelet model.
+
+ Given EURJPY data, our first step is to decompose our data into multiple resolutions.
+ We work with wavelets using the pywt package. For denoising, Daubechies and
+ Symlets are good choices for Wavelets, and we use Symlets 10 in our strategy. We create a Symlets 10 Wavelet
+ using the following:
+
+
+
+
+w = pywt.Wavelet('sym10')
+
+
+
To determine the length of the data we’d need for a certain number of levels after decomposition, we can solve for:
+ Given the length of a Symlet 10 wavelet is 20, if we want three levels, we
+ solve for len(data) to get len(data) = 152, which means data would need to have at least
+ 152 values. Since we will denoise our components using thresholding,
+ we specify threshold = 0.5 to indicate the strength of the thresholding.
+ This threshold value can be any number between 0 and 1.
+
+
To decompose our data, we use:
+
+
+
+coeffs = pywt.wavedec(data, w)
+
+
+
+
For each component, we threshold/denoise the component (except for the first component, the approximation coefficients),
+ roll the values of the component one spot to the left,
+ and replace the last value of the component with a value forecasted from an SVM. This process looks like the following in code:
+
+
+
+for i in range(len(coeffs)):
+ if i > 0:
+ # we don't want to threshold the approximation coefficients
+ coeffs[i] = pywt.threshold(coeffs[i], threshold*max(coeffs[i]))
+ forecasted = __svm_forecast(coeffs[i])
+ coeffs[i] = np.roll(coeffs[i], -1)
+ coeffs[i][-1] = forecasted
+
+
+
+
The __svm_forecast method fits partitioned data to an SVM model then predicts one value into the
+ future, and can be found under SVMWavelet.py file under the Algorithm section
+
Once we forecast one value into the future, we can aggregate the forecasts by recombining the components into a simple time-series. We do this with:
+
+
+datarec = pywt.waverec(coeffs, w)
+
+
+
Since we want the aggregate forecast one time-step into the future, we return the last element of this time-series, or datarec[-1].
+
+
Our trading rules are simple: feed in the past 152 points of daily closing prices of EURJPY into our SVM Wavelet forecasting method, and divide that number by the current close of EURJPY to get the forecasted percent change. Then, we emit an Insight based on the direction of the percent change with the weight of the Insight as the absolute value of the percent change. We use the InsightWeightPortfolioConstructionModel so that the weight of the Insight determines the portfolio allocation percentage, which means larger forecasted moves will have a larger allocation.
The performance of the algorithm was decent. Over the past five years, the algorithm achieved a Sharpe Ratio of 0.252,
+ while buying and holding SPY over the same period would have achieved a Sharpe Ratio of 0.713. Some ideas for improvement include:
+
+
Testing different Wavelet types (e.g. Daubechies)
+
Trying out other time resolutions (e.g. Minute)
+
Using alternative Decomposition methods (e.g. Stationary Wavelet Transform)
+
+
If a user comes across any interesting results with modifications of this algorithm, we’d love to hear about it in the Community Forum.
\ No newline at end of file
diff --git a/04 Strategy Library/1031 SVM Wavelet Forecasting/06 References.html b/04 Strategy Library/1031 SVM Wavelet Forecasting/06 References.html
new file mode 100644
index 0000000..1cc8866
--- /dev/null
+++ b/04 Strategy Library/1031 SVM Wavelet Forecasting/06 References.html
@@ -0,0 +1,5 @@
+
+
+ M. S. Raimundo and J. Okamoto, "SVR-wavelet adaptive model for forecasting financial time series," 2018 International Conference on Information and Computer Technologies (ICICT), DeKalb, IL, 2018, pp. 111-114, doi: 10.1109/INFOCT.2018.8356851. Online Copy.
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1033 Gradient Boosting Model/01 Abstract.html b/04 Strategy Library/1033 Gradient Boosting Model/01 Abstract.html
new file mode 100644
index 0000000..1d309c1
--- /dev/null
+++ b/04 Strategy Library/1033 Gradient Boosting Model/01 Abstract.html
@@ -0,0 +1,7 @@
+
+ In this tutorial, we train a Gradient Boosting Model (GBM) to forecast the intraday price movements of the SPY ETF using a
+ collection of technical indicators. The implementation is based on the research produced by Zhou et al (2013), where a GBM
+ was found to produce an annualized Sharpe ratio greater than 20. Our research shows that throughout a 5 year backtest, the
+ model underperforms the SPY with its current parameter set. However, we finish the tutorial with highlighting potential
+ areas of further research to improve the model’s performance.
+
+ A GBM is trained by setting the initial model prediction to the mean target value in the training set. The model then
+ iteratively builds regression trees to predict the model’s pseudo-residuals on the training set to tighten the fit. The
+ pseudo-residuals are the differences between the target value and the model’s prediction on the current training iteration
+ for each sample. The model’s predictions are made by summing the mean target value and the products of the learning rate
+ and the regression tree outputs. The full algorithm is shown here.
+
+
+
+
+
+
+
+ We provide technical indicator values as inputs to the GBM. The model is trained to predict the security’s return over the
+ next 10 minutes and the performance of the model’s predictions are assessed using the mean squared error loss function.
+
+ Zhou et al (2013) utilize custom loss functions to fit their GBM in a manner that aims to maximize the profit-and-loss or
+ Sharpe ratio over the training data set. The attached notebook shows training the GBM with these custom loss functions
+ leads to poor model predictions.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1033 Gradient Boosting Model/03 Method.html b/04 Strategy Library/1033 Gradient Boosting Model/03 Method.html
new file mode 100644
index 0000000..7e88ae2
--- /dev/null
+++ b/04 Strategy Library/1033 Gradient Boosting Model/03 Method.html
@@ -0,0 +1,163 @@
+
Universe Selection
+
+ We use a ManualUniverseSelectionModel to subscribe to the SPY ETF. The algorithm is designed to work with minute and
+ second data resolutions. In our implementation, we use data on a minute resolution.
+
+ The GradientBoostingAlphaModel predicts the direction of the SPY at each timestep. Each position taken is held for
+ 10 minutes, although this duration is customizable in the constructor. During construction of this alpha model, we
+ simply set up a dictionary to hold a SymbolData object for each symbol in the universe. In the case where the
+ universe consists of multiple securities, the alpha model holds each with equal weighting.
+
+ When a new security is added to the universe, we create a SymbolData object for it to store information unique to
+ the security. The management of the SymbolData objects occurs in the alpha model's OnSecuritiesChanged method.
+
+
+
+def OnSecuritiesChanged(self, algorithm, changes):
+ for security in changes.AddedSecurities:
+ symbol = security.Symbol
+ self.symbol_data_by_symbol[symbol] = SymbolData(symbol, algorithm, self.hold_duration)
+
+ for security in changes.RemovedSecurities:
+ symbol_data = self.symbol_data_by_symbol.pop(security.Symbol, None)
+ if symbol_data:
+ symbol_data.dispose()
+
+ self.weight = 1 / len(self.symbol_data_by_symbol)
+
+
+
+
+
+
SymbolData Class
+
+ The SymbolData class is used in this algorithm to manage indicators, train the GBM, and produce trading predictions.
+ The constructor definition is shown below. The class is designed to train at the end of each month, using the
+ previous 4 weeks of data to fit the GBM that consists of 20 stumps (regression trees with 2 leaves). To ensure
+ overnight holds are avoided, the class uses
+ Scheduled Events to stop trading
+ near the market close.
+
+ For brevity, we omit the model training logic. Although, the code can be seen in the attached backtest. To make
+ predictions, we define the following method inside the SymbolData class. A position is held in the predicted
+ direction only if the predicted return in that direction exceeds the cost of the trade.
+
+
+
+def predict_direction(self):
+ if self.model is None or not self.allow_predictions:
+ return 0
+
+ input_data = [[]]
+ for _, indicators in self.indicators_by_indicator_type.items():
+ for indicator in indicators:
+ input_data[0].append(indicator.Current.Value)
+
+ return_prediction = self.model.predict(input_data)
+ if return_prediction > self.cost:
+ return 1
+ if return_prediction < -self.cost:
+ return -1
+ return 0
+
+
+
+
+
Alpha Update
+
+ As new TradeBars are provided to the alpha model's Update method, each SymbolData object makes a directional
+ prediction for its security. If the prediction is not flat, the alpha model emits an insight in that direction with
+ a duration of 10 minutes.
+
+
+
+def Update(self, algorithm, data):
+ insights = []
+ for symbol, symbol_data in self.symbol_data_by_symbol.items():
+ direction = symbol_data.predict_direction()
+ if direction:
+ hold_duration = timedelta(minutes=self.hold_duration) # Should match universe resolution
+ insights.append(Insight.Price(symbol, hold_duration, direction, None, None, None, self.weight))
+
+ return insights
+
+ Although this strategy passes several of the
+ metrics required for Alpha Streams
+ and the Quant League competition, it requires further work to pass the following requirements:
+
+ The GBM implemented in this tutorial has a lower Sharpe ratio than the S&P 500 index ETF benchmark over the periods
+ we tested. However, the strategy generates a lower annual variance over all the testing period, implying more
+ consistent returns than buy-and-hold. To continue the development of this strategy, future areas of research
+ include:
+
+
+
+
Adjusting parameters in the GradientBoostingAlphaModel and SymbolData classes
+
Testing other custom loss functions
+
Changing the data resolution from minutes to seconds
+
Using more/other technical indicators
+
+ Adding a model to predict the cost of trading (slippage, commissions, market impact) for each security instead of
+ prescribing a fixed amount
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1033 Gradient Boosting Model/08 References.html b/04 Strategy Library/1033 Gradient Boosting Model/08 References.html
new file mode 100644
index 0000000..385172c
--- /dev/null
+++ b/04 Strategy Library/1033 Gradient Boosting Model/08 References.html
@@ -0,0 +1,5 @@
+
+
+ Zhou, Nan and Cheng, Wen and Qin, Yichen and Yin, Zongcheng, Evolution of High Frequency Systematic Trading: A Performance-Driven Gradient Boosting Model (September 10, 2013). Online copy
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1036 Gaussian Naive Bayes Model/01 Abstract.html b/04 Strategy Library/1036 Gaussian Naive Bayes Model/01 Abstract.html
new file mode 100644
index 0000000..9421bb8
--- /dev/null
+++ b/04 Strategy Library/1036 Gaussian Naive Bayes Model/01 Abstract.html
@@ -0,0 +1,7 @@
+
+ Naïve Bayes models have become popular for their success in spam email filtering. In this tutorial, we train
+ Gaussian Naïve Bayes (GNB) classifiers to forecast the daily returns of stocks in the technology sector given the
+ historical returns of the sector. Our implementation shows the strategy has a greater Sharpe and lower variance
+ than the SPY ETF over a 5 year backtest and during the 2020 stock market crash. The algorithm we build here follows
+ the research done by Lu (2016) and Imandoust & Bolandraftar (2014).
+
+ In our use case, the classes in the model are: positive, negative, or flat future return for a security. The features
+ are the last 4 daily returns of the universe constituents. Since we are dealing with continuous data, we extend the
+ model to a GNB model by replacing \(P(x_j|c_i)\) in the equation above. First, we find the mean \(\mu_j\) and standard
+ deviation \(\sigma_j^2\) of the \(x_j\) feature vector in the training set labeled class \(c_i\). A normal distribution
+ parameterized by \(\mu_j\) and \(\sigma_j^2\) is then used to determine the likelihood of the observations. If \(o\) is the
+ observation for the \(j\)th feature. The likelihood of the observation given the class \(c_i\) is
+
+ The mechanics of the GNB model can be seen visually in
+ this video. Note that the GNB model has 2 underlying
+ assumptions: the feature vectors are independent and normally distributed. We do not test for these properties, but
+ rather leave it as an area of future research.
+
\ No newline at end of file
diff --git a/04 Strategy Library/1036 Gaussian Naive Bayes Model/03 Video Walkthrough.html b/04 Strategy Library/1036 Gaussian Naive Bayes Model/03 Video Walkthrough.html
new file mode 100644
index 0000000..3a3ef40
--- /dev/null
+++ b/04 Strategy Library/1036 Gaussian Naive Bayes Model/03 Video Walkthrough.html
@@ -0,0 +1,5 @@
+
\ No newline at end of file
diff --git a/04 Strategy Library/1036 Gaussian Naive Bayes Model/04 Method.html b/04 Strategy Library/1036 Gaussian Naive Bayes Model/04 Method.html
new file mode 100644
index 0000000..8ef11c2
--- /dev/null
+++ b/04 Strategy Library/1036 Gaussian Naive Bayes Model/04 Method.html
@@ -0,0 +1,223 @@
+
Universe Selection
+
+ Following Lu (2016), we implement a custom universe selection model to select the largest stocks from the technology
+ sector. We restrict our universe to have a size of 10, but this can be easily customized via the `fine_size`
+ parameter in the constructor.
+
+
+
+class BigTechUniverseSelectionModel(FundamentalUniverseSelectionModel):
+ def __init__(self, fine_size=10):
+ self.fine_size = fine_size
+ self.month = -1
+ super().__init__(True)
+
+ def SelectCoarse(self, algorithm, coarse):
+ if algorithm.Time.month == self.month:
+ return Universe.Unchanged
+ return [ x.Symbol for x in coarse if x.HasFundamentalData ]
+
+ def SelectFine(self, algorithm, fine):
+ self.month = algorithm.Time.month
+
+ tech_stocks = [ f for f in fine if f.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.Technology ]
+ sorted_by_market_cap = sorted(tech_stocks, key=lambda x: x.MarketCap, reverse=True)
+ return [ x.Symbol for x in sorted_by_market_cap[:self.fine_size] ]
+
+
+
+
+
Alpha Construction
+
+ The GaussianNaiveBayesAlphaModel predicts the direction each security will move from a given day’s open to the next
+ day’s open. When constructing this alpha model, we set up a dictionary to hold a SymbolData object for each symbol
+ in the universe and a flag to show the universe has changed.
+
+ When a new security is added to the universe, we create a SymbolData object for it to store information unique to
+ the security. The management of the SymbolData objects occurs in the alpha model's OnSecuritiesChanged method. In
+ this algorithm, since we train the Gaussian Naive Bayes classifier using the historical returns of the securities
+ in the universe, we flag to train the model every time the universe changes.
+
+
+
+class GaussianNaiveBayesAlphaModel(AlphaModel):
+ ...
+
+ def OnSecuritiesChanged(self, algorithm, changes):
+ for security in changes.AddedSecurities:
+ self.symbol_data_by_symbol[security.Symbol] = SymbolData(security, algorithm)
+
+ for security in changes.RemovedSecurities:
+ symbol_data = self.symbol_data_by_symbol.pop(security.Symbol, None)
+ if symbol_data:
+ symbol_data.dispose()
+
+ self.new_securities = True
+
+
+
+
+
SymbolData Class
+
+ The SymbolData class is used to store training data for the GaussianNaiveBayesAlphaModel and manage a consolidator
+ subscription. In the constructor, we specify the training parameters, setup the consolidator, and warm up the
+ training data.
+
+
+
+class SymbolData:
+ def __init__(self, security, algorithm, num_days_per_sample=4, num_samples=100):
+ self.exchange = security.Exchange
+ self.symbol = security.Symbol
+ self.algorithm = algorithm
+ self.num_days_per_sample = num_days_per_sample
+ self.num_samples = num_samples
+ self.previous_open = 0
+ self.model = None
+
+ # Setup consolidators
+ self.consolidator = TradeBarConsolidator(timedelta(days=1))
+ self.consolidator.DataConsolidated += self.CustomDailyHandler
+ algorithm.SubscriptionManager.AddConsolidator(self.symbol, self.consolidator)
+
+ # Warm up ROC lookback
+ self.roc_window = np.array([])
+ self.labels_by_day = pd.Series()
+
+ data = {f'{self.symbol.ID}_(t-{i})' : [] for i in range(1, num_days_per_sample + 1)}
+ self.features_by_day = pd.DataFrame(data)
+
+ lookback = num_days_per_sample + num_samples + 1
+ history = algorithm.History(self.symbol, lookback, Resolution.Daily)
+ if history.empty or 'close' not in history:
+ algorithm.Log(f"Not enough history for {self.symbol} yet")
+ return
+
+ history = history.loc[self.symbol]
+ history['open_close_return'] = (history.close - history.open) / history.open
+
+ start = history.shift(-1).open
+ end = history.shift(-2).open
+ history['future_return'] = (end - start) / start
+
+ for day, row in history.iterrows():
+ self.previous_open = row.open
+ if self.update_features(day, row.open_close_return) and not pd.isnull(row.future_return):
+ row = pd.Series([np.sign(row.future_return)], index=[day])
+ self.labels_by_day = self.labels_by_day.append(row)[-self.num_samples:]
+
+
+
+
+ The update_features method is called to update our training features with the latest data passed to the algorithm.
+ It returns True/False, representing if the features are in place to start updating the training labels.
+
+ The GNB model is trained each day the universe has changed. By default, it uses 100 samples to train. The features
+ are the historical open-to-close returns of the universe constituents. The labels are the returns from the open at
+ T+1 to the open at T+2 at each time step for each security.
+
+
+
+class GaussianNaiveBayesAlphaModel(AlphaModel):
+ ...
+
+ def train(self):
+ features = pd.DataFrame()
+ labels_by_symbol = {}
+
+ # Gather training data
+ for symbol, symbol_data in self.symbol_data_by_symbol.items():
+ if symbol_data.IsReady:
+ features = pd.concat([features, symbol_data.features_by_day], axis=1)
+ labels_by_symbol[symbol] = symbol_data.labels_by_day
+
+ # Train the GNB model
+ for symbol, symbol_data in self.symbol_data_by_symbol.items():
+ if symbol_data.IsReady:
+ symbol_data.model = GaussianNB().fit(features.iloc[:-2], labels_by_symbol[symbol])
+
+
+
+
+
Alpha Update
+
+ As new TradeBars are provided to the alpha model's Update method, we collect the latest TradeBar’s open-to-close
+ return for each security in the universe. We then predict the direction of each security using the security’s
+ corresponding GNB model, and return insights accordingly.
+
+
+
+class GaussianNaiveBayesAlphaModel(AlphaModel):
+ ...
+
+ def Update(self, algorithm, data):
+ if self.new_securities:
+ self.train()
+ self.new_securities = False
+
+ tradable_symbols = {}
+ features = [[]]
+
+ for symbol, symbol_data in self.symbol_data_by_symbol.items():
+ if data.ContainsKey(symbol) and data[symbol] is not None and symbol_data.IsReady:
+ tradable_symbols[symbol] = symbol_data
+ features[0].extend(symbol_data.features_by_day.iloc[-1].values)
+
+ insights = []
+ if len(tradable_symbols) == 0:
+ return []
+ weight = 1 / len(tradable_symbols)
+ for symbol, symbol_data in tradable_symbols.items():
+ direction = symbol_data.model.predict(features)
+ if direction:
+ insights.append(Insight.Price(symbol, data.Time + timedelta(days=1, seconds=-1),
+ direction, None, None, None, weight))
+
+ return insights
+
+ Although this strategy passes several of the
+ metrics required for Alpha Streams
+ and the Quant League competition, it requires further work to pass the following requirements:
+
+ The GNB model strategy implemented in this tutorial produced a greater Sharpe ratio and lower annual variance than
+ buying and holding the S&P 500 index ETF benchmark over the backtesting period. In addition to outperforming during
+ the entire backtest, the strategy also outperformed during the 2020 stock market crash.
+
+
+
+ To continue the development of this strategy, future areas of research include:
+
+
+
+
Adjusting parameters in the SymbolData class
+
Trying other features and labels for the GNB model
+
Adjusting the universe parameters and targeted sector
+
Adding handlers for corporate actions
+
Filter for stocks with independent and normal returns
+
\ No newline at end of file
diff --git a/04 Strategy Library/1036 Gaussian Naive Bayes Model/09 References.html b/04 Strategy Library/1036 Gaussian Naive Bayes Model/09 References.html
new file mode 100644
index 0000000..0320284
--- /dev/null
+++ b/04 Strategy Library/1036 Gaussian Naive Bayes Model/09 References.html
@@ -0,0 +1,12 @@
+
+
+ Imandoust, S. B., & Mohammad, B. (2014). Forecasting the direction of stock market index movement using three
+ data mining techniques: the case of Tehran Stock Exchange. Journal of Engineering Research and Applications,
+ 6(2), 106-117.
+ Online copy
+
+
+ Lu, N. (2016). A Machine Learning Approach to Automated Trading.
+ Online copy
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/11 Fundamental Factor Long Short Strategy/01 Introduction.html b/04 Strategy Library/11 Fundamental Factor Long Short Strategy/01 Introduction.html
new file mode 100755
index 0000000..f3424da
--- /dev/null
+++ b/04 Strategy Library/11 Fundamental Factor Long Short Strategy/01 Introduction.html
@@ -0,0 +1,26 @@
+
+ In this tutorial we implemented a long/short equity strategy based on fundamental factors. The idea comes from AQR white book: A New Core Equity Paradigm. The original version is a long only strategy. We developed it into a long/short version. The paper strategy used some fundamental data as measures of value, quality and momentum, and then ranked all the stocks in the universe according to the factors. The strategy only long the stocks ranking at the top, but our algorithm would at the same time short the stocks ranking at the bottom. This strategy consistently beats the market and has solid economic intuition.
+
+
Factors
+
+ The paper strategy used three factors together to rank stocks: value, quality and momentum.
+
+
+ Value: The most commonly used measure for value is P/B ratio(price-to-book value). Intuitively, the stocks with high P/B ratio are likely to be overpriced, and those stocks are labeled as growth stock. On the other hand, the stocks with low P/B value are considered to be value stocks. Following this logic, we use book value per share as a measure for value in our algorithm: the stocks with high book value per share rank high.
+
+
+ Quality: Quality is a comprehensive factor. The paper used total profits over asset, gross margins, and free cash flow over assets. For simplicity, we used only operation margin as our quality factor. Here we assume that the companies with high operation margin are profitable, and their stocks are the quality ones.
+
+
+ Momentum: The paper strategy is quarterly rebalanced, so it used recent one-year return, three-month and returns around earning events as measures for momentum. While our algorithm is monthly rebalanced, we simply use recent monthly return as our momentum factor.
+
+
+
Ranking
+
+ Ranking is the core process for stock selection. We first rank all the stocks according to each factor, then assign weights to each factor to get the final rank.
+ Specifically, in our algorithm we have 250 stocks in total. We rank them according to their book values per share, operation margins and one-month returns by descending order. For each stock, its index in each sorted list is its score on each factor. e.g. If stock A ranks 1st by value, 10th by quality and 30th by momentum, its scores on the value, quality and momentum are 1, 10 and 30 respectively.
+
+
+
+ The last step is to calculate the final score of each stocks. We use the same weight as the paper does: 40% on value, 40% on quality and 20% on momentum. In this way, stock A's final score is 1*0.4 + 10*0.4 + 30*0.2 = 10.4. Finally, we can rank all the stocks by their scores by ascending order. It worth attention that the stock with the lowest score is the best and it ranks 1st, and the one with the highest score is the worst.
+
diff --git a/04 Strategy Library/11 Fundamental Factor Long Short Strategy/02 Implementation.html b/04 Strategy Library/11 Fundamental Factor Long Short Strategy/02 Implementation.html
new file mode 100755
index 0000000..834dad1
--- /dev/null
+++ b/04 Strategy Library/11 Fundamental Factor Long Short Strategy/02 Implementation.html
@@ -0,0 +1,103 @@
+
+ In this implementation, the FineSelectionFunction would be the core part because we have to rank the stocks in this process. We also need a ScheduledEvent handler to rebalance the portfolio every month. We would introduce the process step by step.
+
+
+
CoarseSelectionFunction
+
+ This function is a filter for the whole asset universe(around 8000 stocks). We select the top 250 with highest dollar volume to ensure liquidity. We also filter out the stocks without fundamental information or with a too low price(less than $5).
+
+
+
+
+
+def CoarseSelectionFunction(self, coarse):
+ # if the rebalance flag is not 1, return null list to save time.
+ if self.reb != 1:
+ return return self.long + self.short
+
+ # make universe selection once a month
+ # drop stocks which have no fundamental data or have too low prices
+ selected = [x for x in coarse if (x.HasFundamentalData)
+ and (float(x.Price) > 5)]
+
+ sortedByDollarVolume = sorted(selected, key=lambda x: x.DollarVolume, reverse=True)
+ top = sortedByDollarVolume[:self.num_coarse]
+ return [i.Symbol for i in top]
+
+
+
+
FineSelectionFunction
+
+ Here is the core function. The process is that we make three sorted list to store the stocks, and then use a dictionary to store the score information. For the dictionary, the keys are Symbols and the values are their scores. Finally we sort the dictionary to get the final rank. we store the top 20 stocks to long in the list self.long and the bottom 20 stocks to short in the list self.short.
+
+
+
+
+
+ def FineSelectionFunction(self, fine):
+ # return the same symbol list if it's not time to rebalance
+ if self.reb != 1:
+ return self.long+self.short
+ self.reb = 0
+
+ # drop stocks which don't have the information we need.
+ # you can try replacing those factor with your own factors here
+
+ filtered_fine = [x for x in fine if x.OperationRatios.OperationMargin.Value
+ and x.ValuationRatios.PriceChange1M
+ and x.ValuationRatios.BookValuePerShare]
+
+ self.Log('remained to select %d'%(len(filtered_fine)))
+
+ # rank stocks by three factor.
+ sortedByfactor1 = sorted(filtered_fine, key=lambda x: x.OperationRatios.OperationMargin.Value, reverse=True)
+ sortedByfactor2 = sorted(filtered_fine, key=lambda x: x.ValuationRatios.PriceChange1M, reverse=True)
+ sortedByfactor3 = sorted(filtered_fine, key=lambda x: x.ValuationRatios.BookValuePerShare, reverse=True)
+
+ stock_dict = {}
+
+ # assign a score to each stock, you can also change the rule of scoring here.
+ for i,ele in enumerate(sortedByfactor1):
+ rank1 = i
+ rank2 = sortedByfactor2.index(ele)
+ rank3 = sortedByfactor3.index(ele)
+ score = sum([rank1*0.2,rank2*0.4,rank3*0.4])
+ stock_dict[ele] = score
+
+ # sort the stocks by their scores
+ self.sorted_stock = sorted(stock_dict.items(), key=lambda d:d[1],reverse=False)
+ sorted_symbol = [x[0] for x in self.sorted_stock]
+
+ # sotre the top stocks into the long_list and the bottom ones into the short_list
+ self.long = [x.Symbol for x in sorted_symbol[:self.num_fine]]
+ self.short = [x.Symbol for x in sorted_symbol[-self.num_fine:]]
+
+ return self.long+self.short
+
+
Rebalance
+
+ Our portfolio is rebalanced monthly, so first of all we should write a ScheduledEvent handler in the Initialize function:
+
+
+
+
+
+def Initialize(self):
+# Use SPY as a benchmark for market open
+ self.Schedule.On(self.DateRules.MonthStart(self.spy), self.TimeRules.AfterMarketOpen(self.spy,5), Action(self.rebalance))
+Our rebalanced method is straightforward: We first liquidate the stocks that are no longer in the long/short list, and then assign equal weight to the stocks we are going to long or short.
+def rebalance(self):
+# if this month the stock are not going to be long/short, liquidate it.
+ long_short_list = self.long + self.short
+ for i in self.Portfolio.Values:
+ if (i.Invested) and (i.Symbol not in long_short_list):
+ self.Liquidate(i.Symbol)
+
+ # Assign each stock equally. Always hold 10% cash to avoid margin call
+ for i in self.long:
+ self.SetHoldings(i,0.9/self.num_fine)
+
+ for i in self.short:
+ self.SetHoldings(i,-0.9/self.num_fine)
+
+
diff --git a/04 Strategy Library/11 Fundamental Factor Long Short Strategy/03 Summary.html b/04 Strategy Library/11 Fundamental Factor Long Short Strategy/03 Summary.html
new file mode 100644
index 0000000..7fa12d8
--- /dev/null
+++ b/04 Strategy Library/11 Fundamental Factor Long Short Strategy/03 Summary.html
@@ -0,0 +1,4 @@
+
+ The strategy was backtest at a 60-year timespan. It's persistent, systematic and intuitive. Although our version is very different from the paper one, the logic and intuition behind are the same. It has a better performance than the paper strategy because we added short positions.
+ For further development, we can try to rank a large number of stocks, and do some portfolio optimization instead of holding stocks equally.
+
diff --git a/04 Strategy Library/11 Fundamental Factor Long Short Strategy/04 Algorithm.html b/04 Strategy Library/11 Fundamental Factor Long Short Strategy/04 Algorithm.html
new file mode 100755
index 0000000..b8d9c7d
--- /dev/null
+++ b/04 Strategy Library/11 Fundamental Factor Long Short Strategy/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/11 Fundamental Factor Long Short Strategy/05 References.html b/04 Strategy Library/11 Fundamental Factor Long Short Strategy/05 References.html
new file mode 100644
index 0000000..e199f94
--- /dev/null
+++ b/04 Strategy Library/11 Fundamental Factor Long Short Strategy/05 References.html
@@ -0,0 +1,5 @@
+
+
+
diff --git a/04 Strategy Library/113 January Barometer/01 Introduction.html b/04 Strategy Library/113 January Barometer/01 Introduction.html
new file mode 100644
index 0000000..4148671
--- /dev/null
+++ b/04 Strategy Library/113 January Barometer/01 Introduction.html
@@ -0,0 +1,4 @@
+
+ January barometer is a calendar anomaly saying that the January performance of equity index could foretell February to December returns on equity index - a strong January shows strong rest of the year and otherwise.
+ This algorithm is going to explore the estimation effect of the January barometer in equity index market.
+
diff --git a/04 Strategy Library/113 January Barometer/02 Method.html b/04 Strategy Library/113 January Barometer/02 Method.html
new file mode 100644
index 0000000..c8d3623
--- /dev/null
+++ b/04 Strategy Library/113 January Barometer/02 Method.html
@@ -0,0 +1,20 @@
+
+ We use the S&P500 ETF as the underlying. In January, the algorithm buys SPY and hold until the end of January.
+ At the end of January, we calculate the January return, if the return is greater than zero, the algorithm will continue to hold the SPY. If the January return is negative instead, the algorithm will liquidate the SPY asset and invest in the treasury bill for the rest of the year. The portfolio is rebalanced every year in January.
+
+
+
+def Rebalance(self):
+ if self.Time.month == 1:
+ self.Liquidate("BIL")
+ self.SetHoldings("SPY", 1)
+ self.startPrice = self.Securities["SPY"].Price
+ if self.Time.month == 2 and self.startPrice is not None:
+ returns = (self.Securities["SPY"].Price - self.startPrice)/self.startPrice
+ if returns > 0:
+ self.SetHoldings("SPY", 1)
+ else:
+ self.Liquidate("SPY")
+ self.SetHoldings("BIL", 1)
+
+
diff --git a/04 Strategy Library/113 January Barometer/03 Algorithm.html b/04 Strategy Library/113 January Barometer/03 Algorithm.html
new file mode 100644
index 0000000..e85f53d
--- /dev/null
+++ b/04 Strategy Library/113 January Barometer/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/113 January Barometer/04 Source.html b/04 Strategy Library/113 January Barometer/04 Source.html
new file mode 100644
index 0000000..8a2d56e
--- /dev/null
+++ b/04 Strategy Library/113 January Barometer/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/114 January Effect in Stocks/01 Introduction.html b/04 Strategy Library/114 January Effect in Stocks/01 Introduction.html
new file mode 100644
index 0000000..cb4b453
--- /dev/null
+++ b/04 Strategy Library/114 January Effect in Stocks/01 Introduction.html
@@ -0,0 +1,5 @@
+
+ The January effect is a calendar anomaly saying that small-cap stocks returns in January are especially strong.
+ The most common explanation of this phenomenon is that individual investors, who are income tax-sensitive and who disproportionately hold small stocks, sell stocks for tax reasons at year end and reinvest during the first month of the year.
+ In this algorithm, we will explore the January effect in the stock market.
+
diff --git a/04 Strategy Library/114 January Effect in Stocks/02 Method.html b/04 Strategy Library/114 January Effect in Stocks/02 Method.html
new file mode 100644
index 0000000..ae1f295
--- /dev/null
+++ b/04 Strategy Library/114 January Effect in Stocks/02 Method.html
@@ -0,0 +1,69 @@
+
+ The investment universe consists of US-listed companies. A minimum stock price filter is used to avoid penny stocks. To avoid stocks that are not liquid enough, we select 1000 stocks with the highest dollar volume.
+
+
+
+def CoarseSelectionFunction(self, coarse):
+ if self.monthly_rebalance:
+ self.coarse = True
+ coarse = [x for x in coarse if (x.AdjustedPrice > 10)]
+ topDollarVolume = sorted(coarse, key=lambda x: x.DollarVolume, reverse=True)[:1000]
+ return [i.Symbol for i in topDollarVolume]
+ else:
+ return []
+
+
+
+ In FineSelectionFunction(self, fine), we calculate the market cap value with shares outstanding, earning per shares and the PE ratio.
+ Then stocks are sorted by their market capitalization. The top 10 stocks are selected as the large-cap group and the bottom 10 stocks belong to the small-cap group.
+
+
+
+def FineSelectionFunction(self, fine):
+ if self.monthly_rebalance:
+ fine =[i for i in fine if i.EarningReports.BasicAverageShares.ThreeMonths>0
+ and i.EarningReports.BasicEPS.TwelveMonths>0
+ and i.ValuationRatios.PERatio>0]
+ for i in fine:
+ i.MarketCap = float(i.EarningReports.BasicAverageShares.ThreeMonths * (i.EarningReports.BasicEPS.TwelveMonths*i.ValuationRatios.PERatio))
+ sorted_market_cap = sorted(fine, key = lambda x:x.MarketCap, reverse=True)
+ symbols = [i.Symbol for i in sorted_market_cap]
+ self.top_market_cap = symbols[:10]
+ self.bottom_market_cap = symbols[-10:]
+ return self.top_market_cap + self.bottom_market_cap
+ else:
+ return []
+
+
+
+ The algorithm invests into small-cap stocks at the beginning of each January and stays invested in large-cap stocks for rest of the year.
+ The portfolio is rebalanced every month.
+
+
+
+ def OnData(self, data):
+ if not (self.monthly_rebalance and self.coarse): return
+ self.coarse = False
+ self.monthly_rebalance = False
+ stocks_invested = [x.Key for x in self.Portfolio if x.Value.Invested]
+ # invest in small cap stocks at the beginning of each January
+ if self.Time.month == 1:
+ # liquidate stocks not in the small-cap group
+ for i in stocks_invested:
+ if i not in self.bottom_market_cap:
+ self.Liquidate(i)
+ weight = 1/len(self.bottom_market_cap)
+ for i in self.bottom_market_cap:
+ self.SetHoldings(i, weight)
+ # invest in large cap stocks for rest of the year
+ else:
+ # liquidate stocks not in the large-cap group
+ for i in stocks_invested:
+ if i not in self.top_market_cap:
+ self.Liquidate(i)
+
+ weight = 1/len(self.top_market_cap)
+ for i in self.top_market_cap:
+ self.SetHoldings(i, weight)
+
+
diff --git a/04 Strategy Library/114 January Effect in Stocks/03 Algorithm.html b/04 Strategy Library/114 January Effect in Stocks/03 Algorithm.html
new file mode 100644
index 0000000..6dc92eb
--- /dev/null
+++ b/04 Strategy Library/114 January Effect in Stocks/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/114 January Effect in Stocks/04 Source.html b/04 Strategy Library/114 January Effect in Stocks/04 Source.html
new file mode 100644
index 0000000..7f85cc6
--- /dev/null
+++ b/04 Strategy Library/114 January Effect in Stocks/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/118 Time Series Momentum Effect/01 Introduction.html b/04 Strategy Library/118 Time Series Momentum Effect/01 Introduction.html
new file mode 100644
index 0000000..8161ee5
--- /dev/null
+++ b/04 Strategy Library/118 Time Series Momentum Effect/01 Introduction.html
@@ -0,0 +1,10 @@
+
+Time series momentum is related to, but different from the phenomenon known as “momentum” in the finance literature, which is primarily cross-sectional in nature.
+The momentum literature focuses on the relative performance of securities in the cross section, finding that securities that recently outperformed their peers over the past 3 to 12 months continue to do so on average over the next month.
+Rather than focus on the relative returns of securities in the cross section, this time series momentum strategy focuses purely on the past returns of each individual futures contract.
+Every month, the investor considers whether the excess return of each asset over the past 12 months is positive or negative and goes long on the contract if it is positive and short if negative.
+The position size is set to be inversely proportional to the volatility of the security's returns.
+A univariate GARCH model could be used to estimate volatility.
+However, other simple models could probably be easily used with good results (for example, the easiest one would be using historical volatility). For the sake of simplicity, we will use historical volatility.
+The portfolio is rebalanced monthly.
+
diff --git a/04 Strategy Library/118 Time Series Momentum Effect/02 Method.html b/04 Strategy Library/118 Time Series Momentum Effect/02 Method.html
new file mode 100644
index 0000000..3e2ec91
--- /dev/null
+++ b/04 Strategy Library/118 Time Series Momentum Effect/02 Method.html
@@ -0,0 +1,60 @@
+
+ As the strategy needs the continuous futures contract, we import the custom data from Quandl.
+ We create a universe of highly liquid commodity futures that are traded on CME, ICE and CBOT (more contracts can be added using the Quandl API).
+ We will use Quandl's daily, non-adjusted price data, which is based on spot-month continuous contract calculations.
+
+
+ The first step is importing the data.
+
+
+
from QuantConnect.Python import PythonQuandl
+for symbol in self.symbols :
+ self.AddData(QuandlFutures, symbol, Resolution.Daily)
+
+class QuandlFutures(PythonQuandl):
+ def __init__(self):
+ self.ValueColumnName = "Settle"
+
+
+
+ Here we use a 12-month RateOfChange(period) indicator to simulate the momentum returns.
+ All indicators are saved in the dictionary self.roc.
+
+
+
+self.period = 252
+self.roc = {}
+for symbol in self.symbols:
+ self.roc[symbol] = self.ROC(symbol, self.period) #Initialize ROC indicator : ROC is short for RateofChange
+
+
+
+
+
+ We use history request to obtain historical prices. Here, history is the daily returns, which will be used to calculate volatilities.
+
+
+
+ history = self.History(self.symbols, self.period, Resolution.Daily)
+ history = history.value.unstack(level=0).pct_change().dropna()
+
+
+
+
Then we calculate the historical volatilities and place orders.
+ Note that the weights are inversely proportional to volatilities and np.sign determines whether to long or short.
+
+
+
+
diff --git a/04 Strategy Library/118 Time Series Momentum Effect/03 Algorithm.html b/04 Strategy Library/118 Time Series Momentum Effect/03 Algorithm.html
new file mode 100644
index 0000000..61b8d16
--- /dev/null
+++ b/04 Strategy Library/118 Time Series Momentum Effect/03 Algorithm.html
@@ -0,0 +1,7 @@
+div class="qc-embed-frame" style="display: inline-block; position: relative; width: 100%; min-height: 100px; min-width: 300px;">
+
+
+
+
+
diff --git a/04 Strategy Library/118 Time Series Momentum Effect/04 Source.html b/04 Strategy Library/118 Time Series Momentum Effect/04 Source.html
new file mode 100644
index 0000000..f82cd1e
--- /dev/null
+++ b/04 Strategy Library/118 Time Series Momentum Effect/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/12 Asset Class Trend Following/01 Introduction.html b/04 Strategy Library/12 Asset Class Trend Following/01 Introduction.html
new file mode 100644
index 0000000..df8b8b8
--- /dev/null
+++ b/04 Strategy Library/12 Asset Class Trend Following/01 Introduction.html
@@ -0,0 +1,4 @@
+
+ Asset class trend following is a strategy that tries to exploit a momentum anomaly between various assets. It uses various moving averages or momentum filters to gain an exposure to an asset class only at the time when there is a higher probability for outperformance with less risk.
+ The basic logic behind the trend following is finding a method to detect the trend of price movement and buy an asset when its price trend goes up, and sell when its trend goes down.
+
diff --git a/04 Strategy Library/12 Asset Class Trend Following/02 Method.html b/04 Strategy Library/12 Asset Class Trend Following/02 Method.html
new file mode 100644
index 0000000..cf3215f
--- /dev/null
+++ b/04 Strategy Library/12 Asset Class Trend Following/02 Method.html
@@ -0,0 +1,5 @@
+
+ This algorithm applies to trend following ideas to 5 ETFs in different asset classes like stocks, bonds, and commodities. The simple moving average is used to detect the trend. When the closing price is over its ten-month simple moving average,
+ we give equal allocation to those ETFs, otherwise stay in cash.
+ SMA(symbol, period, resolution) is used to generate the moving average value In LEAN implementation. A warm-up period of ten months is set to prime the data and initialize the indicator so the SMA is ready to use when the algorithm starts.
+
diff --git a/04 Strategy Library/12 Asset Class Trend Following/03 Algorithm.html b/04 Strategy Library/12 Asset Class Trend Following/03 Algorithm.html
new file mode 100644
index 0000000..77b7892
--- /dev/null
+++ b/04 Strategy Library/12 Asset Class Trend Following/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/12 Asset Class Trend Following/04 Source.html b/04 Strategy Library/12 Asset Class Trend Following/04 Source.html
new file mode 100644
index 0000000..1c941c0
--- /dev/null
+++ b/04 Strategy Library/12 Asset Class Trend Following/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/01 Introduction.html b/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/01 Introduction.html
new file mode 100644
index 0000000..e5ef779
--- /dev/null
+++ b/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/01 Introduction.html
@@ -0,0 +1,5 @@
+
+ January effect in stocks market says that stocks perform especially well in the first month of the year. This seasonal effect might lead us to think
+ that stocks performed well in the last year's January will perform well in this year's January. In this tutorial, we're going to implement a strategy based
+ on this yearly seasonal effect.
+
diff --git a/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/02 Method.html b/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/02 Method.html
new file mode 100644
index 0000000..8663ff7
--- /dev/null
+++ b/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/02 Method.html
@@ -0,0 +1,74 @@
+
+ The investment universe consists of all stocks from AMEX and NYSE. Firstly, in CoarseSelectionFunction, we remove stocks which do not have fundamental data.
+
+
+
+def CoarseSelectionFunction(self, coarse):
+ if self.monthly_rebalance:
+ coarse = [x for x in coarse if (x.HasFundamentalData)
+ and (x.Market == "usa")]
+ return [i.Symbol for i in coarse]
+ else:
+ return []
+
+
+
+ Next, we are going to filter the top 30% of stocks based on their market cap.
+ In implementation, the market cap is calculated with the BasicAverageShares, BasicEPS and PERatio.
+ Then we request the history price 12 months ago and 11 months ago to calculate the January return of the last year.
+
+
+
+def FineSelectionFunction(self, fine):
+ if self.monthly_rebalance:
+ fine =[i for i in fine if ((i.SecurityReference.ExchangeId == "NYS") or (i.SecurityReference.ExchangeId == "ASE"))]
+ self.filtered_fine = []
+
+ for i in fine:
+ i.MarketCap = float(i.EarningReports.BasicAverageShares.TwelveMonths * (i.EarningReports.BasicEPS.TwelveMonths*i.ValuationRatios.PERatio))
+ history_start = self.History([i.Symbol], TimeSpan.FromDays(365))
+ history_end = self.History([i.Symbol],TimeSpan.FromDays(335))
+ if not history_start.empty and not history_end.empty:
+ i.Returns = float(history_end.iloc[0]["close"] - history_start.iloc[0]["close"])
+ self.filtered_fine.append(i)
+
+ size = int(len(fine)*.3)
+ self.filtered_fine = sorted(self.filtered_fine, key = lambda x: x.MarketCap, reverse=True)
+ self.filtered_fine = self.filtered_fine[:size]
+ self.filtered_fine = sorted(self.filtered_fine, key = lambda x: x.Returns, reverse=True)
+ symbols = [i.Symbol for i in self.filtered_fine]
+ self.filtered_fine = symbols
+ return symbols
+ else:
+ return []
+
+
+
+ Every month, stocks are grouped into ten portfolios with the equal number of stocks in each portfolio according to their performance in January one year ago.
+ Investors go long in stocks from the winner decile and shorts stocks from loser decile. The portfolio is equally weighted and rebalanced every month.
+
+
+
+
+
+def OnData(self, data):
+ if not (self.monthly_rebalance): return
+ if not (self.filtered_fine): return
+ self.monthly_rebalance = False
+
+ portfolio_size = int(len(self.filtered_fine)/10)
+ short_stocks = self.filtered_fine[-portfolio_size:]
+ long_stocks = self.filtered_fine[:portfolio_size]
+ stocks_invested = [x.Key for x in self.Portfolio]
+ for i in stocks_invested:
+ #liquidate the stocks not in the filtered balance sheet accrual list
+ if i not in self.filtered_fine:
+ self.Liquidate(i)
+ #long the stocks in the list
+ elif i in long_stocks:
+ self.SetHoldings(i, 1/(portfolio_size*2))
+ #short the stocks in the list
+ elif i in short_stocks:
+ self.SetHoldings(i,-1/(portfolio_size*2))
+
+
diff --git a/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/03 Algorithm.html b/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/03 Algorithm.html
new file mode 100644
index 0000000..e7aa2b2
--- /dev/null
+++ b/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/04 Source.html b/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/04 Source.html
new file mode 100644
index 0000000..53aad28
--- /dev/null
+++ b/04 Strategy Library/125 12 Month Cycle in Cross-Section of Stocks Returns/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/13 Asset Class Momentum/01 Introduction.html b/04 Strategy Library/13 Asset Class Momentum/01 Introduction.html
new file mode 100644
index 0000000..15ad281
--- /dev/null
+++ b/04 Strategy Library/13 Asset Class Momentum/01 Introduction.html
@@ -0,0 +1,4 @@
+
+This trend following algorithm finds its entry points using the momentum effect. The momentum anomaly says that what was strongly going up in the past will probably continue to go up in the near future.
+The calculation performed uses the rate of change in price movements for a particular asset.
+
diff --git a/04 Strategy Library/13 Asset Class Momentum/02 Method.html b/04 Strategy Library/13 Asset Class Momentum/02 Method.html
new file mode 100644
index 0000000..0869d5c
--- /dev/null
+++ b/04 Strategy Library/13 Asset Class Momentum/02 Method.html
@@ -0,0 +1,3 @@
+
+ The portfolio of this algorithm contains 5 ETFs in different asset classes. LEAN has the momentum indicator MOM(symbol, period). The period is 12 months. After obtaining the most recent momentum value, we pick 3 ETFs with the strongest 12-month momentum into the portfolio and weight them equally. Hold for 1 month and then rebalance the portfolio with new momentum. Unlike asset class trend following strategy which combines asset classes into one portfolio, this rotational momentum system compares the performance of asset classes and picks only the best-performing assets from investment universe into investor's portfolio. The portfolio is rebalanced every month and portfolio's holdings are rotated so that only the best-performing assets are held.
+
diff --git a/04 Strategy Library/13 Asset Class Momentum/03 Algorithm.html b/04 Strategy Library/13 Asset Class Momentum/03 Algorithm.html
new file mode 100644
index 0000000..d001aad
--- /dev/null
+++ b/04 Strategy Library/13 Asset Class Momentum/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/13 Asset Class Momentum/04 Source.html b/04 Strategy Library/13 Asset Class Momentum/04 Source.html
new file mode 100644
index 0000000..ef94c60
--- /dev/null
+++ b/04 Strategy Library/13 Asset Class Momentum/04 Source.html
@@ -0,0 +1,5 @@
+
+ Residual momentum is the phenomenon that stocks with greater monthly residual returns (normalized by the volatility of the
+ residual returns) tend to outperform those with less. Research has shown the strategy experiences less exposure to the dynamic
+ Fama-French factors, produces greater sharpe ratios, and is more robust out-of-sample than a total return momentum strategy.
+ This strategy is claimed to be more stable throughout the business cycle than a total return momentum strategy. It tends to underperform during trending regimes and outperform during reverting regimes. Additionally, this strategy is less concentrated is small-cap stocks than a total return strategy can sometimes be, leading to less trading costs and reducing the effect of tax-loss selling.
+
+ The first step of algorithm is to load 3 years of trailing values of the Fama-French factors. We call the AddData method and provide the Fama-French data source URL from our Tutorials repo. We save the loaded data into a DataFrame in the alpha model.
+
+
+
Universe Selection
+
+ In coarse universe selection, we return the first 400 symbols that have fundamental data. In fine universe selection, we rank the stocks by market cap and return the symbols that are in the top 10%. We only create ResidualMomentum objects for stocks added to the universe that have atleast 3 years of historical prices.
+
+
+
Calculate Residual Momentum Score
+
+ During construction of ResidualMomentum objects, we manually warmup the trailing 3 years of monthly returns for the security. We also set up a monthly consolidator to update the trailing returns each month and to recalculate the score. The score is calculated by fitting a linear regression model to the trailing 36 months of data, using the Fama-French factors as independent variables and the monthly returns of each stock as the dependent variable.
+
+ Where \(r_t\) is the monthly return of the stock in month \(t\); \(Mkt_t\), \(SMB_t\), and \(HML_t\) are the Fama-French factor values in month \(t\); and \(epsilon_t\) is the residual return in month \(t\). After fitting, we test the model on the trailing 12 months of data (excluding the most recent month) to calculate the score. We simply sum the residuals and divide by the standard deviation of the residuals to get the score.
+
+ If a stock's price is below $1 when calculating the score, it's score is set to None, excluding it from trading during the rebalance.
+
+
+
Rebalancing
+
+ We rebalance the portfolio at the beginning of each month. After calculating a score for each security, we long the 10% of stocks with the greatest scores and short the 10% of stocks with the lowest scores, holding until the next rebalance.
+
\ No newline at end of file
diff --git a/04 Strategy Library/136 Residual Momentum/03 Algorithm.html b/04 Strategy Library/136 Residual Momentum/03 Algorithm.html
new file mode 100644
index 0000000..a989254
--- /dev/null
+++ b/04 Strategy Library/136 Residual Momentum/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/136 Residual Momentum/04 References.html b/04 Strategy Library/136 Residual Momentum/04 References.html
new file mode 100644
index 0000000..bd3b043
--- /dev/null
+++ b/04 Strategy Library/136 Residual Momentum/04 References.html
@@ -0,0 +1,8 @@
+
+
+This algorithm is an adaptation of asset class momentum. Instead of rotating ETFs in different asset classes,
+the sector momentum algorithm picks 10 sector ETFs and pick 3 ETFs with the strongest 12-month momentum into
+the portfolio and weight them equally. The portfolio is rebalanced at the start of each month.
+
diff --git a/04 Strategy Library/15 Short Term Reversal/01 Introduction.html b/04 Strategy Library/15 Short Term Reversal/01 Introduction.html
new file mode 100644
index 0000000..ebad458
--- /dev/null
+++ b/04 Strategy Library/15 Short Term Reversal/01 Introduction.html
@@ -0,0 +1,3 @@
+
+The short-term reversal is the phenomenon that stocks with relatively low returns over the past month or week earn positive abnormal returns in the following month or week, and stocks with high returns earn negative abnormal returns.
+
diff --git a/04 Strategy Library/15 Short Term Reversal/02 Method.html b/04 Strategy Library/15 Short Term Reversal/02 Method.html
new file mode 100644
index 0000000..2393a78
--- /dev/null
+++ b/04 Strategy Library/15 Short Term Reversal/02 Method.html
@@ -0,0 +1,6 @@
+
+ To apply short-term reversal in stocks market, first, we use the universe selection API to pick the stocks with the price higher than 4 and rank those stocks by dollar volume and
+ choose the top 100 stocks as our asset pool. In fine universe selection, the prescreened stocks are sorted by market cap we choose the top 20. To detect the reversal effect,
+ the return is the most straightforward measure of the stock history performance. The RateOfReturn indicator is used to calculate the monthly return. We go long on the 10 stocks
+ with the lowest performance in the previous month and go short on the 10 stocks with the greatest performance from the previous month.
+
diff --git a/04 Strategy Library/15 Short Term Reversal/03 Algorithm.html b/04 Strategy Library/15 Short Term Reversal/03 Algorithm.html
new file mode 100644
index 0000000..1970b93
--- /dev/null
+++ b/04 Strategy Library/15 Short Term Reversal/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/15 Short Term Reversal/04 Source.html b/04 Strategy Library/15 Short Term Reversal/04 Source.html
new file mode 100644
index 0000000..df7d579
--- /dev/null
+++ b/04 Strategy Library/15 Short Term Reversal/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/152 Momentum Effect in REITs/01 Introduction.html b/04 Strategy Library/152 Momentum Effect in REITs/01 Introduction.html
new file mode 100644
index 0000000..4cf8481
--- /dev/null
+++ b/04 Strategy Library/152 Momentum Effect in REITs/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ The momentum effect is a classic anomaly that says what was strongly going up in the past will probably continue to go up in the near future. The calculation performed uses the rate of change in price movements. We see this effect in REITs through studies where REITs with the highest annual past performance beat lower performing trusts. This strategy will take a long position in companies with the strongest momentum and rebalance quarterly.
+
\ No newline at end of file
diff --git a/04 Strategy Library/152 Momentum Effect in REITs/02 Method.html b/04 Strategy Library/152 Momentum Effect in REITs/02 Method.html
new file mode 100644
index 0000000..4473eb4
--- /dev/null
+++ b/04 Strategy Library/152 Momentum Effect in REITs/02 Method.html
@@ -0,0 +1,58 @@
+
+ The first step is coarse and fine universe selection. During coarse selection, we create an investment universe of stocks that have prices greater than $1, contain fundamental data and do not have a very low trading volume for liquidity purposes. During the fine selection we take all available REITs by using the Morningstar field IsREIT.
+
+
+ In the fine selection we also calculate each REIT's past 11-month return one-month lagged and rank them. This is used to determine the top tercile of portfolio.
+
+
+
+ def CoarseSelectionFunction(self, coarse):
+ if self.quarterly_rebalance:
+ self.filtered_coarse = [x.Symbol for x in coarse if (float(x.Price) > 1)
+ and (x.HasFundamentalData)
+ and float(x.Volume) > 10000]
+ return self.filtered_coarse
+ else:
+ return []
+
+def FineSelectionFunction(self, fine):
+ if self.quarterly_rebalance:
+ fine = [x for x in fine if (x.CompanyReference.IsREIT == 1)]
+
+ start = self.Time-timedelta(days = 365)
+ end = self.Time-timedelta(days = 30)
+ for x in fine:
+ hist = self.History([x.Symbol],start,end,Resolution.Daily)
+ if not hist.empty:
+ start_price = hist["close"].iloc[0]
+ end_price = hist["close"].iloc[-1]
+ x.momentum = (end_price-start_price)/start_price
+
+ fine = [x for x in fine if hasattr(x, 'momentum')]
+ sorted_filter = sorted(fine, key=lambda x: x.momentum)
+ self.filtered_fine = [i.Symbol for i in sorted_filter]
+ return self.filtered_fine
+ else:
+ return []
+
+
+
+ In OnData(), we buy the stocks in the best performing tercile for three months and the portfolio is rebalanced every three months.
+
+
+
+def OnData(self, data):
+ if not self.quarterly_rebalance: return
+ if self.filtered_fine:
+ portfolio_size = int(len(self.filtered_fine)/3)
+ long_stocks = self.filtered_fine[-portfolio_size:]
+ stocks_invested = [x.Key for x in self.Portfolio]
+ for i in stocks_invested:
+ if i not in long_stocks:
+ self.Liquidate(i)
+ elif i in long_stocks:
+ self.SetHoldings(i, 1/(portfolio_size))
+ self.quarterly_rebalance = False
+ self.filtered_fine = False
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/152 Momentum Effect in REITs/03 Algorithm.html b/04 Strategy Library/152 Momentum Effect in REITs/03 Algorithm.html
new file mode 100644
index 0000000..ad991fb
--- /dev/null
+++ b/04 Strategy Library/152 Momentum Effect in REITs/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/152 Momentum Effect in REITs/04 Source.html b/04 Strategy Library/152 Momentum Effect in REITs/04 Source.html
new file mode 100644
index 0000000..50d2daa
--- /dev/null
+++ b/04 Strategy Library/152 Momentum Effect in REITs/04 Source.html
@@ -0,0 +1,5 @@
+
\ No newline at end of file
diff --git a/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/01 Introduction.html b/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/01 Introduction.html
new file mode 100644
index 0000000..bccce7f
--- /dev/null
+++ b/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/01 Introduction.html
@@ -0,0 +1,4 @@
+
+ Momentum is a well-known strategy that buys stocks with the best return over the past three to twelve months and sells stocks with the worst performances over the same time horizon.
+ The reversal strategy buys the stocks with relatively low returns and sells stocks with high returns. In this algorithm, we will develop a long-short strategy combining the momentum/reversal effect with the realized volatility.
+
diff --git a/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/02 Method.html b/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/02 Method.html
new file mode 100644
index 0000000..94a7056
--- /dev/null
+++ b/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/02 Method.html
@@ -0,0 +1,134 @@
+
The Universe Initial Filter
+
+ The investment universe consists of NYSE, AMEX and NASDAQ stocks with prices higher than $5 per share.
+ In FineSelectionFunction, we divide the universe into two equal halves by size of the company.
+ Here size is defined as the share price times the number of shares outstanding.
+
+
+
+def CoarseSelectionFunction(self, coarse):
+ # update the price of stocks in universe everyday
+ for i in coarse:
+ if i.Symbol not in self.dataDict:
+ self.dataDict[i.Symbol] = SymbolData(i.Symbol, self.lookback)
+ self.dataDict[i.Symbol].Update(i.AdjustedPrice)
+
+ if self.monthly_rebalance:
+ # drop stocks which have no fundamental data or have too low prices
+ filteredCoarse = [x.Symbol for x in coarse if (x.HasFundamentalData) and (float(x.Price) > 5)]
+ return filteredCoarse
+ else:
+ return []
+
+def FineSelectionFunction(self, fine):
+
+ if self.monthly_rebalance:
+ sortedFine = sorted(fine, key = lambda x: x.EarningReports.BasicAverageShares.Value * self.dataDict[x.Symbol].Price, reverse=True)
+ # select stocks with large size
+ topFine = sortedFine[:int(0.5*len(sortedFine))]
+ self.filteredFine = [x.Symbol for x in topFine]
+ return self.filteredFine
+ else:
+ return []
+
+
+
The Realized Return and Volatility
+
+ At the beginning of each month, realized returns and realized (annualized) volatilities are calculated for each stock.
+ The realized volatility refers to the historical volatility. The formula of the realized volatility \(\sigma\) is
+
+ To annualize the volatility, we multiply the 1-day volatility by the square root of the number of trading days in a year – in our case square root of 252.
+
+
+ A 6-month warm-up period is required to initialize the history price for stocks in the universe. We create the class
+ SymbolData to save all required variables associated with a single stock.
+ One week (5 trading days) prior to the beginning of each month is skipped to avoid biases due to microstructures.
+
+
+
+ class SymbolData:
+ '''Contains data specific to a symbol required by this model'''
+
+ def __init__(self, symbol, lookback):
+ self.symbol = symbol
+ # self.History = RollingWindow[Decimal](lookback)
+ self.History = deque(maxlen=lookback)
+ self.Price = None
+
+ def Update(self, value):
+ # update yesterday's close price
+ self.Price = value
+ # update the history price series
+ self.History.append(float(value))
+ # self.History.Add(value)
+
+ def IsReady(self):
+ return len(self.History) == self.History.maxlen
+
+ def Volatility(self):
+ # one week (5 trading days) prior to the beginning of each month is skipped
+ prices = np.array(self.History)[:-5]
+ returns = (prices[1:]-prices[:-1])/prices[:-1]
+ # calculate the annualized realized volatility
+ return np.std(returns)*np.sqrt(252)
+
+ def Return(self):
+ # one week (5 trading days) prior to the beginning of each month is skipped
+ prices = np.array(self.History)[:-5]
+ # calculate the annualized realized return
+ return (prices[-1]-prices[0])/prices[0]
+
+
+
+
+ After the warm-up period, the historical price series is ready. Stocks are sorted into quintiles based on their realized volatility.
+ Stocks in the top 20% highest volatility are further sorted into quintiles by their six-month realized returns.
+ The algorithm goes long on stocks from the highest performing quintile from the highest volatility group and short on stocks from the lowest performing quintile from the highest volatility group.
+
+
+
+def OnData(self, data):
+ if self.monthly_rebalance and self.filteredFine:
+ filtered_data = {symbol: symbolData for (symbol, symbolData) in self.dataDict.items() if symbol in self.filteredFine and symbolData.IsReady()}
+ self.filteredFine = None
+ self.monthly_rebalance = False
+ if len(filtered_data) < 100: return
+ # sort the universe by volatility and select stocks in the top high volatility quintile
+ sortedByVol = sorted(filtered_data.items(), key=lambda x: x[1].Volatility(), reverse = True)[:int(0.2*len(filtered_data))]
+ sortedByVol = dict(sortedByVol)
+ # sort the stocks in top-quintile by realized return
+ sortedByReturn = sorted(sortedByVol, key = lambda x: sortedByVol[x].Return(), reverse = True)
+ long = sortedByReturn[:int(0.2*len(sortedByReturn))]
+ short = sortedByReturn[-int(0.2*len(sortedByReturn)):]
+
+
+
Portfolio Rebalance and Trade
+
+ The methodology of Jegadeesh and Titamn (1993) is used to rebalance the portfolio.
+ Specifically, at the beginning of each month, stocks are sorted into quintiles based on their realized returns and equally weighted portfolios are formed to be held for the next six months.
+ This sorting and portfolio formation procedure is performed each month. In any given month t, the strategy holds 6 portfolios that are selected in the current month as well as the previous 5 months.
+ Therefore 1/6 of the portfolio is rebalanced every month. We save those 6 portfolios in a deque list self.portfolios and the list is updated every month. The portfolio of the current month is added while the portfolio selected from six months ago is removed from the list.
+
+
+
+def Initialize(self):
+ self.portfolios = deque(maxlen=6)
+def OnData(self, data):
+ self.portfolios.append(short+long)
+ # 1/6 of the portfolio is rebalanced every month
+ if len(self.portfolios) == self.portfolios.maxlen:
+ for i in list(self.portfolios)[0]:
+ self.Liquidate(i)
+ # stocks are equally weighted and held for 6 months
+ short_weight = 1/len(short)
+ for i in short:
+ self.SetHoldings(i, -1/6*short_weight)
+
+ long_weight = 1/len(long)
+ for i in long:
+ self.SetHoldings(i, 1/6*long_weight)
+
+
diff --git a/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/03 Algorithm.html b/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/03 Algorithm.html
new file mode 100644
index 0000000..41faf63
--- /dev/null
+++ b/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/04 Source.html b/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/04 Source.html
new file mode 100644
index 0000000..54db2a0
--- /dev/null
+++ b/04 Strategy Library/155 Momentum and Reversal Combined with Volatility Effect in Stocks/04 Source.html
@@ -0,0 +1,5 @@
+
+ The strategy buys SPY ETF at its closing price and sells it at the opening each day.
+ The strategy makes a lot of trades, therefore, the whole strategy is very sensitive
+ to slippage costs and fees. Those returns are canceled out once transaction costs
+ are taken into account. With the InteractiveBrokers transaction model, fees for 20
+ years backtest is almost 25% of the initial cash.
+
diff --git a/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/01 Introduction.html b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/01 Introduction.html
new file mode 100644
index 0000000..d0d909e
--- /dev/null
+++ b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/01 Introduction.html
@@ -0,0 +1,6 @@
+
+ The main reason for the momentum anomaly is the behavioral biases of the investor like underreaction and confirmation bias.
+ Momentum strategy usually uses portfolios filled by thousands of stocks to compute the momentum factor return.
+ This is not possible for small retail investors with small portfolios. They are constrained compared to big hedge funds and cannot diversify so well.
+ In this tutorial, we'll construct a small portfolio consisting of up to 50 stocks to check the effect of momentum.
+
diff --git "a/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/01 \347\256\200\344\273\213.cn.html" "b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/01 \347\256\200\344\273\213.cn.html"
new file mode 100644
index 0000000..e81a4a4
--- /dev/null
+++ "b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/01 \347\256\200\344\273\213.cn.html"
@@ -0,0 +1,3 @@
+
diff --git a/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/02 Method.html b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/02 Method.html
new file mode 100644
index 0000000..e614895
--- /dev/null
+++ b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/02 Method.html
@@ -0,0 +1,66 @@
+
+ The investment universe consists of all US listed companies. Stocks which have no fundamental data are ruled out from the universe.
+
+
+
+def CoarseSelectionFunction(self, coarse):
+ if self.yearly_rebalance:
+ # drop stocks which have no fundamental data
+ self.filtered_coarse = [x.Symbol for x in coarse if (x.HasFundamentalData)]
+ return self.filtered_coarse
+ else:
+ return []
+
+
+
+ In FineSelectionFunction, stocks with the lowest market capitalization (25% of the universe) are excluded due to low liquidity.
+ The momentum is defined as the stock market return over the previous 12 months. Momentum profits are calculated by ranking companies on the basis of yearly return.
+ The ranking period is one year.
+
+
+
+ def FineSelectionFunction(self, fine):
+ if self.yearly_rebalance:
+ # Calculate the yearly return and market cap
+ for i in fine:
+ i.MarketCap = float(i.EarningReports.BasicAverageShares.ThreeMonths * (i.EarningReports.BasicEPS.TwelveMonths*i.ValuationRatios.PERatio))
+ top_market_cap = sorted(fine, key = lambda x:x.MarketCap, reverse=True)[:int(len(fine)*0.75)]
+ has_return = []
+ for i in top_market_cap:
+ history = self.History([i.Symbol], timedelta(days=365), Resolution.Daily)
+ if not history.empty:
+ close = history.loc[str(i.Symbol)]['close']
+ i.returns = (close[0]-close[-1])/close[-1]
+ has_return.append(i)
+ sorted_by_return = sorted(has_return, key = lambda x: x.returns)
+ self.long = [i.Symbol for i in sorted_by_return[-10:]]
+ self.short = [i.Symbol for i in sorted_by_return[:10]]
+
+ return self.long+self.short
+ else:
+ return []
+
+
+
+ The investor goes long in the ten stocks with the highest performance and goes short in the ten stocks with the lowest performance.
+ The portfolio is equally weighted and rebalanced yearly.
+
+
+
+ def OnData(self, data):
+ if not self.yearly_rebalance: return
+ if self.long and self.short:
+ stocks_invested = [x.Key for x in self.Portfolio if x.Value.Invested]
+ # liquidate stocks not in the trading list
+ for i in stocks_invested:
+ if i not in self.long+self.short:
+ self.Liquidate(i)
+ for i in self.short:
+ self.SetHoldings(i, -0.5/len(self.short))
+ for i in self.long:
+ self.SetHoldings(i, 0.5/len(self.long))
+ self.long = None
+ self.short = None
+ self.yearly_rebalance = False
+
+
diff --git "a/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/02 \346\226\271\346\263\225.cn.html" "b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/02 \346\226\271\346\263\225.cn.html"
new file mode 100644
index 0000000..61298fc
--- /dev/null
+++ "b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/02 \346\226\271\346\263\225.cn.html"
@@ -0,0 +1,63 @@
+
+ 投资集合包括所有美国上市公司。没有基本数据的股票被排除在集合之外。
+
+
+
+def CoarseSelectionFunction(self, coarse):
+ if self.yearly_rebalance:
+ # 放弃没有基本数据的股票
+ self.filtered_coarse = [x.Symbol for x in coarse if (x.HasFundamentalData)]
+ return self.filtered_coarse
+ else:
+ return []
+
+ def OnData(self, data):
+ if not self.yearly_rebalance: return
+ if self.long and self.short:
+ stocks_invested = [x.Key for x in self.Portfolio if x.Value.Invested]
+ # 平仓未进入交易清单的股票
+ for i in stocks_invested:
+ if i not in self.long+self.short:
+ self.Liquidate(i)
+ for i in self.short:
+ self.SetHoldings(i, -0.5/len(self.short))
+ for i in self.long:
+ self.SetHoldings(i, 0.5/len(self.long))
+ self.long = None
+ self.short = None
+ self.yearly_rebalance = False
+
+
diff --git a/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/03 Algorithm.html b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/03 Algorithm.html
new file mode 100644
index 0000000..219c782
--- /dev/null
+++ b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git "a/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/03 \347\256\227\346\263\225.cn.html" "b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/03 \347\256\227\346\263\225.cn.html"
new file mode 100644
index 0000000..219c782
--- /dev/null
+++ "b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/03 \347\256\227\346\263\225.cn.html"
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/04 Source.html b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/04 Source.html
new file mode 100644
index 0000000..0cfa5d6
--- /dev/null
+++ b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git "a/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/04 \346\235\245\346\272\220.cn.html" "b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/04 \346\235\245\346\272\220.cn.html"
new file mode 100644
index 0000000..0cfa5d6
--- /dev/null
+++ "b/04 Strategy Library/162 Momentum Effect in Stocks in Small Portfolios/04 \346\235\245\346\272\220.cn.html"
@@ -0,0 +1,5 @@
+
+ Momentum is a trend following strategy, where the strategy buys the assets which have performed well in the past and sells the assets which have performed bad.
+
+ This algorithm applies momentum to the forex market. Our universe consists of 15 forex pairs
+ and covers period from 2006 to 2018. The algorithm goes long 3 currencies with strongest 12-month
+ momentum against USD and goes short 3 currencies with lowest 12-month momentum against USD.
+
diff --git a/04 Strategy Library/18 Volatility Effect in Stocks/01 Introduction.html b/04 Strategy Library/18 Volatility Effect in Stocks/01 Introduction.html
new file mode 100644
index 0000000..20edd72
--- /dev/null
+++ b/04 Strategy Library/18 Volatility Effect in Stocks/01 Introduction.html
@@ -0,0 +1,5 @@
+
+ The low volatility effect in equities refers to that stocks which previously
+ exhibited lower volatility will earn higher risk-adjusted returns than those with higher volatility.
+ This algorithm extends the study of the low volatility effect to U.S stocks with higher market capital.
+
diff --git a/04 Strategy Library/18 Volatility Effect in Stocks/02 Method.html b/04 Strategy Library/18 Volatility Effect in Stocks/02 Method.html
new file mode 100644
index 0000000..8f3cdc8
--- /dev/null
+++ b/04 Strategy Library/18 Volatility Effect in Stocks/02 Method.html
@@ -0,0 +1,17 @@
+
Universe Selection
+
+ To construct the investment universe which consists of US large cap stocks, first in coarse universe selection,
+ we exclude stocks without fundamental data and the price is below 5. A universe of 100 stocks is selected based on the dollar volume. In fine universe selection, we pick 50 stocks from the coarse universe with the highest market cap.
+
+
Calculate the Volatility
+
+ We create SymbolData class and use RollingWindow to store the price data for symbols returned by fine universe.
+ The lookback period is 252 trading days. First, we request history data to initialize the RollingWindow for the added symbols and update it's value with the closing price every day in OnData().
+
+
+ The standard deviation is the typical statistic used to measure volatility. It is defined as the square root of the average variance of the data from its mean. We use the closing price series in RollingWindow to calculate the volatility.
+
+
Trading stocks
+
+ The trading logic is we go long 5 stocks with the lowest volatility and liquidate stocks in the portfolio which does not in the lowest volatility list. The portfolio is rebalanced at the first trading day each month.
+
diff --git a/04 Strategy Library/18 Volatility Effect in Stocks/03 Algorithm.html b/04 Strategy Library/18 Volatility Effect in Stocks/03 Algorithm.html
new file mode 100644
index 0000000..97890a9
--- /dev/null
+++ b/04 Strategy Library/18 Volatility Effect in Stocks/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/18 Volatility Effect in Stocks/04 Source.html b/04 Strategy Library/18 Volatility Effect in Stocks/04 Source.html
new file mode 100644
index 0000000..e9be339
--- /dev/null
+++ b/04 Strategy Library/18 Volatility Effect in Stocks/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/19 Pairs Trading with Stocks/01 Introduction.html b/04 Strategy Library/19 Pairs Trading with Stocks/01 Introduction.html
new file mode 100644
index 0000000..d22f310
--- /dev/null
+++ b/04 Strategy Library/19 Pairs Trading with Stocks/01 Introduction.html
@@ -0,0 +1,6 @@
+
+ The pairs trading algorithm aims to find two stocks which have prices that moved historically together.
+ If price series diverges, long and short positions are opened in the opposite direction. With the assumption
+ of mean reversion, the algorithm expects to make profits from the abnormal fluctuation of prices.
+ The crucial part of pairs trading is determining which stocks are correlated and how to define a price divergence.
+
diff --git a/04 Strategy Library/19 Pairs Trading with Stocks/02 Method.html b/04 Strategy Library/19 Pairs Trading with Stocks/02 Method.html
new file mode 100644
index 0000000..0a9dd73
--- /dev/null
+++ b/04 Strategy Library/19 Pairs Trading with Stocks/02 Method.html
@@ -0,0 +1,14 @@
+
Pairs Formation
+
+ The first step of this algorithm is to select stock pairs from a universe of stocks. We use the history request to get the history closing price for the last one year. This is called the formation period.
+ The matching partner for each stock is found by looking for the security that minimizes the sum of squared deviations between two normalized price series. Assume there are two stocks A and B with the price series X and Y. For price normalization, the starting price during formation period is set to $1.
+ The formula of distance measure is
+ \[\sum_{i=1}^n{(\frac{x_i}{x_1}-\frac{y_i}{y_1}})^2\]
+ Top 4 pairs with the smallest historical distance measure are then traded. The trading pairs are selected
+ every half year. We use the schedule event method to fire the rebalance function.
+
+
Trading Pairs
+
+ As prices in a pair of stocks were closely cointegrated in past, there is high probability that those two securities share common sources of fundamental return correlations. A temporary shock could move one stock out of the common price band which presents statistical arbitrage opportunity. Given the trading pairs, the trading period is the next six months. We calculate the price spread series of the last one year. When pair prices have diverged by two standard deviations,
+ which means the spread is 2 times standard deviation away from its long-term mean, the algorithm will go short the stock which price is diverging up and go long the stock which price is diverging down. The position is closed when prices revert back.
+
diff --git a/04 Strategy Library/19 Pairs Trading with Stocks/03 Algorithm.html b/04 Strategy Library/19 Pairs Trading with Stocks/03 Algorithm.html
new file mode 100644
index 0000000..4b088a3
--- /dev/null
+++ b/04 Strategy Library/19 Pairs Trading with Stocks/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/19 Pairs Trading with Stocks/04 Source.html b/04 Strategy Library/19 Pairs Trading with Stocks/04 Source.html
new file mode 100644
index 0000000..e8be166
--- /dev/null
+++ b/04 Strategy Library/19 Pairs Trading with Stocks/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/01 Introduction.html b/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/01 Introduction.html
new file mode 100644
index 0000000..f975737
--- /dev/null
+++ b/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/01 Introduction.html
@@ -0,0 +1,8 @@
+
+ The Chicago Board Options Exchange (CBOE) introduced the Volatility Index (VIX) in 1993 to provide a measure of the implied volatility of 30-day, at the money S&P 100 index options.
+ Volatility has become a widely accepted asset class since the introduction of the VIX futures contracts in 2004. VIX futures are often used for hedging purpose because of its negative correlation with the equity market return. When we talk about the term structure of futures, we often refer to the forward curve.
+ The VIX forward curve consists of VIX futures prices at various delivery times in the future.
+ Academic research states that volatility follows a mean reverting process. When the VIX futures curve is upward sloped (in contango),
+ the VIX is expected to rise because it is low relative to long-term average levels and vice versa for the downward sloped VIX future curve.
+ In this study, we will create a strategy with the term structure effect of VIX futures and hedge the term structure risk with the S&P500 futures.
+
diff --git a/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/02 Method.html b/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/02 Method.html
new file mode 100644
index 0000000..3463891
--- /dev/null
+++ b/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/02 Method.html
@@ -0,0 +1,182 @@
+
+ The trading strategy uses VIX futures as a trading vehicle and S&P E-mini for hedging purposes. The spot VIX price data and
+ the continuous front contract price of VIX and E-mini S&P500 futures in the daily resolution are from Quandl.
+
+
+
+def Initialize(self):
+ self.SetStartDate(2011, 1, 1) # Set Start Date
+ self.SetEndDate(2018, 9, 1) # Set End Date
+ self.SetCash(10000000) # Set Strategy Cash
+ self.vix = self.AddData(QuandlVix, "CBOE/VIX", Resolution.Daily).Symbol # Add Quandl VIX price (daily)
+ self.vx1 = self.AddData(QuandlFutures, "CHRIS/CBOE_VX1", Resolution.Daily).Symbol # Add Quandl VIX front month futures data (daily)
+ self.es1 = self.AddData(QuandlFutures, "CHRIS/CME_ES1", Resolution.Daily).Symbol # Add Quandl E-mini S&P500 front month futures data (daily)
+ # Add VIX futures contract data
+ self.AddFuture(Futures.Indices.VIX).SetFilter(timedelta(0), timedelta(days=180))
+ # Add E-mini S&P500 futures contract data
+ self.AddFuture(Futures.Indices.SP500EMini).SetFilter(timedelta(0), timedelta(days=180))
+
+
+
+ Futures basis is defined as the difference between the underlying product cash price and futures contract price at a given time.
+
+\[Basis_t=S_t-F_t\]
+
+ Where \(S_t\) is the spot VIX price, \(F_t\) is the VIX futures price. The basis is in contango means the futures price is higher than the spot price.
+ The opposite of Contango is Backwardation. It refers to the market condition in which the futures price is less than the spot price.
+
+\[Contango=S_tF_t\]
+
+ We select the nearest VIX and E-mini futures with at least ten trading days to maturity in the futures chains.
+
+
+
+def OnData(self, data):
+ # select the nearest VIX and E-mini S&P500 futures with at least 10 trading days to maturity
+ # if the front contract expires, roll forward to the next nearest contract
+ for chain in data.FutureChains:
+ if chain.Key.Value == Futures.Indices.VIX:
+ if self.front_VX is None or ((self.front_VX.Expiry-self.Time).days <= 1):
+ contracts = list(filter(lambda x: x.Expiry >= self.Time + timedelta(days = 10), chain.Value))
+ self.front_VX = sorted(contracts, key = lambda x: x.Expiry)[0]
+ if chain.Key.Value == Futures.Indices.SP500EMini:
+ if self.front_ES is None or ((self.front_ES.Expiry-self.Time).days <= 1):
+ contracts = list(filter(lambda x: x.Expiry >= self.Time + timedelta(days = 10), chain.Value))
+ self.front_ES = sorted(contracts, key = lambda x: x.Expiry)[0]
+
+
+
+ While this trading strategy takes advantage of the roll by selling VIX futures at a premium to the VIX and by buying VIX futures at a discount to the VIX,
+ it is exposed to the potentially substantial risks associated with adverse moves in the VIX futures curve. However, as the tendency of VIX futures prices to move inversely to equity returns,
+ much of this risk can be hedged by open the E-mini S&P 500 futures position in the same direction.
+
+
+ The number of mini-S&P futures contracts to buy or sell per VIX futures contract is based on the hedge ratio estimates.
+ The hedge ratios are constructed from regressions of VIX futures price changes on a constant and
+ on contemporaneous percentage changes of the front mini-S&P 500 futures contract both alone and
+ multiplied by the number of business days that the VIX futures contract is from the settlement, as shown below.
+
+ Our daily futures price data is from the continuous front contract. To measure the time to settlement, we import the custom data of the VIX futures expiration dates from 2011 to 2018.
+ We populate the date index with the backward fill method to make it easy to calculate the time to settlement.
+
+
+
+# import the futures expiry calendar
+url = "https://www.dropbox.com/s/5k4rbuzfsfn3w0h/expiry.csv?dl=1"
+data = self.Download(url).split('\r\n')
+expiry = [x.split(',')[1] for x in data][1:]
+date = [x.split(',')[0] for x in data][1:]
+df_date = pd.DataFrame(expiry, index = date, columns = ['expiry'])
+df_date.index = pd.to_datetime(df_date.index)
+df_date['expiry'] = pd.to_datetime(df_date['expiry'])
+idx = pd.date_range('01-01-2011', '04-19-2019')
+# populate the date index and backward fill the dataframe
+return df_date.reindex(idx, method='bfill')
+
+
+
+ To perform the regression, we save the history price in deque list and update the list every day.
+
+
+
+# the rolling window to save the front month VX future price
+self.price_VX = deque(maxlen=252)
+# the rolling window to save the front month ES future price
+self.price_ES = deque(maxlen=252)
+# the rolling window to save the time-to-maturity of the contract
+self.days_to_maturity = deque(maxlen=252)
+# initialize the deque list
+for index, row in df.iterrows():
+ self.price_VX.append(row[self.vx1])
+ self.price_ES.append(row[self.es1])
+ self.days_to_maturity.append((row['expiry']-index).days)
+
+
+
+
+ The daily roll is defined as the difference between the front VIX futures price and the VIX, divided by the number of business days until the VIX futures contract settles.
+ Short VIX futures positions are entered when the VIX futures basis is in contango and the daily roll exceeds 0.10 and
+ long VIX futures positions are entered when the VIX futures basis is in backwardation and the daily roll is less than -0.10.
+
+
+
+# calculate the daily roll
+daily_roll = (self.Securities[self.vx1].Price - self.Securities[self.vix].Price)/(self.front_VX.Expiry-self.Time).days
+self.Plot("Trade", "VIX", self.Securities[self.vix].Price)
+self.Plot("Trade", "VIX Futures", self.Securities[self.vx1].Price)
+self.Plot("Trade", "Daily Roll", daily_roll)
+if not self.Portfolio[self.front_VX.Symbol].Invested:
+ # Short if the contract is in contango with adaily roll greater than 0.10
+ if daily_roll > 0.1:
+ hedge_ratio = self.CalculateHedgeRatio()
+ self.Plot("Trade", "Sell", self.Securities[self.vx1].Price)
+ self.SetHoldings(self.front_VX.Symbol, -0.5)
+ self.SetHoldings(self.front_ES.Symbol, -0.5*hedge_ratio)
+ # Long if the contract is in backwardation with adaily roll less than -0.10
+ elif daily_roll < -0.1:
+ hedge_ratio = self.CalculateHedgeRatio()
+ self.Plot("Trade", "Buy", self.Securities[self.vx1].Price)
+ self.SetHoldings(self.front_VX.Symbol, 0.5)
+ self.SetHoldings(self.front_ES.Symbol, 0.5*hedge_ratio)
+
+
+
+ Trades are exited when the motivating conditions no longer exist.
+ The exit condition is defined as the daily roll being less than 0.05 for short trades and higher than -0.05 VIX futures points for long trades.
+ If these exit conditions are not triggered, trades are exited two days before the contract expires.
+
+
+
+# exit if the daily roll being less than 0.05 if holding short positions
+if self.Portfolio[self.front_VX.Symbol].IsShort and daily_roll < 0.05:
+ self.Liquidate()
+ self.front_VX = None
+ self.front_ES = None
+ return
+
+# exit if the daily roll being greater than -0.05 if holding long positions
+if self.Portfolio[self.front_VX.Symbol].IsLong and daily_roll > -0.05:
+ self.Liquidate()
+ self.front_VX = None
+ self.front_ES = None
+ return
+
+if self.front_VX and self.front_ES:
+# if these exit conditions are not triggered, trades are exited two days before it expires
+if self.Portfolio[self.front_VX.Symbol].Invested and self.Portfolio[self.front_ES.Symbol].Invested:
+ if (self.front_VX.Expiry-self.Time).days <=2 or (self.front_ES.Expiry-self.Time).days <=2:
+ self.Liquidate()
+ self.front_VX = None
+ self.front_ES = None
+ return
+
+
diff --git a/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/03 Algorithm.html b/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/03 Algorithm.html
new file mode 100644
index 0000000..41e0455
--- /dev/null
+++ b/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/04 Source.html b/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/04 Source.html
new file mode 100644
index 0000000..fc12d36
--- /dev/null
+++ b/04 Strategy Library/198 Exploiting Term Structure of VIX Futures/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/199 ROA Effect within Stocks/01 Introduction.html b/04 Strategy Library/199 ROA Effect within Stocks/01 Introduction.html
new file mode 100644
index 0000000..1848e9e
--- /dev/null
+++ b/04 Strategy Library/199 ROA Effect within Stocks/01 Introduction.html
@@ -0,0 +1,5 @@
+
+ Return on Equity(ROE) is defined as the ratio of net income over shareholders equity,
+ where shareholders’ equity is the difference between a company's total assets and total liabilities. Shareholders' equity is often referred to as the book value of the company.
+ ROE is a measure of how efficiently a company uses its assets to produce earnings. It can explain many anomalies related to earnings and profitability. This algorithm will build a long-short portfolio with ROE factor.
+
diff --git a/04 Strategy Library/199 ROA Effect within Stocks/02 Method.html b/04 Strategy Library/199 ROA Effect within Stocks/02 Method.html
new file mode 100644
index 0000000..774d359
--- /dev/null
+++ b/04 Strategy Library/199 ROA Effect within Stocks/02 Method.html
@@ -0,0 +1,74 @@
+
+ The investment universe contains all stocks on NYSE and AMEX and Nasdaq.
+ In CoarseSelectionFunction, we eliminated ETFs which does not have fundamental data.
+
+
+
+def CoarseSelectionFunction(self, coarse):
+ if self.monthly_rebalance:
+ self.coarse = True
+ filteredCoarse = [x.Symbol for x in coarse if x.HasFundamentalData]
+ return filteredCoarse
+ else:
+ return []
+
+
+
+ In FineSelectionFunction, stocks with sales greater than 10 milion USD are selected.
+ Then we calculate the market cap for those stocks and sort them into two groups: Big size group with the higher market cap and small size group with the lower market cap. Each half is then divided into deciles based on Return on assets (ROA).
+
+
+
+def FineSelectionFunction(self, fine):
+ if self.monthly_rebalance:
+ fine =[i for i in fine if i.EarningReports.BasicAverageShares.ThreeMonths != 0
+ and i.EarningReports.BasicEPS.TwelveMonths != 0
+ and i.ValuationRatios.PERatio != 0
+ # sales is greater than 10 million
+ and i.ValuationRatios.SalesPerShare*i.EarningReports.DilutedAverageShares.Value > 10000000
+ and i.OperationRatios.ROA.Value != 0]
+ for i in fine:
+ i.MarketCap = float(i.EarningReports.BasicAverageShares.ThreeMonths * (i.EarningReports.BasicEPS.TwelveMonths*i.ValuationRatios.PERatio))
+ # sort into 2 halfs based on market capitalization
+ sorted_market_cap = sorted(fine, key = lambda x:x.MarketCap, reverse=True)
+ top = sorted_market_cap[:int(len(sorted_market_cap)*0.5)]
+ bottom = sorted_market_cap[-int(len(sorted_market_cap)*0.5):]
+ # each half is then divided into deciles based on Return on Assets (ROA)
+ sortedTopByROA = sorted(top, key = lambda x: x.OperationRatios.ROA.Value, reverse = True)
+ sortedBottomByROA = sorted(bottom, key = lambda x: x.OperationRatios.ROA.Value, reverse = True)
+ # long top decile from each market capitalization group
+ long = sortedTopByROA[:int(len(sortedTopByROA)*0.1)] + sortedBottomByROA[:int(len(sortedTopByROA)*0.1)]
+ self.longStocks = [i.Symbol for i in long]
+ # short bottom decile from each market capitalization group
+ short = sortedTopByROA[-int(len(sortedTopByROA)*0.1):] + sortedBottomByROA[-int(len(sortedTopByROA)*0.1):]
+ self.shortStocks = [i.Symbol for i in short]
+
+ return self.longStocks+self.shortStocks
+ else:
+ return []
+
+
+
+ The algorithm goes long the top decile from each market capitalization group and short the bottom decile.
+ The strategy is rebalanced monthly and stocks are equally weighted.
+
+
+
+ def OnData(self, data):
+ if not (self.monthly_rebalance and self.coarse): return
+ self.coarse = False
+ self.monthly_rebalance = False
+ stocks_invested = [x.Key for x in self.Portfolio if x.Value.Invested]
+ for i in stocks_invested:
+ if i not in self.longStocks+self.shortStocks:
+ self.Liquidate(i)
+
+ long_weight = 0.5/len(self.longStocks)
+ for i in self.longStocks:
+ self.SetHoldings(i, long_weight)
+
+ short_weight = 0.5/len(self.shortStocks)
+ for i in self.shortStocks:
+ self.SetHoldings(i, -short_weight)
+
+
diff --git a/04 Strategy Library/199 ROA Effect within Stocks/03 Algorithm.html b/04 Strategy Library/199 ROA Effect within Stocks/03 Algorithm.html
new file mode 100644
index 0000000..66e4458
--- /dev/null
+++ b/04 Strategy Library/199 ROA Effect within Stocks/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/199 ROA Effect within Stocks/04 Source.html b/04 Strategy Library/199 ROA Effect within Stocks/04 Source.html
new file mode 100644
index 0000000..137b5de
--- /dev/null
+++ b/04 Strategy Library/199 ROA Effect within Stocks/04 Source.html
@@ -0,0 +1,5 @@
+
+ Carry trade is very common in the foreign exchange market.
+ The strategy systematically sells low-interest rate currencies and buys high-interest rates currencies. The “carry” of an asset is the opportunity cost of holding that asset. Carry trade strategy holds one currency relative to another in order to capture the spread between the rates. We can think of this strategy as borrowing money from one country with a lower interest rate and investing it in another country with a higher interest rate.
+
+ The central bank interest rate data is from Quandl. For the trading universe, we choose 9 currencies
+ whose central bank interest rate data is available in Quandl. The method to import the custom data is
+ AddData(type, symbol, resoltuion, timeZone, fillDataForward). As the custom file has it's unique
+ colume name, we need to create a class to specify the colume name of interest rate.
+
+ We save the interest rate symbol and the correspondent forex asset symbol into a dictionary.
+
+
Monthly Rebalance Trading
+
+ Next step we sort the forex symbol by the value of interest rate. The algorithm goes long the currency with the highest interest rates and goes short the currency with the lowest interest rate. The strategy is rebalanced monthly. The schedule event method is used to fire the rebalance event at the first trading day each month.
+
diff --git a/04 Strategy Library/207 Value Effect within Countries/01 Introduction.html b/04 Strategy Library/207 Value Effect within Countries/01 Introduction.html
new file mode 100644
index 0000000..2f1fbdc
--- /dev/null
+++ b/04 Strategy Library/207 Value Effect within Countries/01 Introduction.html
@@ -0,0 +1,5 @@
+
+ Equity valuation may be a predictive signal for future equity return. There are various methodologies to evaluate whether
+ the equity is undervalued or overvalued using metrics like price-to-earnings (P/E), return on equity (ROE), dividend yield, book-to-equity and so on.
+ In this algorithm, we use a ten-year normalized earnings metrics invented by Yale University professor Robert Shiller to find the fair value of the equity market.
+
diff --git a/04 Strategy Library/207 Value Effect within Countries/02 Method.html b/04 Strategy Library/207 Value Effect within Countries/02 Method.html
new file mode 100644
index 0000000..a6db2f9
--- /dev/null
+++ b/04 Strategy Library/207 Value Effect within Countries/02 Method.html
@@ -0,0 +1,88 @@
+
+ The cyclically adjusted price-to-earnings ratio (CAPE) compares the stock prices with earnings smoothed across multiple years.
+ It is the price divided by the average of ten years of earnings (moving average), adjusted for inflation.
+ The backward-looking earnings smooth out the economic cycle as well as the price fluctuations.
+
+
+ The investment universe consists of 22 countries with easily accessible equity markets via ETFs.
+ We import the custom CAPE ratio(Shiller PE Ratio) data of those 22 countries and create a dictionary to save the corresponding country ETF.
+ This data from Quandl is in monthly resolution and starts January 2000.
+
+
+
+ class CAPE(PythonData):
+
+ def GetSource(self, config, date, isLiveMode):
+ return SubscriptionDataSource("https://www.dropbox.com/s/fcv8x1xeqamg5lx/CAPERatio.csv?dl=1", SubscriptionTransportMedium.RemoteFile)
+
+ def Reader(self, config, line, date, isLiveMode):
+ if not (line.strip() and line[1].isdigit()): return None
+ index = CAPE()
+ index.Symbol = config.Symbol
+ # data format
+ # Date Canada UK United States France Germany Italy Spain ...
+ # 1/31/00 45.7 25.08 42.18 55.94 51.35 54.34 32.16 ...
+ data = line.split(',')
+ index.Time = datetime.strptime(data[0], "%m/%d/%y")
+ symbols = Symbols().tickers
+ for key, value in symbols.items():
+ index[key] = float(data[value[0]]) if data[value[0]] else None
+ return index
+
+
+ class Symbols:
+ def __init__(self):
+ # the indiex is the country name
+ # the first element of the value is the column number of CAPE ratio value in custom dataset
+ # the second element of the value is the corresponding country ETF
+
+ self.tickers = {"Canada":[1, "XIC"], # S&P/TSX Composite Index: iShares S&P TSX Capped Cmpst Indx Fnd
+ "Uk":[2, "EWU"], # FTSE 100 Index: iShares MSCI United Kingdom ETF
+ "Us":[3, "SPY"], # S&P 500 Index: SPDR S&P 500 ETF
+ "France":[4, "EWQ"], # CAC 40 Index: iShares MSCI France ETF
+ "Germany":[5, "EWG"], # HDAX Index: iShares MSCI Germany ETF
+ "Italy":[6, "EWI"], # FTSE MIB Index: iShares MSCI Italy ETF
+ "Spain":[7, "EWP"], # IBEX 35 Index: iShares MSCI Spain ETF
+ "Russia":[8, "ERUS"], # RTS Index: iShares MSCI Russia ETF
+ "India":[9, "INDY"], # NIFTY 50 Index: iShares India 50 ETF
+ "Japan":[10, "EWJ"], # All Public Companies: iShares MSCI Japan ETF
+ "Singapore":[11, "EWS"], # STI Index: iShares MSCI Singapore ETF
+ "Korea":[12,"EWY"], # KOSPI Index: iShares MSCI South Korea ETF
+ "China":[13, "MCHI"], # SSE Composite: iShares MSCI China Index Fund
+ "Hongkong":[14, "EWH"], # Hang Seng Index: iShares MSCI Hong Kong Index Fund
+ "Brazil":[15, "EWZ"], # Indice Bovespa (Ibovespa): iShares MSCI Brazil ETF
+ "Mexico":[16, "EWW"], # &P/BMV IPC Index: iShares MSCI Mexico ETF
+ "Southafrica":[17, "EZA"], # FTSE/JSE CAP Top 40 Index: iShares MSCI South Africa ETF
+ "Australia":[18, "EWA"], # ASX All Ordinaries Index: iShares MSCI Australia ETF
+ "Turkey":[19, "TUR"], # BIST 100: iShares MSCI Turkey ETF
+ "Poland":[20, "EPOL"], # WIG Index: iShares MSCI Poland ETF
+ "Indonesia":[21, "EIDO"], # IDX Composite: iShares MSCI Indonesia ETF
+ "Philippines":[22, "EPHE"]} # PSE Composite: iShares MSCI Philippines Investable
+
+
+
+ According to the academic research of Shiller and Campbell using market data from the S&P index, the lower the CAPE, the higher the investors' likely return from equities.
+ Therefore, the algorithm then invests in the cheapest 33% of countries from the sample with the lowest CAPE ratio if those countries have a CAPE below 15.
+ If there are no countries with CAPE lower than 15, the algorithm holds cash instead of country ETFs.
+ The portfolio is equally weighted and rebalanced monthly.
+
+
+
+ def Rebalance(self):
+ self.cape = {}
+ for key, value in self.symbols.items():
+ cape = getattr(self.slice["CAPE"], key)
+ if cape is not None:
+ self.cape[value[1]] = cape
+ sorted_cape = sorted(self.cape, key = lambda x: self.cape[x])
+ # invests the cheapest 33% of countries if those countries have a CAPE below 15
+ lowest_cape = sorted_cape[:int(1/3*len(sorted_cape))]
+ long_list = [i for i in lowest_cape if self.cape[i]<15]
+ invested = [x.Key for x in self.Portfolio if x.Value.Invested]
+ for i in invested:
+ if i.Value not in long_list:
+ self.Liquidate(i)
+ for i in long_list:
+ self.SetHoldings(i, 1/len(long_list))
+
+
diff --git a/04 Strategy Library/207 Value Effect within Countries/03 Algorithm.html b/04 Strategy Library/207 Value Effect within Countries/03 Algorithm.html
new file mode 100644
index 0000000..f2180a0
--- /dev/null
+++ b/04 Strategy Library/207 Value Effect within Countries/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/207 Value Effect within Countries/04 Source.html b/04 Strategy Library/207 Value Effect within Countries/04 Source.html
new file mode 100644
index 0000000..66df9ad
--- /dev/null
+++ b/04 Strategy Library/207 Value Effect within Countries/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/21 Momentum Effect in Stocks/01 Introduction.html b/04 Strategy Library/21 Momentum Effect in Stocks/01 Introduction.html
new file mode 100644
index 0000000..6baa7a8
--- /dev/null
+++ b/04 Strategy Library/21 Momentum Effect in Stocks/01 Introduction.html
@@ -0,0 +1,3 @@
+
+The momentum anomaly says that what was strongly going up in the near past will probably continue to go up shortly. Stocks which outperform peers on 3-12 month period tend to perform well also in the future. This algorithm will explore the momentum effect on large-cap stocks.
+
diff --git a/04 Strategy Library/21 Momentum Effect in Stocks/02 Method.html b/04 Strategy Library/21 Momentum Effect in Stocks/02 Method.html
new file mode 100644
index 0000000..2dc76cf
--- /dev/null
+++ b/04 Strategy Library/21 Momentum Effect in Stocks/02 Method.html
@@ -0,0 +1,20 @@
+
Universe Selection
+
+ We use the universe selection API to create a momentum portfolio. Our coarse-universe selection eliminates stocks with a price lower than $5 and ETFs which do not have fundamental data. Fine-universe selection chooses the 50 largest companies ranked by market capitalization.
+
+
Momentum Calculation
+
+ Momentum is the absolute difference in stocks.
+ \[Momentum = Close_{today}-Close_{N-days-ago}\]
+
+ Dictionary self.mom is used to save the LEAN Momentum class instance Momentum for each symbol.
+ In OnSecuritiesChanged event method, we add the newly selected symbol to the dictionary and initialize the momentum indicator with the history request. For symbols removed from the universe, we remove it from the dictionary and liquidate its positions. Each day in OnData, the Momentum indicator for all symbols in the dictionary will be updated with the latest closing price.
+
+
+ We choose a period of 12 months for the momentum indicator. Stocks with the best 12-month momentum (12-month performance) are then added to our portfolio and are weighted equally.
+
+
+
Monthly Rebalance
+
+ The portfolio is rebalanced once a month. The coarse and fine universe selection is set to default to run at midnight once a day. To make the universe selection run at the first trading day each month, we use the int variable self.month that tracks the current month to manage the universe selection. At the start of each month, the universe selection will filter new stocks. On all other days, the universe selection function will return Universe.Unchanged. In contrast to returning an empty list or a list of previously selected symbols, returning Universe.Unchanged is the best way for monthly rebalance universe selection. If there are no open positions for certain symbol, returning an empty list will stop the data subscription of that symbol and halt updates of the indicator.
+
diff --git a/04 Strategy Library/21 Momentum Effect in Stocks/03 Algorithm.html b/04 Strategy Library/21 Momentum Effect in Stocks/03 Algorithm.html
new file mode 100644
index 0000000..b92aa3f
--- /dev/null
+++ b/04 Strategy Library/21 Momentum Effect in Stocks/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/21 Momentum Effect in Stocks/04 Source.html b/04 Strategy Library/21 Momentum Effect in Stocks/04 Source.html
new file mode 100644
index 0000000..f50729f
--- /dev/null
+++ b/04 Strategy Library/21 Momentum Effect in Stocks/04 Source.html
@@ -0,0 +1,5 @@
+
+ Statistical arbitrage strategies uses mean-reversion models to take advantage of pricing inefficiencies between groups of correlated
+ securities. This class of short-term financial trading strategies produce moves that can contrarian to the broader market movement and are often discussed in conjunction with
+ Pairs Trading.
+ In our algorithm, we will be using a PCA-based approach as opposed to an ETF-based approach to limit our universe of stocks.
+ Backtests from the period 1997-2007 support our strategy by showing that PCA-based strategies have Sharpe ratios that outperform Sharpe ratios
+ from ETF-based strategies.
+
+
diff --git a/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/02 Method.html b/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/02 Method.html
new file mode 100644
index 0000000..bdbfa32
--- /dev/null
+++ b/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/02 Method.html
@@ -0,0 +1,66 @@
+
Step 1: Select our universe
+
+ We will select our universe of stocks by dropping securities with prices lower than $5 and pick the ones with the highest dollar traded volume.
+
+
+
+
+ # Sort the equities in DollarVolume decendingly
+ selected = sorted([x for x in coarse if x.Price > 5],
+ key=lambda x: x.DollarVolume, reverse=True)
+ symbols = [x.Symbol for x in selected[:self.num_equities]]
+
+
+
+
Step 2: Reduce dimensions to three principal components
+
+ We want to minimize our algorithm's exposure to market factors. PCA is a procedure that extracts uncorrelated components of a possibly-correlated set of observations to reveal the factors that contribute most to a the variance of the observations as a whole. Applying PCA to the data above enables us to reduce dimensionality and select the most relevant market factors to shape our asset universe.
+ Based on the results found in the cited paper, and for the sake of demonstration, we chose 3 components to account for the bulk of the variance.
+ In our algorithm, the 3 principal components of the feature space are formed by the historical close values.
+
+
+
+
+ # Sample data for PCA (smooth it using np.log function)
+ sample = np.log(history.dropna(axis=1))
+ sample -= sample.mean() # Center it column-wise
+
+ # Fit the PCA model for sample data
+ model = PCA().fit(sample)
+
+ # Get the first n_components factors
+ factors = np.dot(sample, model.components_.T)[:,:self.num_components]
+
+
+
+
Step 3: Measure price deviation
+
+ We will model the mean-reverting residuals of our assets from a regression line.
+ We use linear regression to derive the weight of each stock in the portfolio based on its price deviation, which is measured by the residual.
+ If the absolute value of a stock's residual is large, it means that the level of price deviation is high and we should give it
+ more weight in the portfolio. Similarly, if the absolute value of the residual is small,
+ it is reasonable to give the stock less weight in the portfolio. To facilitate this, we can first standardize the residuals to get
+ their z-scores. Then, based on the z-scores, it is easy to detect the level of price deviation.
+ Specifically, the level of deviation is higher when the absolute values of the z-scores are large.
+ From this it is natural to use the inverse of the absolute values of the z-scores as a measurement of the weights of the portfolio.
+
+
+
+
+ # Train Ordinary Least Squares linear model for each stock
+ OLSmodels = {ticker: sm.OLS(sample[ticker], factors).fit() for ticker in sample.columns}
+
+ # Get the residuals from the linear regression after PCA for each stock
+ resids = pd.DataFrame({ticker: model.resid for ticker, model in OLSmodels.items()})
+
+ # Get the Z scores by standarize the given pandas dataframe X
+ zscores = ((resids - resids.mean()) / resids.std()).iloc[-1] # residuals of the most recent day
+
+ # Get the stocks far from mean (for mean reversion)
+ selected = zscores[zscores < -1.5]
+
+ # Return the weights for each selected stock
+ weights = selected * (1 / selected.abs().sum())
+
+
+
diff --git a/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/03 Results.html b/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/03 Results.html
new file mode 100644
index 0000000..5c3f0f7
--- /dev/null
+++ b/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/03 Results.html
@@ -0,0 +1,11 @@
+
+ In our alorithm, the portfolio is rebalanced every 30 days and the backtest period runs from Jan 2010 to Aug 2019.
+ Our result is an annual rate of return over 7% with a max drawdown of around 40% for nearly 10 years. Our performance indicates
+ using PCA combined with linear regression to measure the deviation level is reasonable.
+
+
+ To tune the model, we could expand our universe of stocks beyond the current 20 equities or incorporate more PCA components.
+ We could also come up with another way to measure the level of deviation or change the rebalance frequency of the algorithm
+ (30 days in this example).
+
+
diff --git a/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/04 Algorithm.html b/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/04 Algorithm.html
new file mode 100644
index 0000000..78e62f1
--- /dev/null
+++ b/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/05 Reference.html b/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/05 Reference.html
new file mode 100644
index 0000000..218aff7
--- /dev/null
+++ b/04 Strategy Library/211 Mean-Reversion Statistical Arbitrage Strategy in Stocks/05 Reference.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/01 Introduction.html b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/01 Introduction.html
new file mode 100644
index 0000000..37a614e
--- /dev/null
+++ b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ This algorithm examines the momentum effect in country indexes exchange-traded funds.
+
diff --git "a/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/01 \347\256\200\344\273\213.cn.html" "b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/01 \347\256\200\344\273\213.cn.html"
new file mode 100644
index 0000000..6b02628
--- /dev/null
+++ "b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/01 \347\256\200\344\273\213.cn.html"
@@ -0,0 +1,3 @@
+
+ 此算法检验了国家指数交易所交易基金的动量效应。
+
diff --git a/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/02 Method.html b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/02 Method.html
new file mode 100644
index 0000000..6b6f900
--- /dev/null
+++ b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/02 Method.html
@@ -0,0 +1,8 @@
+
+The algorithm picks 35 country indexes ETFs as the trading universe. As the symbols in the universe don't change over time, we use the momentum indicator helper method
+ self.MOM(symbol, period, resolution). This helper method creates a new momentum indicator and computes the absolute n-period change in the security. In contrast to the indicator constructor Momentum(period), the helper method indicator will be automatically updated on the given resolution.
+
+
+ In Initialize(), we set the warm-up period to the momentum period and create the dictionary self.data to save the indicator of
+ each symbol. On each month, the top five indexes ETFs with the best 6-month momentum will be selected to open long position. ETFs which are no longer in this top list will be liquidated. The scheduled event API is used to schedule the portfolio to rebalance at the start of each month.
+
diff --git "a/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/02 \346\226\271\346\263\225.cn.html" "b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/02 \346\226\271\346\263\225.cn.html"
new file mode 100644
index 0000000..7b69538
--- /dev/null
+++ "b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/02 \346\226\271\346\263\225.cn.html"
@@ -0,0 +1,6 @@
+
diff --git a/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/03 Conclusion.html b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/03 Conclusion.html
new file mode 100644
index 0000000..5b5cc52
--- /dev/null
+++ b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/03 Conclusion.html
@@ -0,0 +1,4 @@
+
+ The algorithm result shows that momentum effects do exist in the country indices.
+ The strategy of holding for one month, a portfolio of the five best performing country indices ETFs over the previous six months, was found to out-perform the equal-weighted portfolio by around 40% per annum over the 16-year period from 2002 to 2018.
+
diff --git "a/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/03 \347\273\223\350\256\272.cn.html" "b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/03 \347\273\223\350\256\272.cn.html"
new file mode 100644
index 0000000..b3aecfd
--- /dev/null
+++ "b/04 Strategy Library/22 Momentum Effect in Country Equity Indexes/03 \347\273\223\350\256\272.cn.html"
@@ -0,0 +1,3 @@
+
+ Multiple factors can explain abnormal equity returns which could be used to build profitable equity long-short strategy.
+ The most common factors are momentum, short-term reversal, market value, size factors and so on.
+ In this tutorial, we will choose a few factors associated with earnings quality to investigate the return premium on stocks.
+
+ Earnings quality refers to the ability of reported earnings to predict a company's future earnings.
+ The earnings should be attributable to higher sales or lower costs, rather than artificial profits created by accounting anomalies or tricks such as inflation of inventories or changing depreciation.
+ It is one of the most critical measures in financial reporting systems. High earnings quality indicates a healthy development in the firm's business and can improve the market efficiency.
+
+
+ The first metric of earnings quality is accruals. It is defined by cash flow relative to reported earnings. The high-quality earnings firms are characterized by low accruals while the low-quality firms are characterized by high accruals.
+ The formula is
+
\(\Delta Cash\) = change in cash and cash equivalents
+
\(\Delta CL\) = change in current liabilities
+
\(\Delta STD\) = change in debt included in current liabilities
+
\(\Delta ITP\) = change in income taxes payable
+
\(\Delta Dep\) = annual depreciation and amortization expense
+
+
+ We use an annual change reported for two consecutive fiscal years.
+ To calculate the accruals, we save the fine fundamental object in the last year and calculate the difference in the next year.
+ The algorithm will start to trade after one-year initialization.
+
+
+
+ def CalculateAccruals(self, current, previous):
+ accruals = []
+ for stock_data in current:
+ #compares this and last year's fine fundamental objects
+ try:
+ prev_data = None
+ for x in previous:
+ if x.Symbol == stock_data.Symbol:
+ prev_data = x
+ break
+
+ #calculates the balance sheet accruals and adds the property to the fine fundamental object
+ delta_assets = float(stock_data.FinancialStatements.BalanceSheet.CurrentAssets.Value)-float(prev_data.FinancialStatements.BalanceSheet.CurrentAssets.Value)
+ delta_cash = float(stock_data.FinancialStatements.BalanceSheet.CashAndCashEquivalents.Value)-float(prev_data.FinancialStatements.BalanceSheet.CashAndCashEquivalents.Value)
+ delta_liabilities = float(stock_data.FinancialStatements.BalanceSheet.CurrentLiabilities.Value)-float(prev_data.FinancialStatements.BalanceSheet.CurrentLiabilities.Value)
+ delta_debt = float(stock_data.FinancialStatements.BalanceSheet.CurrentDebt.Value)-float(prev_data.FinancialStatements.BalanceSheet.CurrentDebt.Value)
+ delta_tax = float(stock_data.FinancialStatements.BalanceSheet.IncomeTaxPayable.Value)-float(prev_data.FinancialStatements.BalanceSheet.IncomeTaxPayable.Value)
+ dep = float(stock_data.FinancialStatements.IncomeStatement.DepreciationAndAmortization.Value)
+ avg_total = (float(stock_data.FinancialStatements.BalanceSheet.TotalAssets.Value)+float(prev_data.FinancialStatements.BalanceSheet.TotalAssets.Value))/2
+ #accounts for the size difference
+ stock_data.Accrual = ((delta_assets-delta_cash)-(delta_liabilities-delta_debt-delta_tax)-dep)/avg_total
+ accruals.append(stock_data)
+ except:
+ #value in current universe does not exist in the previous universe
+ pass
+ return accruals
+
+
+
+ The second metric is cash flow to assets ratio. It is calculated by dividing cash flows from operations by the average total assets. Firms with high cash flow to total assets are of high earnings quality.
+ The other two metrics are Return on Equity(ROE) and Debt to Assets(DA) which are available properties of fine fundamental objects. The Higher the ROE ratio, the better the earnings quality.
+ Low debt to assets means low leverage. It leads to more stable earnings and less dependence on the current financing conditions in the economy. Therefore, low debt to assets ratios is a signal of high earnings quality.
+ Before calculating those variables, we should make sure their values are all positive.
+
+
+
+def FineSelectionFunction(self, fine):
+ if self.yearly_rebalance:
+ #filters out the non-financial companies that don't contain the necessary data
+ fine = [x for x in fine if (x.CompanyReference.IndustryTemplateCode != "B")
+ and (x.FinancialStatements.BalanceSheet.CurrentAssets.Value != 0)
+ and (x.FinancialStatements.BalanceSheet.CashAndCashEquivalents.Value != 0)
+ and (x.FinancialStatements.BalanceSheet.CurrentLiabilities.Value != 0)
+ and (x.FinancialStatements.BalanceSheet.CurrentDebt.Value != 0)
+ and (x.FinancialStatements.BalanceSheet.IncomeTaxPayable.Value != 0)
+ and (x.FinancialStatements.IncomeStatement.DepreciationAndAmortization.Value != 0)]
+
+ if not self.previous_fine:
+ # will wait one year in order to have the historical fundamental data
+ self.previous_fine = fine
+ self.yearly_rebalance = False
+ return []
+ else:
+ # calculate the accrual for each stock
+ fine = self.CalculateAccruals(fine, self.previous_fine)
+ filtered_fine = [x for x in fine if (x.FinancialStatements.CashFlowStatement.OperatingCashFlow.Value != 0)
+ and (x.EarningReports.BasicEPS.Value != 0)
+ and (x.EarningReports.BasicAverageShares.Value != 0)
+ and (x.OperationRatios.DebttoAssets.Value != 0)
+ and (x.OperationRatios.ROE.Value != 0)]
+ for i in filtered_fine:
+ # cash flow to assets
+ i.CFA = i.FinancialStatements.CashFlowStatement.OperatingCashFlow.Value/(i.EarningReports.BasicEPS.Value * i.EarningReports.BasicAverageShares.Value)
+ # debt to assets
+ i.DA = i.OperationRatios.DebttoAssets.Value
+ # return on equity
+ i.ROE = i.OperationRatios.ROE.Value
+
+
+
+
The Scoring System
+
+ The investment universe consists of all non-financial stocks from NYSE, Amex and Nasdaq. Next, we will build a composite scoring system to rank the stocks in the universe.
+ The first step is sorting stocks by four factors respectively. “good” quality has a high score, so ideally a stock has low accruals, low debt to assets, high ROE, and high cash flow to assets will be allocated high score.
+ Therefore, we sort the accruals and debt to assets ratio in descending orders and sort the ROE and cash flow to assets ratios in ascending order.
+ Then the score of each stock is the sum of rank in four factors.
+
+
+
+ # sort stocks by four factors respectively
+ sortedByAccrual = sorted(filtered_fine, key=lambda x: x.Accrual, reverse=True) # high score with low accrual
+ sortedByCFA = sorted(filtered_fine, key=lambda x: x.CFA) # high score with high CFA
+ sortedByDA = sorted(filtered_fine, key=lambda x: x.DA, reverse=True) # high score with low leverage
+ sortedByROE = sorted(filtered_fine, key=lambda x: x.ROE) # high score with high ROE
+ # create dict to save the score for each stock
+ score_dict = {}
+ # assign a score to each stock according to their rank with different factors
+ for i,obj in enumerate(sortedByAccrual):
+ scoreAccrual = i
+ scoreCFA = sortedByCFA.index(obj)
+ scoreDA = sortedByDA.index(obj)
+ scoreROE = sortedByROE.index(obj)
+ score = scoreAccrual + scoreCFA + scoreDA + scoreROE
+ score_dict[obj.Symbol] = score
+
+ sortedByScore = sorted(score_dict, key = lambda x: score_dict[x], reverse = True)
+ # long stocks with the top score (> 30%) and short stocks with the bottom score (< 70%)
+ self.long = sortedByScore[:int(0.3*len(sortedByScore))]
+ self.short = sortedByScore[-int(0.3*len(sortedByScore)):]
+
+
+
Trade and Rebalance
+
+ Based on the composite factor score, the algorithm goes long the top 30% of high score stocks and short the bottom 30% of low score stocks.
+ Final factor portfolio is formed at the end of each June and is rebalanced yearly.
+
+
+
+def OnData(self, data):
+ if not self.yearly_rebalance: return
+ if self.long and self.short:
+ long_stocks = [x.Key for x in self.Portfolio if x.Value.IsLong]
+ short_stocks = [x.Key for x in self.Portfolio if x.Value.IsShort]
+ # liquidate the stocks not in the filtered long/short list
+ for long in long_stocks:
+ if long not in self.long:
+ self.Liquidate(long)
+
+ for short in short_stocks:
+ if short not in self.short:
+ self.Liquidate(short)
+
+ long_weight = 0.8/len(self.long)
+ for i in self.long:
+ self.SetHoldings(i, long_weight)
+ short_weight = 0.8/len(self.short)
+ for i in self.short:
+ self.SetHoldings(i, -short_weight)
+
diff --git a/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/01 Introduction.html b/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/01 Introduction.html
new file mode 100644
index 0000000..1d69fc6
--- /dev/null
+++ b/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/01 Introduction.html
@@ -0,0 +1,4 @@
+
+ Mean reversion in stock price is the assumption that the price will tend to move back to the average price over time.
+ Mean reversion trading often refers to counter-trend or reversal trading. This algorithm will explore the mean reversion effect in country equity indexes.
+
diff --git a/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/02 Method.html b/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/02 Method.html
new file mode 100644
index 0000000..b5578d7
--- /dev/null
+++ b/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/02 Method.html
@@ -0,0 +1,8 @@
+
+ The investment universe consists of 19 ETFs which invest in individual country equity indexes.
+ The strategy is going to long on the bottom four countries with the worst 36-month return and short on the top 4 countries with the best 36-month return. The helper indicator method self.ROC(symbol, period, resolution)
+ is used to calculate 36-month return where the resolution is daily and the period is 36*21.
+
+
+ The portfolio is reweighted every three years. We schedule the event to fire every month. self.months is the variable to save the number of months, and the algorithm jumps the rebalance execution if the amount of passed months does not equate to 36.
+
diff --git a/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/03 Algorithm.html b/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/03 Algorithm.html
new file mode 100644
index 0000000..2b216a7
--- /dev/null
+++ b/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/04 Source.html b/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/04 Source.html
new file mode 100644
index 0000000..c4c7a89
--- /dev/null
+++ b/04 Strategy Library/23 Mean Reversion Effect in Country Equity Indexes/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/24 Liquidity Effect in Stocks/01 Introduction.html b/04 Strategy Library/24 Liquidity Effect in Stocks/01 Introduction.html
new file mode 100644
index 0000000..abeb595
--- /dev/null
+++ b/04 Strategy Library/24 Liquidity Effect in Stocks/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ Liquidity has a powerful impact on price and the valuation of equities. Stocks with little liquidity are used to earning higher returns than stocks with high liquidity. In this algorithm, we present the effect of liquidity on returns for the lowest capitalization quartile from the largest 1500 stocks.
+
diff --git a/04 Strategy Library/24 Liquidity Effect in Stocks/02 Method.html b/04 Strategy Library/24 Liquidity Effect in Stocks/02 Method.html
new file mode 100644
index 0000000..6fd2878
--- /dev/null
+++ b/04 Strategy Library/24 Liquidity Effect in Stocks/02 Method.html
@@ -0,0 +1,15 @@
+
+ In coarse universe selection, we filter stocks whose price is higher than $5. ADRs, ETFs and closed-end funds are all excluded with the property of coarse fundamental object HasFundamentalData.
+
+
+ In fine universe selection, in the first step, we exclude stocks with the market cap less than ten million.
+ To evaluate the liquidity of stocks, we choose the annual turnover which is the number of shares traded divided by the stock’s outstanding shares.
+ The main advantage of turnover against volume is its market capitalization-neutrality, as either small-cap or large-cap stocks can have low or high turnover rates.
+ Although turnover is capitalization neutral, the liquidity effect is the strongest among small-cap stocks. Therefore, stocks are then divided into quartiles based on their market capitalization. Stocks from the lowest market-cap quartile are again divided into 5% and 95% quantiles based on their turnover. To calculate the turnover,
+ we request the historical daily volume for the last one year and compute the mean volume. The turnover is the average annual volume divided by BasicAverageShares in EarningReports.
+ Stocks in the 5% quantile and in the top 95% percentile are saved in self.long and self.short lists respectively.
+
+
+ In OnData(), the algorithm goes long on stocks in the lowest turnover list and short on stocks in the highest turnover list. Stocks not in those two lists are liquidated.
+ The portfolio is rebalanced once a year and stocks are weighted equally.
+
diff --git a/04 Strategy Library/24 Liquidity Effect in Stocks/03 Algorithm.html b/04 Strategy Library/24 Liquidity Effect in Stocks/03 Algorithm.html
new file mode 100644
index 0000000..15edb83
--- /dev/null
+++ b/04 Strategy Library/24 Liquidity Effect in Stocks/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/24 Liquidity Effect in Stocks/04 Source.html b/04 Strategy Library/24 Liquidity Effect in Stocks/04 Source.html
new file mode 100644
index 0000000..e09165f
--- /dev/null
+++ b/04 Strategy Library/24 Liquidity Effect in Stocks/04 Source.html
@@ -0,0 +1,5 @@
+
+ Long volatility means that the value of your portfolio increases when the volatility goes up.
+ Short volatility means that you make money when the volatility goes down. The simplest example of volatility selling involves the sale of put and call contracts.
+ Traders often long volatility by holding the long position of put or call options for hedging purpose.
+ In contrast, the short volatility strategy expects to earn the systematic risk premium by selling options.
+ This algorithm will explore the risk premium effect in volatility selling.
+
+ This short volatility algorithm first prescreens the option contracts by the expiry and the strike.
+ To include the weekly contract, we use the universe function
+
+ The algorithm selects contracts with one month until maturity so we choose a small range for expiration.
+
+
+ In OnData(), we divide the option chain into put and call options. Then we create two lists
+ expiries and strikes to save all available expiration dates and stike prices to facilitate
+ sorting and filtering.
+
+
+ The algorithm needs three option contracts with one month to the maturity: one ATM call, one ATM put to contruct the ATM straddle,
+ one 15% OTM put. As it's difficult to find the contract with the specified days to maturity and strikes,
+ we use min() to find the most closest contract.
+
+
+
expiries = [i.Expiry for i in puts]
+# determine expiration date nearly 30 days
+expiry = min(expiries, key=lambda x: abs((x.date()-self.Time.date()).days-30))
+strikes = [i.Strike for i in puts]
+# determine at-the-money strike
+strike = min(strikes, key=lambda x: abs(x-underlying_price))
+# determine 15% out-of-the-money strike
+otm_strike = min(strikes, key = lambda x:abs(x-Decimal(0.85)*underlying_price))
+
+
+
+ From the above expiration date and strike price, we pick three option contracts
+
+
+
self.atm_call = [i for i in calls if i.Expiry == expiry and i.Strike == strike]
+self.atm_put = [i for i in puts if i.Expiry == expiry and i.Strike == strike]
+self.otm_put = [i for i in puts if i.Expiry == expiry and i.Strike == otm_strike]
+
+
+
+ In trading, we sell the ATM straddle by selling one ATM call and one ATM put. Then we buy an OTM put option as insurance against a market crash.
+ Then we wait until the expiration and sell the underlying positions after option exercise and assignment. The portfolio is rebalanced once a month.
+
+
+
diff --git a/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/01 Introduction.html b/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/01 Introduction.html
new file mode 100644
index 0000000..17958c4
--- /dev/null
+++ b/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/01 Introduction.html
@@ -0,0 +1,19 @@
+
+ This tutorial implements a seasonality strategy that trades based on historical same-calendar-month returns. The strategy is
+ derived from the paper Common Factors in Return Seasonalities.
+
+
+ A great deal of research on seasonality effects in algorithmic trading exists. Seasonality patterns are well documented in stock returns across numerous
+ countries and in commodity and country portfolios. The phenomenon’s occurrence is not isolated to specific stocks or monthly time intervals, for example, seasonality is observed at the daily frequency as well. Our implementation reflects the existing research.
+
+
+ In our algorithm, we will first use a coarse selection filter function to narrow down our universe to the top 100 liquid securities with a price greater than $5.
+
+
+ Next, for each security in the universe, we will calculate the monthly return for the same-calendar month of the previous year. For example, if we implement this strategy on a backtest for the period of August 2019, we would base our long and short positions on monthly returns from August 2018. We will long the securities with top monthly returns and short those with the bottom monthly returns.
+
+
+ At the end of each month we will rebalance and repeat the strategy. The following section offers further explanation of how to implement each step of the strategy.
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/02 Method.html b/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/02 Method.html
new file mode 100644
index 0000000..5b5da95
--- /dev/null
+++ b/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/02 Method.html
@@ -0,0 +1,70 @@
+
Step 1: Select our universe
+
+ We first select the top 100 liquid securities and ETFs with prices greater than $5 based on Dollar Volume for our universe. Research from "Common Factors" suggests that the U.S. equity, commodity, and index markets are all affected by seasonality patterns. Therefore, we can include any assets in our universe. Note that while this strategy does not require fundamental data for implementation, other strategies in the library do. In those cases we would need to remove ETFs from the universe because we don’t have fundamental data for ETFs.
+
+
+
+
+ # Sort the securities with prices > 5 in DollarVolume decendingly
+ selected = sorted([x for x in coarse if x.Price > 5],
+ key=lambda x: x.DollarVolume, reverse=True)
+
+ # Get securities after coarse selection
+ symbols = [x.Symbol for x in selected[:self.num_coarse]]
+
+
+
+
Step 2: Calculate the same-calendar month returns of the previous year
+
+ "Common Factors" indicates that taking long and short positions based on historical same-calendar month returns earns an average monthly return of 1.88%. Our implementation also selects securities to long and short based on their same-calendar month returns. For each security in the universe, we calculate the monthly return for the same-calendar month of the previous year and choose the symbols as follows:
+
+
+
+
+ # Get historical close data for coarse-selected symbols of the same calendar month
+ start = self.Time.replace(day = 1, year = self.Time.year-1)
+ end = Expiry.EndOfMonth(start) - timedelta(1)
+ history = self.History(symbols, start, end, Resolution.Daily).close.unstack(level=0)
+
+ # Get the same calendar month returns for the symbols
+ MonthlyReturn = {ticker: prices.iloc[-1]/prices.iloc[0] for ticker, prices in history.iteritems()}
+
+ # Sorted the values of monthly return
+ sortedReturn = sorted(MonthlyReturn.items(), key=lambda x:x[1], reverse=True)
+
+ # Get the symbols to long / short
+ self.longSymbols = [x[0] for x in sortedReturn[:self.num_long]]
+ self.shortSymbols = [x[0] for x in sortedReturn[-self.num_short:]]
+
+ # Note that self.longSymbols/self.shortSymbols contains strings instead of symbols
+ return [x for x in symbols if str(x) in self.longSymbols + self.shortSymbols]
+
+
+
+
Step 3: Rebalance monthly
+
+ At the end of each month, we rebalance our portfolio, liquidate the securities that are not part of the new month’s universe, and repeat step 1 and 2. Keep in mind we use equal weights for the long and short positions of securities in our portfolio.
+
+
+
+
+ '''
+ Rebalance every month based on same-calendar month returns effect
+ '''
+ # Before next rebalance, do nothing
+ if self.Time < self.nextRebalance:
+ return
+
+ count = len(self.longSymbols + self.shortSymbols)
+ # Open long positions
+ for symbol in self.longSymbols:
+ self.SetHoldings(symbol, 1/count)
+
+ # Open short positions
+ for symbol in self.shortSymbols:
+ self.SetHoldings(symbol, -1/count)
+
+ # Rebalance at the end of every month
+ self.nextRebalance = Expiry.EndOfMonth(self.Time) - timedelta(1)
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/03 Results.html b/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/03 Results.html
new file mode 100644
index 0000000..e4e319f
--- /dev/null
+++ b/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/03 Results.html
@@ -0,0 +1,9 @@
+
+ In backtesting our algorithm achieves a Sharpe ratio of 0.332 relative to S&P 500 (SPY) Sharpe ratio of 0.893 for the past 10 years.
+ The performance indicates using the idea of same-calendar month returns makes sense. Interested users can build upon this implementation by trying the following extensions:
+
+
+
Using the same-calendar months of multiple years (e.g. the last 5 years), instead of using the previous year as we did in this tutorial, to get more stable monthly returns.
+
Using discounting to capture time effects in the returns.
+
Creating the initial universe using different criteria such as quarterly, rather than monthly, returns.
+
\ No newline at end of file
diff --git a/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/04 Algorithm.html b/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/04 Algorithm.html
new file mode 100644
index 0000000..03c24b0
--- /dev/null
+++ b/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/05 Reference.html b/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/05 Reference.html
new file mode 100644
index 0000000..a859e6e
--- /dev/null
+++ b/04 Strategy Library/269 Seasonality Effect based on Same-Calendar Month Returns/05 Reference.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/27 Momentum Effect in Commodities Futures/01 Introduction.html b/04 Strategy Library/27 Momentum Effect in Commodities Futures/01 Introduction.html
new file mode 100644
index 0000000..21044a4
--- /dev/null
+++ b/04 Strategy Library/27 Momentum Effect in Commodities Futures/01 Introduction.html
@@ -0,0 +1,4 @@
+
+ Commodity futures are excellent portfolio diversifiers and some of them are an effective hedge against inflation.
+ This algorithm will explore the momentum effect in commodity futures with the momentum return.
+
diff --git a/04 Strategy Library/27 Momentum Effect in Commodities Futures/02 Method.html b/04 Strategy Library/27 Momentum Effect in Commodities Futures/02 Method.html
new file mode 100644
index 0000000..9870587
--- /dev/null
+++ b/04 Strategy Library/27 Momentum Effect in Commodities Futures/02 Method.html
@@ -0,0 +1,42 @@
+
+ As the strategy needs the continuous futures contract, we import the custom data from Quandl.
+ We create a universe of tradable commodity futures from all available commodity futures traded on CME and ICE.
+ They are all liquid and active continuous contracts #1. The data from Quandl are non-adjusted price based on spot-month continuous contract calculations.
+ The data resolution is daily.
+
+
+ The first step is importing the data.
+
+
+
from QuantConnect.Python import PythonQuandl
+for symbol in self.symbols:
+ self.AddData(QuandlFutures, symbol, Resolution.Daily)
+
+class QuandlFutures(PythonQuandl):
+ def __init__(self):
+ self.ValueColumnName = "Settle"
+
+
+
+ Here we use the indicator RateOfChange(period) to simulate the momentum return. Here the period is 12 months.
+ As we are using the custom data, the indicator initialization should use the history request to update the value manually.
+ All indicators are saved in the dictionary self.roc.
+
+
+
self.roc = {}
+for symbol in self.symbols:
+ self.AddData(QuandlFutures, symbol, Resolution.Daily)
+ self.roc[symbol] = RateOfChange(period)
+ hist = self.History([symbol], 400, Resolution.Daily).loc[symbol]
+ for i in hist.itertuples():
+ self.roc[symbol].Update(i.Index, i.value)
+
+
+
+ In OnData(self, data), indicators for all futures contracts are updated every day with the settlement price.
+
+
+ We rank the contracts by the last 12-month return and divide them into quintiles.
+ In the trading part, the algorithm goes long on the quintile with the highest momentum return and goes short on the quintile with the lowest momentum return.
+ The portfolio is rebalanced each month.
+
diff --git a/04 Strategy Library/27 Momentum Effect in Commodities Futures/03 Algorithm.html b/04 Strategy Library/27 Momentum Effect in Commodities Futures/03 Algorithm.html
new file mode 100644
index 0000000..ad5e9f8
--- /dev/null
+++ b/04 Strategy Library/27 Momentum Effect in Commodities Futures/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/27 Momentum Effect in Commodities Futures/04 Source.html b/04 Strategy Library/27 Momentum Effect in Commodities Futures/04 Source.html
new file mode 100644
index 0000000..7b964a7
--- /dev/null
+++ b/04 Strategy Library/27 Momentum Effect in Commodities Futures/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/270 Risk Premia in Forex Markets/01 Introduction.html b/04 Strategy Library/270 Risk Premia in Forex Markets/01 Introduction.html
new file mode 100644
index 0000000..2c85d7e
--- /dev/null
+++ b/04 Strategy Library/270 Risk Premia in Forex Markets/01 Introduction.html
@@ -0,0 +1,7 @@
+
+ This tutorial implements a risk premia strategy that enters long-short positions in the forex market based on signals from a skewness indicator. The strategy is derived from the paper “Risk Premia: Asymmetric Tail Risks and Excess Returns” by Lemperiere, Deremble, Nguyen, Seager, Potters, and Bouchaud.
+
+
+
+ One of the pillars in modern finance theory is the concept of risk premium, which states the riskier an investment is today the more profitable it should be in the long run. Risk premia strategies aim to profit from risk premiums. Lemperiere et al. describe a positive linear relationship between the Sharpe ratio of risk premia strategies and their negative skewness. It provides extensive evidence that risk premium is indeed strongly correlated with the skewness of a strategy, not only in the equity world but also in currencies, options, credit, etc.
+
diff --git a/04 Strategy Library/270 Risk Premia in Forex Markets/02 Method.html b/04 Strategy Library/270 Risk Premia in Forex Markets/02 Method.html
new file mode 100644
index 0000000..fd1d64a
--- /dev/null
+++ b/04 Strategy Library/270 Risk Premia in Forex Markets/02 Method.html
@@ -0,0 +1,73 @@
+
Step 1: Select our forex universe
+
+ In this algorithm, we use a fixed forex universe which contains four symbols: "EURUSD", "AUDUSD", "USDCAD" and "USDJPY". By using self.AddForex(), we add the requested forex data into the data feed.
+
+
+
+
+ # Add forex data of the following symbols
+ for pair in ['EURUSD', 'AUDUSD', 'USDCAD', 'USDJPY']:
+ self.AddForex(pair, Resolution.Hour, Market.FXCM)
+
+
+
+
Step 2: Calculate the skewness indicator
+
+ In statistics, skewness is a measure of the asymmetry of the probability distribution of a real-valued random variable about its mean. Lemperiere et al. suggest there is a positive relationship between risk premia strategies and their negative skewness. We will use this relationship in our trading logic. Our implementation goes long for a forex pair when the skewness indicator is lower than a minimum threshold (-0.6) and short the pair when the indicator exceeds a maximum threshold (0.6). For each forex pair in the universe, we will calculate the skewness indicator with historical close prices and select the symbols as follows:
+
+
+
+
+ ### In OnData()
+ # Get historical close data for the symbols
+ history = self.History(self.Securities.Keys, self.lookback, Resolution.Daily)
+ history = history.drop_duplicates().close.unstack(level=0)
+
+ # Get the skewness of the historical data
+ skewness = self.GetSkewness(history)
+
+ longSymbols = [k for k,v in skewness.items() if v < self.longSkewLevel]
+ shortSymbols = [k for k,v in skewness.items() if v > self.shortSkewLevel]
+
+ def GetSkewness(self, values):
+ '''
+ Get the skewness for all forex symbols based on its historical data
+ Ref: https://www.itl.nist.gov/div898/handbook/eda/section3/eda35b.htm
+ '''
+ # Get the numerator of the skewness
+ numer = ((values - values.mean()) ** 3).sum()
+
+ # Get the denominator of the skewness
+ denom = self.lookback * values.std() ** 3
+
+ # Return the skewness
+ return (numer/denom).to_dict()
+
+
+
+
Step 3: Rebalance weekly
+
+ We rebalance every week, liquidate the forex pairs not on the trading list, then repeat steps 1-2. We use equal weights for the long and short positions of securities in our portfolio.
+
+
+
+
+ # Liquidate the holdings for pairs that will not trade
+ for holding in self.Portfolio.Values:
+ symbol = holding.Symbol
+ if holding.Invested and symbol.Value not in longSymbols + shortSymbols:
+ self.Liquidate(symbol, 'Not selected pair')
+
+ # Open positions for the symbols with equal weights
+ count = len(longSymbols) + len(shortSymbols)
+
+ for pair in longSymbols:
+ self.SetHoldings(pair, 1/count)
+
+ for pair in shortSymbols:
+ self.SetHoldings(pair, -1/count)
+
+ # Set next rebalance time
+ self.nextRebalance += timedelta(self.rebalanceDays)
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/270 Risk Premia in Forex Markets/03 Results.html b/04 Strategy Library/270 Risk Premia in Forex Markets/03 Results.html
new file mode 100644
index 0000000..3e38c14
--- /dev/null
+++ b/04 Strategy Library/270 Risk Premia in Forex Markets/03 Results.html
@@ -0,0 +1,9 @@
+
+ In this case our backtest results in a low annual return of approximately -0.7% over a decade. The poor performance may be due to several reasons:
+
+
The fixed forex universe chosen is not large enough to properly diversify market risk
+
The thresholds for entering long and short positions (0.6, -0.6) may need adjustment
+
The length of historical data might be not large enough for this weekly-rebalanced strategy.
+
+ We encourage the community to further develop this strategy by testing out different symbols, thresholds, and historical data lengths.
+
\ No newline at end of file
diff --git a/04 Strategy Library/270 Risk Premia in Forex Markets/04 Algorithm.html b/04 Strategy Library/270 Risk Premia in Forex Markets/04 Algorithm.html
new file mode 100644
index 0000000..f3764f8
--- /dev/null
+++ b/04 Strategy Library/270 Risk Premia in Forex Markets/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/270 Risk Premia in Forex Markets/05 Reference.html b/04 Strategy Library/270 Risk Premia in Forex Markets/05 Reference.html
new file mode 100644
index 0000000..dfffb15
--- /dev/null
+++ b/04 Strategy Library/270 Risk Premia in Forex Markets/05 Reference.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/271 Price and Earning Momentum/01 Introduction.html b/04 Strategy Library/271 Price and Earning Momentum/01 Introduction.html
new file mode 100644
index 0000000..aa3ce63
--- /dev/null
+++ b/04 Strategy Library/271 Price and Earning Momentum/01 Introduction.html
@@ -0,0 +1,11 @@
+
+ In this tutorial, we will develop a strategy based on the price and earnings momentum effect of stocks. This strategy is derived from the paper "Momentum" by N.Jegadeesh and S.Titman.
+
+
+
+ N.Jegadeesh et al. describe price/return momentum as a tendency for stocks that perform well over a three to twelve month period to continue to perform well over a subsequent three to twelve month period. Similarly, stocks that perform poorly over a three to twelve month period have a tendency to continue to perform poorly. They describe earnings momentum as the tendency for stocks with high earnings per share (EPS) to continue to outperform stocks with low EPS.
+
+
+
+ Below, we will implement a quarterly-rebalanced stock strategy based on the price and earnings momentum.
+
diff --git a/04 Strategy Library/271 Price and Earning Momentum/02 Method.html b/04 Strategy Library/271 Price and Earning Momentum/02 Method.html
new file mode 100644
index 0000000..755688e
--- /dev/null
+++ b/04 Strategy Library/271 Price and Earning Momentum/02 Method.html
@@ -0,0 +1,166 @@
+
Step 1: Select the coarse universe
+
+ We will use both a coarse selection filter and in a later step, a fine universe filter, to narrow down our universe of assets. Our coarse universe filter creates a set of stocks based on volume, price, and whether fundamental data on the stock exists. In this step we filter for the top 100 liquid equities with prices greater than $5. We also exclude the equities missing fundamental data because EPS is needed in the fine selection step.
+
+
+
+
+def CoarseSelection(self, coarse):
+ '''
+ Pick the top 100 liquid equities as the coarse-selected universe
+ '''
+ # Before next rebalance time, just remain the current universe
+ if self.Time < self.nextRebalance:
+ return Universe.Unchanged
+
+ # Sort the equities (prices > 5) by Dollar Volume descendingly
+ selectedByDollarVolume = sorted([x for x in coarse if x.Price > 5 and x.HasFundamentalData],
+ key = lambda x: x.DollarVolume, reverse = True)
+
+ # Pick the top 100 liquid equities as the coarse-selected universe
+ return [x.Symbol for x in selectedByDollarVolume[:self.numOfCoarse]]
+
+
+
+
Step 2: Calculate quarterly return and earnings growth
+
+ N.Jegadeesh et al. state price momentum and earnings momentum can be used as two indicators for trading. We will calculate for price momentum with the "GetQuarterlyReturn" method and for earnings momentum with the "GetEarningGrowth" method.
+
+
+ "GetQuarterlyReturn" calculates price momentum for each symbol in our coarse universe and ranks each stock based on its quarterly return. First we request last quarter’s close price for all stocks. Then we calculate quarterly return by taking the delta of the first day’s close price and the last day’s close price. Finally, we store the symbols and their corresponding rankings by quarterly return in a dictionary in preparation for fine selection.
+
+
+
+
+ def GetQuarterlyReturn(self, history):
+ '''
+ Get the rank of securities based on their quarterly return from historical close prices
+ Return: dictionary
+ '''
+ # Get quarterly returns for all symbols
+ # (The first row divided by the last row)
+ returns = history.iloc[0] / history.iloc[-1]
+
+ # Transform them to dictionary structure
+ returns = returns.to_dict()
+
+ # Get the rank of the returns (key: symbol; value: rank)
+ # (The symbol with the 1st quarterly return ranks the 1st, etc.)
+ ranked = sorted(returns, key = returns.get, reverse = True)
+ return {symbol: rank for rank, symbol in enumerate(ranked, 1)}
+
+
+
+ "GetEarningGrowth" calculates earnings momentum for each symbol in our coarse universe and ranks each stock based on its earnings growth. First we use a RollingWindow to store and update the BasicEPS to reflect quarterly earnings reports. A RollingWindow holds a set of the most recent entries of data. As we move from time t=0 forward, our rolling window will shuffle data further along to a different index until it leaves the window completely. The object in the window with index[0] refers to the most recent item. The length-1 in the window is the oldest object.
+
+
+
+ Our rolling window has a length of 2 so index[0] is the current EPS and index[1] is last quarter's EPS. We calculate earnings growth for each stock by taking the delta of this quarter’s EPS and last quarter’s EPS divided by last quarter’s EPS. Finally we rank each asset based on earnings growth.
+
+
+
+ def GetEarningGrowth(self, fine):
+ '''
+ Get the rank of securities based on their EPS growth
+ Return: dictionary
+ '''
+
+ # Earning Growth by symbol
+ egBySymbol = {}
+ for stock in fine:
+
+ # Select the securities with EPS (> 0)
+ if stock.EarningReports.BasicEPS.ThreeMonths == 0:
+ continue
+
+ # Add the symbol in the dict if not exist
+ if not stock.Symbol in self.epsBySymbol:
+ self.epsBySymbol[stock.Symbol] = RollingWindow[float](2)
+
+ # Update the rolling window for each stock
+ self.epsBySymbol[stock.Symbol].Add(stock.EarningReports.BasicEPS.ThreeMonths)
+
+ # If the rolling window is ready
+ if self.epsBySymbol[stock.Symbol].IsReady:
+ rw = self.epsBySymbol[stock.Symbol]
+ # Caculate the Earning Growth
+ egBySymbol[stock.Symbol] = (rw[0] - rw[1]) / rw[1]
+
+ # Get the rank of the Earning Growth
+ ranked = sorted(egBySymbol, key = egBySymbol.get, reverse = True)
+ return {symbol: rank for rank, symbol in enumerate(ranked, 1)}
+
+
+
+
Step 3: Select the fine universe
+
+ We use a fine selection filter in addition to a coarse selection filter to refine our asset selection based on corporate fundamental data. We can use both quarterly return and earnings growth from our two indicators to generate an average rank for each stock. Then we can go long on the top 10 and short the bottom 10.
+
+
+
+
+ def FineSelection(self, fine):
+ '''
+ Select securities based on their quarterly return and their earnings growth
+ '''
+ symbols = [x.Symbol for x in fine]
+
+ # Get the quarterly returns for each symbol
+ history = self.History(symbols, self.rebalanceDays, Resolution.Daily)
+ history = history.drop_duplicates().close.unstack(level = 0)
+ rankByQuarterReturn = self.GetQuarterlyReturn(history)
+
+ # Get the earning growth for each symbol
+ rankByEarningGrowth = self.GetEarningGrowth(fine)
+
+ # Get the sum of rank for each symbol and pick the top ones to long and the bottom ones to short
+ rankSumBySymbol = {key: rankByQuarterReturn.get(key, 0) + rankByEarningGrowth.get(key, 0)
+ for key in set(rankByQuarterReturn) | set(rankByEarningGrowth)}
+
+ # Get 10 symbols to long and short respectively
+ sortedDict = sorted(rankSumBySymbol.items(), key = lambda x: x[1], reverse = True)
+ self.longSymbols = [x[0] for x in sortedDict[:10]]
+ self.shortSymbols = [x[0] for x in sortedDict[-10:]]
+
+ return [x for x in symbols if str(x) in self.longSymbols + self.shortSymbols]
+
+
+
+
Step 4: Rebalance quarterly
+
+ We choose to rebalance every quarter and use equal weights for the long and short positions of securities in our portfolio.
+
+
+
+
+ def OnData(self, data):
+ '''
+ Rebalance quarterly
+ '''
+ # Do nothing until next rebalance
+ if self.Time < self.nextRebalance:
+ return
+
+ # Liquidate the holdings if necessary
+ for holding in self.Portfolio.Values:
+ symbol = holding.Symbol
+ if holding.Invested and symbol.Value not in self.longSymbols + self.shortSymbols:
+ self.Liquidate(symbol, "Not Selected")
+
+ # Open positions for the symbols with equal weights
+ count = len(self.longSymbols + self.shortSymbols)
+ if count == 0:
+ return
+
+ # Enter long positions
+ for symbol in self.longSymbols:
+ self.SetHoldings(symbol, 1 / count)
+
+ # Enter short positions
+ for symbol in self.shortSymbols:
+ self.SetHoldings(symbol, -1 / count)
+
+ # Set next rebalance time
+ self.nextRebalance += timedelta(self.rebalanceDays)
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/271 Price and Earning Momentum/03 Results.html b/04 Strategy Library/271 Price and Earning Momentum/03 Results.html
new file mode 100644
index 0000000..e0cab48
--- /dev/null
+++ b/04 Strategy Library/271 Price and Earning Momentum/03 Results.html
@@ -0,0 +1,9 @@
+
+ Our backtest results in a Sharpe ratio of 0.59 while the SP500 Sharpe ratio is 0.8 during the same decade. This performance may be due to several factors:
+
+
The number of stocks in our portfolio, 100, could be too low.
+
Equal weighting for all stocks may not fully capture the strength of higher ranking stocks.
+
Rebalancing quarterly may be too frequent for a momentum strategy in equities.
+
+ This tutorial shows us how to take advantage of the techniques of requesting historical data and using a RollingWindow. We hope the community can further develop strategies based on these techniques.
+
\ No newline at end of file
diff --git a/04 Strategy Library/271 Price and Earning Momentum/04 Algorithm.html b/04 Strategy Library/271 Price and Earning Momentum/04 Algorithm.html
new file mode 100644
index 0000000..65639b2
--- /dev/null
+++ b/04 Strategy Library/271 Price and Earning Momentum/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/271 Price and Earning Momentum/05 Reference.html b/04 Strategy Library/271 Price and Earning Momentum/05 Reference.html
new file mode 100644
index 0000000..8ce9247
--- /dev/null
+++ b/04 Strategy Library/271 Price and Earning Momentum/05 Reference.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/01 Introduction.html b/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/01 Introduction.html
new file mode 100644
index 0000000..1e56e9b
--- /dev/null
+++ b/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/01 Introduction.html
@@ -0,0 +1,6 @@
+
+ Small caps are typically defined as companies with market caps that are less than $2 billion.
+ The advantage of investing in small cap companies is that they are young companies with significant growth potential.
+ However, the risk of failure is greater with small-cap stocks than with large-cap and mid-cap stocks.
+ In this algorithm, we will explore the performance of the small-capitalization investment.
+
diff --git a/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/02 Method.html b/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/02 Method.html
new file mode 100644
index 0000000..98c8577
--- /dev/null
+++ b/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/02 Method.html
@@ -0,0 +1,21 @@
+
+ The first step is coarse universe selection. We create an investment universe with stocks that have fundmental data and with a price greater than $5.
+
+
+
return [x.Symbol for x in coarse if x.HasFundamentalData and x.Price > 5]
+
+
+
In fine universe selection, we sort the stocks in the universe by the market capitalization and choose 10 stocks with the lowest market cap.
+
+
+
def FineSelectionFunction(self, fine):
+ ''' Selects the stocks by lowest market cap '''
+ sorted_market_cap = sorted([x for x in fine if x.MarketCap > 0],
+ key=lambda x: x.MarketCap)
+
+ return [x.Symbol for x in sorted_market_cap[:self.count]]
+
+
+
+ In OnData(), we buy 10 stocks in the list of lowest market-cap. The portfolio is rebalanced every year.
+
diff --git a/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/03 Algorithm.html b/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/03 Algorithm.html
new file mode 100644
index 0000000..b50f912
--- /dev/null
+++ b/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/04 Source.html b/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/04 Source.html
new file mode 100644
index 0000000..b33e5d2
--- /dev/null
+++ b/04 Strategy Library/28 Small Capitalization Stocks Premium Anomaly/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/29 Term Structure Effect in Commodities/01 Introduction.html b/04 Strategy Library/29 Term Structure Effect in Commodities/01 Introduction.html
new file mode 100644
index 0000000..aa441da
--- /dev/null
+++ b/04 Strategy Library/29 Term Structure Effect in Commodities/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ The term structure of commodities usually refers to the difference between futures prices of different maturities at a given time point. The shape of the futures curve is essential to commodity hedgers and speculators as futures price serves as a forecast of future spot price. The futures price curve contains the information about futures supply and demand conditions. This algorithm will examine the role of term structure signals for the design of profitable trading strategies in commodity futures markets.
+
diff --git a/04 Strategy Library/29 Term Structure Effect in Commodities/02 Method.html b/04 Strategy Library/29 Term Structure Effect in Commodities/02 Method.html
new file mode 100644
index 0000000..616312c
--- /dev/null
+++ b/04 Strategy Library/29 Term Structure Effect in Commodities/02 Method.html
@@ -0,0 +1,61 @@
+
Concepts of Futures
+
+ Before starting the algorithm, we first introduce a few concepts related to commodity futures. Backwardation is defined as conditions when the futures price is below the current spot price and contango as conditions when the futures price is above the current spot price. The futures term structure curve is a representation of the backwardation/contango rate for the different maturities of futures contracts. This price gap between different maturity contracts is quantified as the roll return.
+ The contango/backwardation rates are calculated by taking the price difference between the spot market price and the futures contract price. This difference can be expressed
+ as a percentage over the time to expiration and then annualised to calculate an annual roll return.
+
+ Where \(P_{t,n}\) is the price of the nearest-to-maturity contract at time t. \(P_{t,d}\) is the price of the distant contract at time t. \(N_{t,n}\) is the number of days between time t and the maturity of the nearby contract and \(N_{t,d}\) is the number of days between time t and the maturity of the distant contract.
+
+
Calculation of Roll Return
+
+ To calculate the roll return, first we sort the future chain by expiry and select the first two contracts as the nearest-to-maturity contract and the the distant contract.
+
+
+
for symbol, chain in self.chains.items():
+ contracts = sorted(chain, key = lambda x: x.Expiry)
+ # R = (log(Pn) - log(Pd)) * 365 / (Td - Tn)
+ # R - Roll returns
+ # Pn - Nearest contract price
+ # Pd - Distant contract price
+ # Tn - Nearest contract expire date
+ # Pd - Distant contract expire date
+ near_contract = contracts[0]
+ distant_contract = contracts[-1]
+ price_near = near_contract.LastPrice if near_contract.LastPrice>0 else 0.5*float(near_contract.AskPrice+near_contract.BidPrice)
+ price_distant = distant_contract.LastPrice if distant_contract.LastPrice>0 else 0.5*float(distant_contract.AskPrice+distant_contract.BidPrice)
+ if distant_contract.Expiry == near_contract.Expiry:
+ self.Debug("ERROR: Near and distant contracts have the same expiry!" + str(near_contract))
+ return
+ expire_range = 365 / (distant_contract.Expiry - near_contract.Expiry).days
+ roll_returns[symbol] = (np.log(float(price_near)) - np.log(float(price_distant)))*expire_range
+
+
+
Backwardation and Contango
+
+ In the next step, we will split the futures based on backwardation and contango. If the roll return is greater than 0, the term structure of commodity futures prices
+ is downward-sloping and so that the market is in backwardation. Conversely, a negative roll return signals an upward-sloping price curve and a contangoed market.
+
+
+
positive_roll_returns = { symbol: returns for symbol, returns in roll_returns.items() if returns > 0 }
+negative_roll_returns = { symbol: returns for symbol, returns in roll_returns.items() if returns < 0 }
+backwardation = sorted(positive_roll_returns , key = lambda x: positive_roll_returns[x], reverse = True)[:quintile]
+contango = sorted(negative_roll_returns , key = lambda x: negative_roll_returns[x])[:quintile]
+
+
+
Algorithm Trade
+
+ The algorithm buys 20% of commodities with the highest roll-returns and shorts the 20% of commodities with the lowest roll-returns and holds the long-short positions for one month.
+
diff --git a/04 Strategy Library/29 Term Structure Effect in Commodities/03 Algorithm.html b/04 Strategy Library/29 Term Structure Effect in Commodities/03 Algorithm.html
new file mode 100644
index 0000000..f820ca9
--- /dev/null
+++ b/04 Strategy Library/29 Term Structure Effect in Commodities/03 Algorithm.html
@@ -0,0 +1,17 @@
+
Algorithm
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/04 Strategy Library/29 Term Structure Effect in Commodities/04 References.html b/04 Strategy Library/29 Term Structure Effect in Commodities/04 References.html
new file mode 100644
index 0000000..149276a
--- /dev/null
+++ b/04 Strategy Library/29 Term Structure Effect in Commodities/04 References.html
@@ -0,0 +1,9 @@
+
+
+
+ Fuertes, Ana-Maria and Miffre, Joëlle and Rallis, Georgios, Tactical Allocation in Commodity Futures Markets: Combining Momentum and Term Structure Signals (April 22, 2010). Journal of Banking and Finance 34, 2530-2548. Online Copy
+
+
+ Jez Liberty, Roll Yield and Commodity Yield Curve (July 19th, 2010). Automated Trading System Online Copy
+
+
diff --git a/04 Strategy Library/29 Term Structure Effect in Commodities/05 Source.html b/04 Strategy Library/29 Term Structure Effect in Commodities/05 Source.html
new file mode 100644
index 0000000..f270488
--- /dev/null
+++ b/04 Strategy Library/29 Term Structure Effect in Commodities/05 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/01 Introduction.html b/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/01 Introduction.html
new file mode 100644
index 0000000..8af2089
--- /dev/null
+++ b/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/01 Introduction.html
@@ -0,0 +1,6 @@
+
+ This algorithm will combine the term structure effect and
+ the momentum effect to exploit the trading signals in commodity futures.
+ The momentum strategy goes long commodity futures with the highest one-month momentum and shorts on futures with the lowest one-month momentum. Signals are based on the historical return.
+ While the portfolio in term structure strategy is created with futures contracts in deep contango and backwardation. It goes long commodities with the highest roll-returns and short commodities with the lowest roll-returns and holds the long-short positions for one month.
+
diff --git a/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/02 Method.html b/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/02 Method.html
new file mode 100644
index 0000000..59d56bb
--- /dev/null
+++ b/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/02 Method.html
@@ -0,0 +1,62 @@
+
Roll Return
+
+ The universe is created with 22 commodity futures. For multiple commodities, we save the future chain of each commodity in dictionary self.chains.
+ First, we compute the roll-returns at the start of each month and sort the roll-return list. 1/3 breakpoints are used to split the cross-section of futures contracts into 3 portfolios, labeled Low, Med and High. For the formula of the roll-return, please see Term Structure Effect in Commodities.
+ Contracts fall into Med level are eliminated from the universe. Next we'll calculate the mean return of contracts in High and Low.
+
+ The second filter is the historical mean return. We sort the contracts in the High portfolio into two sub-portfolios (High-Winner and High-Loser) based on the mean return of the commodities over the past one month.
+High-Winner is thus made of the commodities that have both the highest roll-returns at the time of portfolio construction and the best past performance.
+Similarly, we sort the commodities in the Low portfolio into two sub-portfolios (Low-Winner and Low-Loser) based on their mean return over the past one months. Low-Loser contains, therefore, commodities that have both the lowest roll-returns at the time of portfolio construction and the worst past performance.
+
+The combined strategy buys the High-Winner portfolio, shorts the Low-Loser portfolio and holds this position for one month. At the start of the next month, the strategy liquidates the contracts invested and rebalances the portfolio.
+
+
+
+short_weight = 0.5/len(low_losers)
+for short in low_losers:
+ self.SetHoldings(short.Symbol, -short_weight)
+
+long_weight = 0.5/len(high_winners)
+for long in high_winners:
+ self.SetHoldings(long.Symbol, long_weight)
+
+
diff --git a/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/03 Algorithm.html b/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/03 Algorithm.html
new file mode 100644
index 0000000..b781228
--- /dev/null
+++ b/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/04 Source.html b/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/04 Source.html
new file mode 100644
index 0000000..be5436f
--- /dev/null
+++ b/04 Strategy Library/30 Momentum Effect Combined with Term Structure in Commodities/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/31 Book-to-Market Value Anomaly/01 Introduction.html b/04 Strategy Library/31 Book-to-Market Value Anomaly/01 Introduction.html
new file mode 100644
index 0000000..bad6aeb
--- /dev/null
+++ b/04 Strategy Library/31 Book-to-Market Value Anomaly/01 Introduction.html
@@ -0,0 +1,10 @@
+
+ Book-to-market ratio is used to find the value of a company by comparing the book value of a firm to its market value. The definition of the book-to-market ratio is
+ \[Book\ to\ Market \ Ratio=\frac{Common\ Shareholders \ Equity}{Market \ Cap}=\frac{book \ value \ per \ share}{Market \ price \ per \ share}\]
+ Book value represents a company's assets minus its liabilities and sometimes is referred to as shareholders' equity.
+ Price-to-Book Ratio is defined as
+ \[Price \ to \ Book\ Ratio=\frac{Market \ price \ per \ share}{book \ value \ per \ share}\]
+ Therefore, we can see the Book-to-market ratio is the inverse of the P/B ratio.
+ The book-to-market ratio suggests how much investors are paying against each dollar of book value in the balance sheet.
+ The bigger the ratio is, the more fundamentally cheap is the investigated company. This algorithm will create the portfolio with this factor.
+
diff --git a/04 Strategy Library/31 Book-to-Market Value Anomaly/02 Method.html b/04 Strategy Library/31 Book-to-Market Value Anomaly/02 Method.html
new file mode 100644
index 0000000..2af5ef5
--- /dev/null
+++ b/04 Strategy Library/31 Book-to-Market Value Anomaly/02 Method.html
@@ -0,0 +1,27 @@
+
+ To construct the universe, first we eliminate stocks which don't have fundmental data. In FineSelectionFunction,
+ we calculate the market cap with PE ratio, earning per shares and shares outstanding and assign the property MarketCap
+ to each fine fundamental object. The universe is narrowed to top 20% companies with the highest market cap.
+
+
+ According to the algorithm, the portfolio is weighted based on market cap. We calculate the weight in FineSelectionFunction and save
+ them in self.weights.
+
+
+
+fine = [x for x in fine if (x.ValuationRatios.PBRatio > 0)]
+for i in fine:
+ i.MarketCap = float(i.EarningReports.BasicAverageShares.ThreeMonths * (i.EarningReports.BasicEPS.TwelveMonths*i.ValuationRatios.PERatio))
+top_market_cap = sorted(fine, key = lambda x:x.MarketCap, reverse=True)[:int(len(fine)*0.2)]
+top_bm = sorted(top_market_cap, key = lambda x: 1 / x.ValuationRatios.PBRatio, reverse=True)[:int(len(top_market_cap)*0.2)]
+self.sorted_by_bm = [i.Symbol for i in top_bm]
+total_market_cap = np.sum([i.MarketCap for i in top_bm])
+self.weights = {}
+for i in top_bm:
+ self.weights[str(i.Symbol)] = i.MarketCap/total_market_cap
+return self.sorted_by_bm
+
+
+
+In the next step, we sort the stocks with the inverse of P/B ratio by descending order. Quintile portfolios are then formed based on the Book-to-Market ratio and the highest quintile is held for one year.
+
diff --git a/04 Strategy Library/31 Book-to-Market Value Anomaly/03 Algorithm.html b/04 Strategy Library/31 Book-to-Market Value Anomaly/03 Algorithm.html
new file mode 100644
index 0000000..9029e2c
--- /dev/null
+++ b/04 Strategy Library/31 Book-to-Market Value Anomaly/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/31 Book-to-Market Value Anomaly/04 Summary.html b/04 Strategy Library/31 Book-to-Market Value Anomaly/04 Summary.html
new file mode 100644
index 0000000..7d4d947
--- /dev/null
+++ b/04 Strategy Library/31 Book-to-Market Value Anomaly/04 Summary.html
@@ -0,0 +1,9 @@
+
+The portfolio underperforms relatively to the benchmark, S&P 500, during the backtest period.
+
+
+In general, stocks that have a low B/P ratio are considered to be value stocks, and similarly, stocks that have a high B/P ratio are referred to as growth stocks.
+
+
+During a bull market, which is associated with high GDP growth, value stocks tend to underperform growth stocks, as investors are optimistic about future earnings growth.
+
diff --git a/04 Strategy Library/31 Book-to-Market Value Anomaly/05 Source.html b/04 Strategy Library/31 Book-to-Market Value Anomaly/05 Source.html
new file mode 100644
index 0000000..cd8d0fa
--- /dev/null
+++ b/04 Strategy Library/31 Book-to-Market Value Anomaly/05 Source.html
@@ -0,0 +1,5 @@
+
+Gold plays an essential role as a diversifier due to its low or negative correlation to other asset classes. We explore "The Fed Model," a theory that bonds can be used to judge whether the U.S. stock market is fairly valued and use this to determine entry and exit points for gold.
+
+ Historically, the S&P 500 earning yield has a strong correlation with the 10-year Treasury note. There is the theory that if the forward earnings yield of the S&P 500 is higher than the 10-year government bond yield, stocks are undervalued and vice versa.
+
+
+ We import the custom fundamental data of government 10-year bond yield and S&P 500 earnings yield from Quandl.
+
+
+
+# United States Government 10-Year Bond Yield
+self.bond_yield = "YC/USA10Y"
+# S&P 500 Earnings Yield. Earnings Yield = trailing 12 month earnings divided by index price
+self.earnings_yield = "MULTPL/SP500_EARNINGS_YIELD_MONTH"
+# Gold Prices (Daily) - Currency USD (All values are national currency units per troy ounce)
+self.gold = "WGC/GOLD_DAILY_USD"
+# Add custom quandl data
+self.AddData(QuandlRate, self.bond_yield, Resolution.Daily, DateTimeZone.Utc, True)
+self.AddData(QuandlValue, self.earnings_yield, Resolution.Daily, DateTimeZone.Utc, True)
+self.AddData(QuandlValue, self.gold, Resolution.Daily, DateTimeZone.Utc, True)
+
+
+
+
Gold Investment
+
+ With gold having a strong negative correlation to equity valuations, then gold prices will rise along with earnings yield, bond yield, and inflation. Taking the above relationship a step further, this algorithm goes long gold when the Fed model shows the market undervalued otherwise liquidate the portfolio. The undervalued market is defined as the earning yield is higher than the bond yield and their ratio is at least 2. Rebalancing is done on a monthly basis.
+
+
+
+def Rebalance(self):
+ if self.Securities[self.earnings_yield].Price == 0 or self.Securities[self.bond_yield].Price == 0: return
+ # Buy gold if E/P is higher than the bond yield and their ratio is at least 2
+ if self.Securities[self.earnings_yield].Price > self.Securities[self.bond_yield].Price * Decimal(2):
+ self.SetHoldings(self.gold, 0.9)
+ else:
+ self.Liquidate()
+
+
+
Custom Charting
+
+ To demonstrate the relationship between government 10-year bond yield and S&P 500 earnings yield, we plot the two series in equity chart.
+
+ Paired switching is a strategy where in its simplest form, investors pick two assets that are negatively correlated and periodically switch position based on their relative performance. The idea behind this strategy is that if the assets are negatively correlated, then a traditional mixed portfolio might lead to a lower return than the return for the individual assets. If the negative correlation exists, switching positions could improve the performance of a portfolio where two assets are statically weighted.
+
\ No newline at end of file
diff --git a/04 Strategy Library/33 Paired Switching/02 Method.html b/04 Strategy Library/33 Paired Switching/02 Method.html
new file mode 100644
index 0000000..61d91f6
--- /dev/null
+++ b/04 Strategy Library/33 Paired Switching/02 Method.html
@@ -0,0 +1,26 @@
+
+ After two negatively correlated assets are determined, we will analyze them on a quarterly basis. The analysis will consist of retrieving historical prices for the two assets and calculating their performances over the prior quarter. We will buy the asset that yields a higher return during the period. The position is held for one quarter, and then the analysis is repeated.
+
\ No newline at end of file
diff --git a/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/01 Introduction.html b/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/01 Introduction.html
new file mode 100644
index 0000000..fcda95b
--- /dev/null
+++ b/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/01 Introduction.html
@@ -0,0 +1,4 @@
+
+ Momentum effect is an anomaly in nearly every market. However, if a stock in the winner group is in the final stages of overreaction, it is not the best long opportunity because of the high probability of its reversal, and therefore profit reduction. Similarly, in the loser group, a stock which is in the final stages of overreaction is also not the best short opportunity because its reversal would lower the profit of short selling within a short time. Based on this logic,
+ this momentum-reversal strategy seeks to buy winners and sell losers that are less likely to be in the final stages of overreaction.
+
diff --git a/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/02 Method.html b/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/02 Method.html
new file mode 100644
index 0000000..522b29b
--- /dev/null
+++ b/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/02 Method.html
@@ -0,0 +1,88 @@
+
+ All stocks on NYSE and NASDAQ are used as the investment universe. We create a class to save all variables for each symbol.
+
+ To get the value for the above variables, we save the stock price at the start of each month in the rolling window for the last 12 months and calculate the monthly return and the yearly return.
+ Then we can compute the last month's geometric average rate of return (GARR) and the previous 12-month GARR. The formulas are as follows
+
+ We assign the value of two returns to each symbol in SymbolData class. All stocks are sorted based on their past 12-month return.
+ Stocks are then divided into 3 portfolios (top 30% - winner group, middle 40% and bottom 30% - loser group). In the winner group, stocks are further
+ classified into two categories: the return-increasing winner and return-decreasing winner using the ratio of last month's geometric average rate of return (GARR) over the last 12 month GARR.
+
+def CoarseSelectionFunction(self, coarse):
+ if self.month_start:
+ self.coarse = True
+ coarse = [i for i in coarse if i.AdjustedPrice > 10]
+ for i in coarse:
+ if i.Symbol not in self.SymbolPrice:
+ self.SymbolPrice[i.Symbol] = SymbolData(i.Symbol)
+ self.SymbolPrice[i.Symbol].window.Add(float(i.AdjustedPrice))
+ if self.SymbolPrice[i.Symbol].window.IsReady:
+ price = np.array([i for i in self.SymbolPrice[i.Symbol].window])
+ returns = (price[:-1]-price[1:])/price[1:]
+ self.SymbolPrice[i.Symbol].yearly_return = (price[0]-price[-1])/price[-1]
+ GARR_12 = np.prod([(1+i)**(1/12) for i in returns])-1
+ GARR_1 = (1+returns[0])**(1/12)-1
+ self.SymbolPrice[i.Symbol].GARR_ratio = GARR_1 / GARR_12
+
+
+
+
+ The decreasing-return winner group contains 13 stocks in winner group with the lowest GARR Ratio and vice-versa for the increasing-return winner group.
+ The loser group is divided into the increasing-return loser and the decreasing-return loser groups using a similar methodology. The return-increasing loser group
+ contains 15 stocks in loser group with the highest GARR Ratio.
+
+
+
+ReadySymbolPrice = {symbol: SymbolData for symbol, SymbolData in self.SymbolPrice.items() if SymbolData.window.IsReady}
+if ReadySymbolPrice and len(ReadySymbolPrice)>50:
+ # sort stocks in coarse by last 12-month return
+ sorted_by_return = sorted(ReadySymbolPrice, key = lambda x: ReadySymbolPrice[x].yearly_return)
+ # top 30% with the highest 12-month return goes into winner group
+ winner = sorted_by_return[:int(len(sorted_by_return)*0.3)]
+ # bottom 30% with the lowest 12-month return goes into loser group
+ loser = sorted_by_return[-int(len(sorted_by_return)*0.3):]
+ self.decrease_winner = sorted(winner, key = lambda x: ReadySymbolPrice[x].GARR_ratio)[:15]
+ self.increase_loser = sorted(loser, key = lambda x: ReadySymbolPrice[x].GARR_ratio)[-15:]
+ return self.decrease_winner+self.increase_loser
+
+
+
+The algorithm goes long stocks from the decreasing-return winner group and short stocks from the increasing-return loser group. The portfolio is created as equally weighted and rebalanced on a monthly basis.
+
+
+
+def OnData(self, data):
+ if self.month_start and self.coarse:
+ self.month_start = False
+ self.coarse = False
+ if all([self.decrease_winner, self.increase_loser]):
+ stocks_invested = [x.Key for x in self.Portfolio]
+ for i in stocks_invested:
+ if i not in self.decrease_winner+self.increase_loser:
+ self.Liquidate(i)
+ short_weight = 0.5/len(self.increase_loser)
+ for j in self.increase_loser:
+ self.SetHoldings(j, -short_weight)
+ long_weight = 0.5/len(self.decrease_winner)
+ for i in self.decrease_winner:
+ self.SetHoldings(i, long_weight)
+
+
diff --git a/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/03 Algorithm.html b/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/03 Algorithm.html
new file mode 100644
index 0000000..b3b0694
--- /dev/null
+++ b/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/04 Source.html b/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/04 Source.html
new file mode 100644
index 0000000..0b1779c
--- /dev/null
+++ b/04 Strategy Library/34 Momentum-Short Term Reversal Strategy/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/35 Turn of the Month in Equity Indexes/01 Introduction.html b/04 Strategy Library/35 Turn of the Month in Equity Indexes/01 Introduction.html
new file mode 100644
index 0000000..acf9adb
--- /dev/null
+++ b/04 Strategy Library/35 Turn of the Month in Equity Indexes/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ The turn of the month is an effect on stock indices which states that stocks will rise during the last day before the end of the month and the first three days of each month. Researchers believe this significance comes as a result of pension funds receiving cash flows and reinvesting in the market, along with this period being a natural point for portfolio rebalancing between retail and professional investors. This algorithm is an approximation of the following strategy.
+
diff --git a/04 Strategy Library/35 Turn of the Month in Equity Indexes/02 Method.html b/04 Strategy Library/35 Turn of the Month in Equity Indexes/02 Method.html
new file mode 100644
index 0000000..2f57e97
--- /dev/null
+++ b/04 Strategy Library/35 Turn of the Month in Equity Indexes/02 Method.html
@@ -0,0 +1,28 @@
+
+ We start by creating a scheduled event, MonthEnd(), that will trigger the algorithm to buy SPY.
+
+ We will purchase the SPY immediately, and we will wait 3 trading days, as suggested, before liquidating our portfolio. The boolean self.Portfolio.Invested will help us wait 3 days before executing the liquidate order in OnData(). The equity index is bought and sold every month.
+
+
+
def Purchase(self):
+ ''' Immediately purchases the ETF at market opening '''
+ self.SetHoldings(self.spy, 1)
+ self.days = 0
+
+def OnData(self, data):
+ if self.Portfolio.Invested:
+ self.days += 1
+
+ # Liquidates after 3 days
+ if self.days > 3:
+ self.Liquidate(self.spy, 'Liquidate after 3 days')
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/35 Turn of the Month in Equity Indexes/03 Algorithm.html b/04 Strategy Library/35 Turn of the Month in Equity Indexes/03 Algorithm.html
new file mode 100644
index 0000000..ddaf1fb
--- /dev/null
+++ b/04 Strategy Library/35 Turn of the Month in Equity Indexes/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/35 Turn of the Month in Equity Indexes/04 Source.html b/04 Strategy Library/35 Turn of the Month in Equity Indexes/04 Source.html
new file mode 100644
index 0000000..3d56eeb
--- /dev/null
+++ b/04 Strategy Library/35 Turn of the Month in Equity Indexes/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/353 Fama French Five Factors/01 Introduction.html b/04 Strategy Library/353 Fama French Five Factors/01 Introduction.html
new file mode 100644
index 0000000..c5889c0
--- /dev/null
+++ b/04 Strategy Library/353 Fama French Five Factors/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ The relationship between return and risk has long been a popular topic for research. Investors have been seeking financial models that quantify risk and use it to estimate the expected return on equity. The Fama French five-factor model, improved from the Fama French three-factor model, is one of the most classic models (Fama and French, 2015). In this post, we will discuss this model and develop a stock-picking strategy based on it.
+
\ No newline at end of file
diff --git a/04 Strategy Library/353 Fama French Five Factors/02 Method.html b/04 Strategy Library/353 Fama French Five Factors/02 Method.html
new file mode 100644
index 0000000..1fd2f52
--- /dev/null
+++ b/04 Strategy Library/353 Fama French Five Factors/02 Method.html
@@ -0,0 +1,93 @@
+
+ The Fama French five-factor model was proposed in 2014 and is adapted from the Fama French three-factor model (Fama and French, 2015). It builds upon the dividend discount model which states that the value of stocks today is dependent upon future dividends.
+ Fama and French add two factors, investment and profitability, to the dividend discount model to better capture the relationship between risk and return.
+ The model is as follows
+
MKT is the excess return of the market. It is the return on the value-weighted market portfolio.
+
SMB is the return on a diversified portfolio of small-cap stocks minus the return on a diversified portfolio of big-cap stocks.
+
HML is the difference between the returns on diversified portfolios of stocks with high and low Book-to-Market ratios.
+
RMW is the difference between the returns on diversified portfolios of stocks with robust (high and steady) and weak (low) profitability.
+
CMA is the difference between the returns on diversified portfolios of the stocks of low and high investment firms, which we call conservative and aggressive. Here, low/high investment means reinvestment ratio is low/high.
+
+
+
+ Taking inspiration from the Fama French five-factor model, we can develop a multi-factor stock selection strategy that focuses on five factors: size, value, quality, profitability, and investment pattern.
+
+
+
+ First, we run a Coarse Selection to drop equities which have no fundamental data or have too low prices. Then we select those with the highest dollar volume.
+ Note that a useful technique is used here: we can use Universe.Unchanged to remain the same universe when there is no necessary change, which greatly speeds up the backtest.
+
+
+
+
+def CoarseSelectionFunction(self, coarse):
+ '''Drop securities which have no fundamental data or have too low prices.
+ Select those with highest by dollar volume'''
+
+ if self.Time < self.nextLiquidate:
+ return Universe.Unchanged
+
+ selected = sorted([x for x in coarse if x.HasFundamentalData and x.Price > 5],
+ key=lambda x: x.DollarVolume, reverse=True)
+
+ return [x.Symbol for x in selected[:self.num_coarse]]
+
+
+
+
+ Secondly, in Fine Selection, we use the terms TotalEquity, BookValuePerShare, OperationProfitMargin, ROE, and TotalAssetsGrowth to account for the five factors, respectively. We then calculate a custom ranking metric for each stock using these five terms. Our algorithm will go long in the five stocks with the highest scores and short the five stocks with the lowest scores.
+
+
+
+def FineSelectionFunction(self, fine):
+ '''Select securities with highest score on Fama French 5 factors'''
+
+ # Select stocks with these 5 factors:
+ # MKT -- Book value per share: Value
+ # SMB -- TotalEquity: Size
+ # HML -- Operation profit margin: Quality
+ # RMW -- ROE: Profitability
+ # CMA -- TotalAssetsGrowth: Investment Pattern
+ filtered = [x for x in fine if x.ValuationRatios.BookValuePerShare
+ and x.FinancialStatements.BalanceSheet.TotalEquity
+ and x.OperationRatios.OperationMargin.Value
+ and x.OperationRatios.ROE
+ and x.OperationRatios.TotalAssetsGrowth]
+
+ # Sort by factors
+ sortedByMkt = sorted(filtered, key=lambda x: x.ValuationRatios.BookValuePerShare, reverse=True)
+ sortedBySmb = sorted(filtered, key=lambda x: x.FinancialStatements.BalanceSheet.TotalEquity.Value, reverse=True)
+ sortedByHml = sorted(filtered, key=lambda x: x.OperationRatios.OperationMargin.Value, reverse=True)
+ sortedByRmw = sorted(filtered, key=lambda x: x.OperationRatios.ROE.Value, reverse=True)
+ sortedByCma = sorted(filtered, key=lambda x: x.OperationRatios.TotalAssetsGrowth.Value, reverse=False)
+
+ stockBySymbol = {}
+
+ # Get the rank based on 5 factors for every stock
+ for index, stock in enumerate(sortedByMkt):
+ mktRank = self.beta_m * index
+ smbRank = self.beta_s * sortedBySmb.index(stock)
+ hmlRank = self.beta_h * sortedByHml.index(stock)
+ rmwRank = self.beta_r * sortedByRmw.index(stock)
+ cmaRank = self.beta_c * sortedByCma.index(stock)
+ avgRank = np.mean([mktRank,smbRank,hmlRank,rmwRank,cmaRank])
+ stockBySymbol[stock.Symbol] = avgRank
+
+ sorted_dict = sorted(stockBySymbol.items(), key = lambda x: x[1], reverse = True)
+ symbols = [x[0] for x in sorted_dict]
+
+ # Pick the stocks with the highest scores to long
+ self.longSymbols= symbols[:self.num_long]
+ # Pick the stocks with the lowest scores to short
+ self.shortSymbols = symbols[-self.num_short:]
+
+ return self.longSymbols + self.shortSymbols
+
+
diff --git a/04 Strategy Library/353 Fama French Five Factors/03 Results.html b/04 Strategy Library/353 Fama French Five Factors/03 Results.html
new file mode 100644
index 0000000..4d05305
--- /dev/null
+++ b/04 Strategy Library/353 Fama French Five Factors/03 Results.html
@@ -0,0 +1,8 @@
+
+ In this example, the portfolio is rebalanced every 30 days and the backtest period runs from Jan 2010 to Aug 2019. You can improve upon this strategy by changing the fundamental factors, the weight of each factor and the rebalance frequency.
+
+
+
+ The Fama French five-factor model provides a scientific way to measure asset pricing. For the five aspects that Fama and French mentioned, we used one possible combination in our backtest. We can see from the results that it achieves an annual rate of return around 5% with a max drawdown of 30% over 8 years.
+ These factors perhaps cannot capture a sufficient amount of information on the assets' pricing, and therefore, there are still many aspects can be improved (e.g. the weights of factors, a different set of factors for different kinds of equities,etc.) We encourage you to explore and create better algorithms upon this tutorial!
+
\ No newline at end of file
diff --git a/04 Strategy Library/353 Fama French Five Factors/04 Algorithm.html b/04 Strategy Library/353 Fama French Five Factors/04 Algorithm.html
new file mode 100644
index 0000000..f3cdbee
--- /dev/null
+++ b/04 Strategy Library/353 Fama French Five Factors/04 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/353 Fama French Five Factors/05 References.html b/04 Strategy Library/353 Fama French Five Factors/05 References.html
new file mode 100644
index 0000000..4a09697
--- /dev/null
+++ b/04 Strategy Library/353 Fama French Five Factors/05 References.html
@@ -0,0 +1,5 @@
+
\ No newline at end of file
diff --git a/04 Strategy Library/354 Expected Idiosyncratic Skewness/01 Abstract.html b/04 Strategy Library/354 Expected Idiosyncratic Skewness/01 Abstract.html
new file mode 100644
index 0000000..ffa6192
--- /dev/null
+++ b/04 Strategy Library/354 Expected Idiosyncratic Skewness/01 Abstract.html
@@ -0,0 +1,3 @@
+
+ This tutorial implements a strategy that trades stocks with low expected idiosyncratic skewness based on a paper by Boyer, Mitton and Vorkink (2009, hereafter BMV) published in The Review of Financial Studies. Our implementation narrows down our initial universe to liquid assets by selecting 200 stocks based on daily trading volume, price and whether the stock has fundamental data in our data library. We calculate the expected idiosyncratic skewness at the end of each month and sort our universe based on the calculated skewness. This implementation will long the bottom 5%, hold for the next month, and rebalance the portfolio monthly. The Sharpe ratio is 1.03 relative to S&P 500 (SPY) Sharpe ratio of 1.00 during the period of July 1, 2009 to July 30, 2019.
+
\ No newline at end of file
diff --git a/04 Strategy Library/354 Expected Idiosyncratic Skewness/02 Theory.html b/04 Strategy Library/354 Expected Idiosyncratic Skewness/02 Theory.html
new file mode 100644
index 0000000..b49f79e
--- /dev/null
+++ b/04 Strategy Library/354 Expected Idiosyncratic Skewness/02 Theory.html
@@ -0,0 +1,7 @@
+
+ BMV tests recent theories that stocks with low idiosyncratic skewness should have high expected returns. For example, Mitton and Vorkink (2007) develop a model that some investors ("lotto investors") have a preference for positive skewness while others ("traditional investors") are mean-variance optimizers seeking to maximize the Sharpe ratio of their portfolios. Lotto investors accept lower average returns on stocks with high idiosyncratic skewness because they have a preference for stocks with lottery-like return properties. In equilibrium, markets clear at prices such that stocks with high idiosyncratic skewness have low expected returns, due to the different portfolio preferences of the two groups of investors.
+
+
+
+ Despite the theoretical basis for the pricing effects of skewness preference, empirically testing the relation is not straightforward as expected skewness is difficult to measure. BMV accounts for the phenomenon that lagged skewness alone does not adequately forecast skewness by presenting a cross-sectional model of expected skewness using additional predictive variables. Using their model, they reaffirm the existing theory that expected idiosyncratic skewness and returns are negatively correlated. Notably, they find the Fama-French alpha of a low-expected-skewness quintile exceeds the alpha of a high-expected-skewness quintile by 1.00% per month. Furthermore, the Fama-MacBeth cross-sectional regressions have statistically significant, negative coefficients. Besides, BMV finds that the expected skewness helps explain how stocks with low idiosyncratic volatility have high expected returns.
+
\ No newline at end of file
diff --git a/04 Strategy Library/354 Expected Idiosyncratic Skewness/03 Data Description.html b/04 Strategy Library/354 Expected Idiosyncratic Skewness/03 Data Description.html
new file mode 100644
index 0000000..31483b2
--- /dev/null
+++ b/04 Strategy Library/354 Expected Idiosyncratic Skewness/03 Data Description.html
@@ -0,0 +1,3 @@
+
+ To execute our algorithm, we will use daily data from Kenneth French's Data Library that captures the Fama-French three factors for the period July 1, 2009 to June 30, 2019. The raw data is delivered in a zip file which is not directly importable into LEAN. We need to unzip the file and upload the CSV to a Github repository. All other data used for this algorithm, including stock price, volume, and market capitalization, are from QuantConnect's Data Library. In the original paper, BSV also includes firm-specific variables like momentum, turnover, and dummies of properties including Nasdaq-listed stocks, small-size, medium-size, industries. We can refer to this online technical appendix for descriptions of these variables.
+
\ No newline at end of file
diff --git a/04 Strategy Library/354 Expected Idiosyncratic Skewness/04 Method.html b/04 Strategy Library/354 Expected Idiosyncratic Skewness/04 Method.html
new file mode 100644
index 0000000..fa80957
--- /dev/null
+++ b/04 Strategy Library/354 Expected Idiosyncratic Skewness/04 Method.html
@@ -0,0 +1,50 @@
+
+ We can develop a model of estimated expected idiosyncratic skewness using Fama-French three factors. Lower expected idiosyncratic skewness will predict a higher alpha. We will let the investment horizon over which investors are hoping to experience an extreme positive outcome be 1 month. And, let S(t) denote the set of trading days in the current month, and let N(t) denote the number of days in this set.
+
+ Let \(\epsilon_{i,d}\) be the regression residual using the Fama and French (1993) three-factor model on day d for firm i, where the regression coefficients that define this residual are estimated using daily data for days in S(t) as the time-series regression below.
+
+ Let \(iv_{i,t}\) and \(is_{i,t}\) denote historical estimates of idiosyncratic volatility and skewness (respectively) for firm i using daily data for all days in S(t). We can then define \(iv_{i,t}\) and \(is_{i,t}\) as:
+
+ We need measures of expected skewness over a horizon of 1 month for firm i at the end of month t, \(E_t[is_{i,t+1}]\), rather than measures of historical skewness as defined in equation above. To model investor perceptions of expected skewness in a feasible manner, we first estimate cross-sectional regression separately at the end of each month t in our sample,
+
+ Superscripts on regression parameters are included to emphasize that we estimate these parameters using information observable at the end of month t. We then use the regression parameters from equation above, along with information observable at the end of each month t, to estimate expected skewness for each firm,
+
+ This approach provides feasible estimates of each month's expected skewness and accounts for variation between historical moments and expected skewness across time.
+
+
+
Step 4: Generating trading signals
+
+
+ At the end of each month, we use the results of equation above to sort stocks by expected idiosyncratic skewness. We construct our universe using the lowest 5% of expected skewness, and long our assets to construct a value-weighted portfolio.
+
+
diff --git a/04 Strategy Library/354 Expected Idiosyncratic Skewness/05 Conclusion and Future Work.html b/04 Strategy Library/354 Expected Idiosyncratic Skewness/05 Conclusion and Future Work.html
new file mode 100644
index 0000000..0252ef9
--- /dev/null
+++ b/04 Strategy Library/354 Expected Idiosyncratic Skewness/05 Conclusion and Future Work.html
@@ -0,0 +1,13 @@
+
+ Before the BMV paper was published in 2009, a number of theories on the pricing premium for stocks with idiosyncratic skewness existed, but lacked supporting empirical evidence of the relationship between idiosyncratic skewness and returns. BMV fills this void by estimating a model of predicted skewness and using predicted skewness to explain the cross-section of returns. The paper finds that lagged idiosyncratic volatility is a stronger predictor of skewness than lagged idiosyncratic skewness.
+
+
+
+ In this implementation, we rely on idiosyncratic volatility and skewness to predict idiosyncratic skewness. Interested users can build from this implementation by trying the following extensions:
+
+
+
+
Including a number of firm-specific variables to improve predictive power for expected idiosyncratic skewness;
+
Using different investment horizons such as 3 months, 6 months, 1 year;
+
Adding more lags in the time-series regression for both expected and historical idiosyncratic skewness.
+
\ No newline at end of file
diff --git a/04 Strategy Library/354 Expected Idiosyncratic Skewness/06 Algorithm.html b/04 Strategy Library/354 Expected Idiosyncratic Skewness/06 Algorithm.html
new file mode 100644
index 0000000..20f54ed
--- /dev/null
+++ b/04 Strategy Library/354 Expected Idiosyncratic Skewness/06 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/354 Expected Idiosyncratic Skewness/07 References.html b/04 Strategy Library/354 Expected Idiosyncratic Skewness/07 References.html
new file mode 100644
index 0000000..337cf0a
--- /dev/null
+++ b/04 Strategy Library/354 Expected Idiosyncratic Skewness/07 References.html
@@ -0,0 +1,11 @@
+
+
+ Boyer B, Mitton T, Vorkink K. Expected idiosyncratic skewness. The Review of Financial Studies. 2009 Jun 3;23(1):169-202. Online Copy
+
+
+ Fama EF, French KR. Common risk factors in the returns on stocks and bonds. Journal of Financial Economics. 1993 Feb 1;33(1):3-56. Online Copy
+
+
+ Mitton T, Vorkink K. Equilibrium underdiversification and the preference for skewness. The Review of Financial Studies. 2007 Jan 29;20(4):1255-88. Online Copy
+
+ This tutorial implements a strategy that standardizes the unexpected earnings of stocks and trades the top 5% of those standardized stocks. It is written based on a paper published in The Accounting Review by Foster, Olsen, and Shevlin (1984). Our implementation narrows down our universe to 1000 liquid assets based on daily trading volume and price, and the availability of fundamental data on the stocks in our data library. We calculate the unexpected earnings at the beginning of each month, standardize the unexpected earnings, go long on the top 5%, and rebalance the portfolio monthly. We observed a Sharpe ratio of 0.83 relative to SPY Sharpe of 0.88 using this implementation during the period of December 1, 2009 to September 1, 2019 in backtesting.
+
\ No newline at end of file
diff --git a/04 Strategy Library/355 Standardized Unexpected Earnings/02 Theory.html b/04 Strategy Library/355 Standardized Unexpected Earnings/02 Theory.html
new file mode 100644
index 0000000..0179e8b
--- /dev/null
+++ b/04 Strategy Library/355 Standardized Unexpected Earnings/02 Theory.html
@@ -0,0 +1,3 @@
+
+ In market efficiency literature, one frequently discussed topic is the anomalous behavior of stock returns following earnings announcements. The market does not adjust to news from earning announcements instantaneously. Instead, many studies report evidence that the direction and magnitude of returns in the post-earnings announcement period are positively correlated with the direction and magnitude of the unexpected component in the earnings releases. This observed phenomenon is consistent with suggestions that the capital market is inefficient.
+
\ No newline at end of file
diff --git a/04 Strategy Library/355 Standardized Unexpected Earnings/03 Method.html b/04 Strategy Library/355 Standardized Unexpected Earnings/03 Method.html
new file mode 100644
index 0000000..a1b3ba6
--- /dev/null
+++ b/04 Strategy Library/355 Standardized Unexpected Earnings/03 Method.html
@@ -0,0 +1,125 @@
+
+ Unexpected earnings, or earnings surprise, is the difference between reported earnings and the expected earnings of a firm. Expected earnings is calculated using a combination of analyst forecasts and mathematical models based on earnings of previous periods. In this tutorial, we use standardized unexpected earnings (SUE) to measure earnings surprise. SUE's numerator is the change in quarterly earnings per share (EPS) from EPS four quarters ago. Its denominator is the standard deviation of a series of deltas each calculated by subtracting EPS at quarter q-4 from EPS at quarter q. It can be formulated as
+
+ where \(\sigma(X)\) is the standard deviation of X, EPS a firm's quarterly earnings per share, q the current quarter, and q-4 four quarters ago. Keep in mind that although we use quarterly EPS data, the portfolio rebalances monthly. Additionally, note that SUE's stock ranking changes month to month because each company's earnings announcement release date for the quarter differs (i.e., firm A's Q3 announcement may come out in August while firm B's Q3 announcement comes out in September).
+
+
+
+
Step 1: Narrow down the universe with a coarse selection filter function
+
+
+ We use a coarse selection filter to narrow down the universe to 1000 stocks at the beginning of each month according to dollar volume, price and whether the stock has fundamental data in our data library.
+
+
+
+
+
def CoarseSelectionFunction(self, coarse):
+ '''Get dynamic coarse universe to be further selected in fine selection
+ '''
+ # Before next rebalance time, keep the current universe unchanged
+ if self.Time < self.next_rebalance:
+ return Universe.Unchanged
+
+ ### Run the coarse selection to narrow down the universe
+ # Filter stocks by price and whether they have fundamental data
+ # Then, sort descendingly by daily dollar volume
+ sorted_by_volume = sorted([ x for x in coarse if x.HasFundamentalData and x.Price > 5 ],
+ key = lambda x: x.DollarVolume, reverse = True)
+ self.new_fine = [ x.Symbol for x in sorted_by_volume[:self.num_coarse] ]
+
+ # Return all symbols that have appeared in Coarse Selection
+ return list( set(self.new_fine).union( set(self.eps_by_symbol.keys()) ) )
+
+
+
+
Step 2: Sort the universe by SUE and select the top 5%
+
+
+ Next we use a fine universe selection filter to extract quarterly EPS data and save it in a rolling window for each stock. We don't trade during the first 36-month warm-up period because the window is not ready yet. After the warm-up period, we can calculate quarterly EPS change from four quarters ago and the standard deviation of the change over the prior eight quarters using historical EPS data saved in the rolling windows. Then we sort the universe and assign the top 5% of symbols to self.long.
+
+
+
+
+
+
def FineSelectionAndSueSorting(self, fine):
+ '''Select symbols to trade based on sorting of SUE'''
+
+ sue_by_symbol = dict()
+
+ for stock in fine:
+
+ ### Save (symbol, rolling window of EPS) pair in dictionary
+ if not stock.Symbol in self.eps_by_symbol:
+ self.eps_by_symbol[stock.Symbol] = RollingWindow[float](self.months_count)
+ # update rolling window for each stock
+ self.eps_by_symbol[stock.Symbol].Add(stock.EarningReports.BasicEPS.ThreeMonths)
+
+ ### Calculate SUE
+
+ if stock.Symbol in self.new_fine and self.eps_by_symbol[stock.Symbol].IsReady:
+
+ # Calculate the EPS change from four quarters ago
+ rw = self.eps_by_symbol[stock.Symbol]
+ eps_change = rw[0] - rw[self.months_eps_change]
+
+ # Calculate the st dev of EPS change for the prior eight quarters
+ new_eps_list = list(rw)[:self.months_count - self.months_eps_change:3]
+ old_eps_list = list(rw)[self.months_eps_change::3]
+ eps_std = np.std( [ new_eps - old_eps for new_eps, old_eps in
+ zip( new_eps_list, old_eps_list )
+ ] )
+
+ # Get Standardized Unexpected Earnings (SUE)
+ sue_by_symbol[stock.Symbol] = eps_change / eps_std
+
+ # Sort and return the top quantile
+ sorted_dict = sorted(sue_by_symbol.items(), key = lambda x: x[1], reverse = True)
+
+ self.long = [ x[0] for x in sorted_dict[:math.ceil( self.top_percent * len(sorted_dict) )] ]
+ # If universe is empty, OnData will not be triggered, then update next rebalance time here
+ if not self.long:
+ self.next_rebalance = Expiry.EndOfMonth(self.Time)
+
+ return self.long
+
+
+
+
Step 3: Form an equal-weighted portfolio and place orders
+
+
+ Once the symbols are selected, we form an equal-weighted portfolio and place orders. Finally, we update the next rebalance time to the beginning of the next calendar month. The portfolio will be held until liquidated at next rebalance time.
+
+
+
+
+
+
def OnSecuritiesChanged(self, changes):
+ '''Liquidate symbols that are removed from the dynamic universe
+ '''
+ for security in changes.RemovedSecurities:
+ if security.Invested:
+ self.Liquidate(security.Symbol, 'Removed from universe')
+
+
+def OnData(self, data):
+ '''Monthly rebalance at the beginning of each month. Form portfolio with equal weights.
+ '''
+ # Before next rebalance, do nothing
+ if self.Time < self.next_rebalance or not self.long:
+ return
+
+ # Placing orders (with equal weights)
+ equal_weight = 1 / len(self.long)
+ for stock in self.long:
+ self.SetHoldings(stock, equal_weight)
+
+ # Rebalance at the beginning of every month
+ self.next_rebalance = Expiry.EndOfMonth(self.Time)
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/355 Standardized Unexpected Earnings/04 Conclusion and Future Work.html b/04 Strategy Library/355 Standardized Unexpected Earnings/04 Conclusion and Future Work.html
new file mode 100644
index 0000000..291c81a
--- /dev/null
+++ b/04 Strategy Library/355 Standardized Unexpected Earnings/04 Conclusion and Future Work.html
@@ -0,0 +1,10 @@
+
+ This tutorial shows that SEU is a valid indicator for earnings surprise, which can be used as a trading signal to follow post-earning announcement drifts. Our implementation generates a Sharpe ratio of 0.83 relative to SPY Sharpe ratio of 0.88. Interested users can build from this implementation by trying the following extensions:
+
+
+
+
Using a more complicated measure for expected earnings to replace the historical EPS from four quarters ago.
+
Using different investment horizons such as 3 months, 6 months, 1 year. In a longer investment horizon of n months, each month’s decile will have n subdeciles, each of which is initiated in a different month in the prior n-month period. An example is a horizon of 6 months with each month having 6 subdeciles, each initiated in a different month in the prior 6-month period.
+
Importing custom data of analysts’ forecasts of firms’ earnings to replace the expected earnings based on historical EPS.
+
Selecting small-size companies and then trade based on SUE ranking, since studies suggest that post-earnings announcement is more significant for small-size companies than larger ones.
+
\ No newline at end of file
diff --git a/04 Strategy Library/355 Standardized Unexpected Earnings/05 Algorithm.html b/04 Strategy Library/355 Standardized Unexpected Earnings/05 Algorithm.html
new file mode 100644
index 0000000..26f8e7e
--- /dev/null
+++ b/04 Strategy Library/355 Standardized Unexpected Earnings/05 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/355 Standardized Unexpected Earnings/06 References.html b/04 Strategy Library/355 Standardized Unexpected Earnings/06 References.html
new file mode 100644
index 0000000..b138986
--- /dev/null
+++ b/04 Strategy Library/355 Standardized Unexpected Earnings/06 References.html
@@ -0,0 +1,8 @@
+
+
+ Foster G, Olsen C, Shevlin T. Earnings releases, anomalies, and the behavior of security returns. Accounting Review. 1984 Oct 1:574-603 Online Copy
+
+
+ Hou K, Xue C, Zhang L. Replicating Anomalies. The Review of Financial Studies Online Copy
+
+
diff --git a/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/01 Abstract.html b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/01 Abstract.html
new file mode 100644
index 0000000..a095d84
--- /dev/null
+++ b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/01 Abstract.html
@@ -0,0 +1,3 @@
+
+ In this tutorial we implement a correlation-adjusted time-series momentum strategy (TSMOM-CF) that addresses three weaknesses typically found in traditional time-series momentum strategies (TSMOM). Our implementation is based on the paper "Demystifying Time-Series Momentum Strategies: Volatility Estimators, Trading Rules and Pairwise Correlations" by Nick Baltas and Robert Kosowski. We will also compare TSMOM-CF to the basic momentum strategy implemented in our strategy library - Momentum Effect in Commodities Futures.
+
\ No newline at end of file
diff --git a/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/02 Introduction.html b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/02 Introduction.html
new file mode 100644
index 0000000..2130e92
--- /dev/null
+++ b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/02 Introduction.html
@@ -0,0 +1,16 @@
+
+ Baltas and Kosowski modify the basic momentum strategy by incorporating trend strength into the trading signal, using an efficient volatility estimator, and adding a dynamic leverage mechanism. The modifications overcome these three weaknesses:
+
+
+
+
+ An Oversimplified Trading Signal: The traditional time-series momentum strategy (TSMOM) results in high portfolio turnover which, after accounting for transaction costs, leads to diminished performance. Baltas and Kosowski attribute the traditional strategy's extreme long/short positions to an oversimplified trading signal whose values are a discrete +1 or -1. The traditional trading signal is based on the sign of the past 12-month average simple return. Baltas and Kosowski propose a trading signal with a continuous value between +1 and -1. Their signal is a statistical measure that reflects the strength of the price trend.
+
+
+ An Inefficient Volatility Estimator: The TSMOM generally scales asset positions using the estimated volatility of portfolio constituents. The traditional strategy's volatility estimator is the standard deviation of past daily close-to-close returns, which is subject to large estimation errors. Baltas and Kosowski demonstrate that a more efficient volatility estimator can significantly reduce portfolio turnover which, after taking into account transaction costs, boosts the portfolio performance. They present the Yang and Zhang volatility estimator, a range-based estimator that considers the open, high, low, and close prices of assets. The next section will discuss this estimator in greater detail.
+
+
+ A Fixed Portfolio Allocation Mechanism: The TSMOM does not consider the correlation between assets during portfolio construction. It simply allocates funds to each asset based on the properties of the individual assets. Strategies based on TSMOM significantly underperform in the post-2008 global financial crisis (GFC) period due to the increased level of asset co-movement at the time. As a remedy, Baltas and Kosowski introduce a dynamic leverage adjustment for the overall portfolio by adding a correlation factor to the weighting scheme.
+
+\[r_{t,t+1}^{TSMOM-CF} = \text{TSMOM-CF portfolio return from time t to time t+1}\]
+\[N_t = \text{Number of portfolio constituents at time t}\]
+\[X_t^i = \text{Trading signal value of asset i at time t}\]
+\[\sigma_{P,tgt} = \text{Target level of volatility for the overall portfolio}\]
+\[\sigma_t^i = \text{Estimated volatility of asset i at time t}\]
+\[CF(\bar{\rho}_t) = \text{Correlation factor that adjusts the level of leverage applied to each portfolio constituents at time t}\]
+\[r_{t,t+1}^i = \text{return of asset i from time t to time t+1}\]
+
+
+ The formula shows that the weights for each portfolio constituent are dependent on three parts:
+
+
+
+
Part I: Trading Rule Adjustment (\(X_t^i\))
+
+
+The TREND trading rule determines the trading signal based on the statistical strength of the realized return:
+
+where t() is the t-statistic of the daily futures log-returns over the past 12 months to scale the gross exposure to each portfolio constituents.
+
+
+
+When the absolute value of our t-statistic is greater than 1, the trend is highly statistically significant, so the strategy puts 100% exposure to the asset. When the t-statistic is between -1 and 1, the strength of the trend is not as significant, so the strategy scales its exposure to less than 100%.
+
+
+
+
Part II: Yang and Zhang Volatility Estimato(\(\sigma_{YZ}\))
+
+ Instead of estimating each asset's volatility as the standard deviation of past close-to-close daily logarithmic returns, Baltas and Kosowski adopt a more efficient volatility estimator proposed by Yang and Zhang (2000). The formula for the Yang and Zhang volatility estimator (\(\sigma_{YZ}\)) is shown below:
+
+
+\[\sigma_{OJ} = \text{Overnight jump estimator (standard deviation of close-to-open daily logarithmic returns)}\]
+\[\sigma_{SD} = \text{Standard volatility estimator (standard deviation of close-to-close daily logarithmic returns)}\]
+\[\sigma_{RS} = \text{Rogers and Satchell (1991) range estimator}\]
+\[k = \text{parameter that minimizes YZ estimator variance, which is a function of the numbers of days in the estimation}\]
+
+
+ where \(h(\tau)\), \(l(\tau)\) and \(c(\tau)\) denote the logarithmic difference between the high, low and closing prices respectively with the opening price. The RS volatility of an asset at the end of month t, assuming a certain estimation period, is equal to the average daily RS volatility over this period.
+
+
+
+The estimation period is chosen to be 1 month, or 21 trading days, based on Baltas and Kosowski's suggestions.
+
+
+
+
Part III: Correlation Factor (CF)
+Baltas and Kosowski's correlation factor (CF) is a function of \(\bar{\rho}\), which is the average pairwise signed correlation of all portfolio constituents. The calculations are shown below:
+
+\[CF(\bar{\rho}) = \sqrt{\frac{N}{1+(N-1)\bar{\rho}}}\]
+\[\bar{\rho} = 2 \frac{\sum_{i=1}^N \sum_{j=i+1}^N X_i X_j \rho_{i,j}}{N(N-1)}\]
+
+
+ where:
+
+
+\[N = \text{number of assets in the portfolio}\]
+\[\rho_{i,j} = \text{correlation between asset i, j}\]
+\[X_i = \text{trade signal of asset i}\]
+\[\bar{\rho} = \text{average pairwise signed correlation for the entire portfolio}\]
+
diff --git a/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/04 Method.html b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/04 Method.html
new file mode 100644
index 0000000..2014718
--- /dev/null
+++ b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/04 Method.html
@@ -0,0 +1,207 @@
+
+ The strategy requires the continuous futures contract, so we import the custom data from Quandl. We manually create a universe of tradable commodity futures from all available commodity futures traded on CME and ICE. They are all liquid and active continuous contracts #1. The data from Quandl are non-adjusted price based on spot-month continuous contract calculations. The data resolution is daily.
+
+
+
+
Step 1: Import the data
+
+
+
+from QuantConnect.Python import PythonQuandl
+class ImprovedCommodityMomentumTrading(QCAlgorithm):
+ def Initialize(self):
+ for ticker in tickers:
+ data = self.AddData(QuandlFutures, ticker, Resolution.Daily)
+ data.SetLeverage(3) # Leverage was set to 3 for each of the futures contract
+class QuandlFutures(PythonQuandl):
+ def __init__(self):
+ self.ValueColumnName = "Settle"
+
+
+
+
+
+
Step 2: Set the portfolio target volatility and decide rebalance schedule
+
+
+def Initialize(self):
+ # Last trading date tracker to achieve rebalancing the portfolio every month
+ self.nextRebalance = self.Time
+
+ # Set portfolio target level of volatility, set to 12%
+ self.portfolio_target_sigma = 0.12
+
+
+
+
Step 3: Implement functions to calculate the three components of Baltas and Kosowski weights
+
1. TREND Trade Signal
+
+
+def GetTradingSignal(self, history):
+ '''
+ TREND Trading Signal
+ - Uses the t-statistics of historical daily log-returns to reflect the strength of price movement trend
+ - TREND Signal Conditions:
+ t-stat > 1 => TREND Signal = 1
+ t-stat < 1 => TREND Signal = -1
+ -1 < t-stat < 1 => TREND Signal = t-stat
+ '''
+ settle = history.settle.unstack(level = 0)
+
+ # daily futures log-returns based on close-to-close
+ log_returns = np.log(settle/settle.shift(1)).dropna()
+
+ # Calculate the t-statistics as
+ # (mean-0)/(stdev/sqrt(n)), where n is sample size
+ mean = np.mean(log_returns)
+ std = np.std(log_returns)
+ n = len(log_returns)
+ t_stat = mean/(std/np.sqrt(n))
+
+ # cap holding at 1 and -1
+ return np.clip(t_stat, a_max=1, a_min=-1)
+
+
+
+
2. Yang and Zhang Volatility Estimator
+
+
+def GetYZVolatility(self, history, available_symbols):
+ '''
+ Yang and Zhang 'Drift-Independent Volatility Estimation'
+
+ Formula: sigma_YZ^2 = sigma_OJ^2 + self.k * sigma_SD^2 + (1-self.k)*sigma_RS^2 (Equation 20 in [1])
+ where, sigma_OJ - (Overnight Jump Volitility estimator)
+ sigma_SD - (Standard Volitility estimator)
+ sigma_RS - (Rogers and Satchell Range Volatility estimator)'''
+ YZ_volatility = []
+
+ time_index = history.loc[available_symbols[0]].index
+ today = time_index[-1]
+
+ #Calculate YZ volatility for each security and append to list
+ for ticker in available_symbols:
+ past_month_ohlc = history.loc[ticker].loc[today-timedelta(self.OneMonth):today]
+ open, high, low, close = past_month_ohlc.open, past_month_ohlc.high, past_month_ohlc.low, past_month_ohlc.settle
+ estimation_period = past_month_ohlc.shape[0]
+
+ # Calculate constant parameter k for Yang and Zhang volatility estimator
+ # using the formula found in Yang and Zhang (2000)
+ k = 0.34 / (1.34 + (estimation_period + 1) / (estimation_period - 1))
+
+ # sigma_OJ (overnight jump => stdev of close-to-open log returns)
+ open_to_close_log_returns = np.log(open/close.shift(1))
+ open_to_close_log_returns = open_to_close_log_returns[np.isfinite(open_to_close_log_returns)]
+ sigma_OJ = np.std(open_to_close_log_returns)
+
+ # sigma_SD (standard deviation of close-to-close log returns)
+ close_to_close_log_returns = np.log(close/close.shift(1))
+ close_to_close_log_returns = close_to_close_log_returns[np.isfinite(close_to_close_log_returns)]
+ sigma_SD = np.std(close_to_close_log_returns)
+
+ # sigma_RS (Rogers and Satchell (1991))
+ h = np.log(high/open)
+ l = np.log(low/open)
+ c = np.log(close/open)
+ sigma_RS_daily = (h * (h - c) + l * (l - c))**0.5
+ sigma_RS_daily = sigma_RS_daily[np.isfinite(sigma_RS_daily)]
+ sigma_RS = np.mean(sigma_RS_daily)
+
+ # daily Yang and Zhang volatility
+ sigma_YZ = np.sqrt(sigma_OJ**2 + k * sigma_SD**2 + (1 - k) * sigma_RS**2)
+
+ # append annualized volatility to the list
+ YZ_volatility.append(sigma_YZ*np.sqrt(252))
+
+ return YZ_volatility
+
+
+
+
3. Correlation Factor (CF)
+
+
+def GetCorrelationFactor(self, history, trade_signals, available_symbols):
+ '''
+ Calculate the Correlation Factor, which is a function of the average pairwise correlation of all portfolio contituents
+ - the calculation is based on past three month pairwise correlation
+ - Notations:
+ rho_bar - average pairwise correlation of all portfolio constituents
+ CF_rho_bar - the correlation factor as a function of rho_bar'''
+
+ # Get the past three month simple daily returns for all securities
+ settle = history.settle.unstack(level = 0)
+ past_three_month_returns = settle.pct_change().loc[settle.index[-1]-timedelta(self.ThreeMonths):]
+
+ # Get number of assets
+ N_assets = len(available_symbols)
+
+ # Get the pairwise signed correlation matrix for all assets
+ correlation_matrix = past_three_month_returns.corr()
+
+ # Calculate rho_bar
+ summation = 0
+ for i in range(N_assets-1):
+ for temp in range(N_assets - 1 - i):
+ j = i + temp + 1
+ x_i = trade_signals[i]
+ x_j = trade_signals[j]
+ rho_i_j = correlation_matrix.iloc[i,j]
+ summation += x_i * x_j * rho_i_j
+
+ # Equation 14 in [1]
+ rho_bar = (2 * summation) / (N_assets * (N_assets - 1))
+
+ # Calculate the correlation factor (CF_rho_bar)
+ # Equation 18 in [1]
+ return np.sqrt(N_assets / (1 + (N_assets - 1) * rho_bar))
+
+
+
+
Step 4: Construct/Rebalance the Portfolio
+
+For efficiency purposes, a History() request is called once on each rebalance date to get all the data from the past year for all securities. We retrieve our trade signal, Yang and Zhang volatility, and correlation factor by passing the history data frame to each respective function.
+
+
+
+
+def OnData(self, data):
+ '''
+ Monthly rebalance at the beginning of each month.
+ Portfolio weights for each constituents are calculated based on Baltas and Kosowski weights.
+ '''
+
+ # skip if less than 30 days passed since the last trading date
+ if self.Time < self.nextRebalance:
+ return
+
+ '''Monthly Rebalance Execution'''
+ # dataframe that contains the historical data for all securities
+ history = self.History(self.Securities.Keys, self.OneYear, Resolution.Daily)
+ history.replace(0, np.nan, inplace = True)
+
+ # Get the security symbols are are in the history dataframe
+ available_symbols = list(set(history.index.get_level_values(level = 0)))
+
+ # Liquidate symbols that are not in the history dataframe anymore
+ for security in self.Securities.Keys:
+ if security.Value not in available_symbols:
+ self.Liquidate(security, 'Not found in history request')
+
+ # Get the trade signals and YZ volatility for all securities
+ trade_signals = self.GetTradingSignal(history)
+ volatility = self.GetYZVolatility(history, available_symbols)
+
+ # Get the correlation factor
+ CF_rho_bar = self.GetCorrelationFactor(history, trade_signals, available_symbols)
+
+ #Rebalance the portfolio according to Baltas and Kosowski suggested weights
+ N_assets = len(available_symbols)
+ for symbol, signal, vol in zip(available_symbols, trade_signals, volatility):
+ # Baltas and Kosowski weights (Equation 19 in [1])
+ weight = (signal*self.portfolio_target_sigma*CF_rho_bar)/(N_assets*vol)
+ self.SetHoldings(symbol, weight)
+
+ # Set next rebalance time
+ self.nextRebalance = Expiry.EndOfMonth(self.Time)
+
+
diff --git a/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/05 Summary.html b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/05 Summary.html
new file mode 100644
index 0000000..572eb95
--- /dev/null
+++ b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/05 Summary.html
@@ -0,0 +1,3 @@
+
+The implementation of TSMOM-CF in the post-GFC period, January 2018 to September 2019, shows significant performance improvement over the basic TSMOM. The backtest of TSMOM-CF produces Sharpe ratio of 0.321, compared to TSMOM's Sharpe ratio of -0.746 and SPY Sharpe ratio of 0.46. The exact TSMOM algorithm can be found in the strategy library.
+
\ No newline at end of file
diff --git a/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/06 Algorithm.html b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/06 Algorithm.html
new file mode 100644
index 0000000..6eebbb0
--- /dev/null
+++ b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/06 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/07 References.html b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/07 References.html
new file mode 100644
index 0000000..5a494dd
--- /dev/null
+++ b/04 Strategy Library/356 Improved Momentum Strategy on Commodities Futures/07 References.html
@@ -0,0 +1,8 @@
+
+
+ Yang, Dennis & Zhang, Qiang. (2000). Drift-Independent Volatility Estimation Based on High, Low, Open, and Close Prices. The Journal of Business, 73(3), 477-492. doi:10.1086/209650. Online Copy
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/357 Commodities Futures Trend Following/01 Abstract.html b/04 Strategy Library/357 Commodities Futures Trend Following/01 Abstract.html
new file mode 100644
index 0000000..46860f0
--- /dev/null
+++ b/04 Strategy Library/357 Commodities Futures Trend Following/01 Abstract.html
@@ -0,0 +1,3 @@
+
+ In this tutorial we implement a trend following strategy on commodities futures based on a 2014 paper "Two Centuries Of Trend Following" by Y. Lempérière, C. Deremble, P. Seager, M. Potters, and J. P. Bouchaud.
+
\ No newline at end of file
diff --git a/04 Strategy Library/357 Commodities Futures Trend Following/02 Introduction.html b/04 Strategy Library/357 Commodities Futures Trend Following/02 Introduction.html
new file mode 100644
index 0000000..21ba8d1
--- /dev/null
+++ b/04 Strategy Library/357 Commodities Futures Trend Following/02 Introduction.html
@@ -0,0 +1,21 @@
+
+The paper highlights the existence of trends as an anomaly that contradicts the efficient market hypothesis. If financial markets are completely efficient as the hypothesis suggests, then asset price changes should be totally unpredictable. In other words, no systematic excess return based on public information should exist since asset prices ought to reflect all public information available. However observationally, trend existence in the market do exist. They make it possible to use the simple trend following strategy which states, buy when prices goes up and sell when prices goes down. Numerous academic studies have demonstrated that trend following strategies generate persistent returns over long periods of time.
+
+
+
+The paper extends the backtest period of trend following strategies to two centuries and demonstrates statistically significant systematic excess returns on four asset classes (commodities, currencies, stock indices, and bonds). It implements a risk managed strategy that buys or sells a quantity of \(\sigma_n^{-1}\) of the underlying contract depending on the sign of \(s_n\).
+
+
+
+The signal \(s_n(t)\) at the beginning of month t is:
+
+where \(\text{<}p\text{>}_{n,t-1}\) is last month's exponential moving average of past prices with a decay rate equal to n months,\(p(t-1)\) is the price of last month, and \(\sigma_n(t-1)\) is last month's volatility, estimated as the exponential moving average of the absolute monthly price changes, with a decay rate equal to n months. The decay rate was set to 5 months.
+
+
+
+Below, we will implement the above monthly-rebalanced trend following strategy on commodities futures.
+
\ No newline at end of file
diff --git a/04 Strategy Library/357 Commodities Futures Trend Following/03 Method.html b/04 Strategy Library/357 Commodities Futures Trend Following/03 Method.html
new file mode 100644
index 0000000..6e8e094
--- /dev/null
+++ b/04 Strategy Library/357 Commodities Futures Trend Following/03 Method.html
@@ -0,0 +1,123 @@
+
+ The strategy requires the continuous futures contract, so we import the custom data from Quandl. We manually create a universe of tradable commodity futures. They are all liquid and active continuous contracts #1. The data from Quandl are non-adjusted price based on spot-month continuous contract calculations. The data resolution is daily.
+
+
+
+
Step 1: Import futures data from Quandl
+
+
+The paper selected a well-balanced commodities pool to include 7 representative contracts: Crude oil, Henry Hub Natural Gas, Corn, Wheat, Super, Live Cattle and Copper. We will add continuous futures data of these contracts from Quandl. This implementation performs a backtest on 20 years as opposed to 200 years of data for the purpose of comparing to benchmark SPY.
+
Step 2: Create a SymbolData class to store and update the number of contracts to trade for each security
+
+
+In Initialize(), we create a dictionary to store the SymbolData object for each security. The strategy is designed to trade monthly, so we will create a monthly consolidator for each security as well. When a new monthly data becomes available, the consolidator calls an event handler CalendarHandler. Within this event handler, we will update the SymbolData object with the freshly received monthly data.
+
+
+
+def Initialize(self):
+ # Container to store the SymbolData object for each security
+ self.Data = {}
+
+ for ticker in tickers:
+ # Add Quandl data and set desired leverage
+ data = self.AddData(QuandlFutures, ticker, Resolution.Daily)
+ data.SetLeverage(3)
+
+ # Create a monthly consolidator for each security
+ self.Consolidate(ticker, CalendarType.Monthly, self.CalendarHandler)
+
+ # Create a SymbolData object for each security to store relevant indicators
+ # and calculate quantity of contracts to Buy/Sell
+ self.Data[data.Symbol] = SymbolData()
+def CalendarHandler(self, bar):
+ '''
+ Event Handler that updates the SymbolData object for each security when a new monthly bar becomes available
+ '''
+ self.Data[bar.Symbol].Update(bar)
+
+
+
+
+The SymbolData class is designed to contain everything we need for calculating how many contracts to Buy/Sell at the beginning of each month. LEAN provides helpful indicators to get the exponential moving average and momentum indicators. The Introduction section above detailed the formula for calculating the number of contracts to Buy/Sell. We implement the formula in the Update function.
+
+
+
+
+class SymbolData:
+ '''
+ Contains the relevant indicators used to calculate number of contracts to Buy/Sell
+ '''
+ def __init__(self):
+ self.ema = ExponentialMovingAverage("MonthEMA", 5)
+
+ # Volatility estimation is defined as the EMA of absolute monthly price changes
+ # Use Momentum indicator to get absolute monthly price changes.
+ # Then use the IndicatorExtensions.EMA and pass the momentum indicator values to get the volatility
+ self.mom = Momentum("MonthMOM", 1)
+ # Note: self.vol will automatically be updated with self.mom
+ self.vol = IndicatorExtensions.EMA(self.mom, 5)
+
+ self.Quantity = 0
+
+
+ def Update(self, bar):
+ self.ema.Update(bar.Time, bar.Value)
+ self.mom.Update(bar.Time, bar.Value)
+
+ if self.ema.IsReady and self.vol.IsReady:
+ # Equation 1 in [1]
+ signal = (bar.Value - self.ema.Current.Value) / self.vol.Current.Value
+ # Equation 2 in [1]
+ self.Quantity = np.sign(signal)/abs(self.vol.Current.Value)
+
+ return self.Quantity != 0
+
+
+
+
Step 3: Buy and Sell at the beginning of each month
+
+Now we’ll place orders based on the quantity of contracts calculated from previous month stored in the SymbolData object. Note that we warm up the algorithm with 150 days of data to allow the algorithm to execute trades on the start date.
+
+
+
+
+def OnData(self, data):
+ '''
+ Buy/Sell security every month
+ '''
+ if self.Time < self.nextRebalance or self.IsWarmingUp:
+ return
+
+ for symbol in data.Keys:
+ symbolData = self.Data[symbol]
+ if symbolData.Quantity != 0:
+ self.MarketOrder(symbol, symbolData.Quantity)
+
+ self.nextRebalance = Expiry.EndOfMonth(self.Time)
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/357 Commodities Futures Trend Following/04 Summary.html b/04 Strategy Library/357 Commodities Futures Trend Following/04 Summary.html
new file mode 100644
index 0000000..363d402
--- /dev/null
+++ b/04 Strategy Library/357 Commodities Futures Trend Following/04 Summary.html
@@ -0,0 +1,7 @@
+
+For the backtest period (January 1998 to September 2019), the trend following strategy produced a Sharpe ratio of 0.266, compared to SPY’s Sharpe ratio of 0.459. The positive performance of the trend-following strategy over the approximately 20-year time horizon indeed suggests the existence of statistically significant, anomalous, systematic, excess returns from trends. Furthermore, the paper suggests the anomaly is universal across 3 other asset classes (currencies, stock indices and bonds).
+
+
+
+This tutorial demonstrates trends as one of the most powerful sources of anomalous excess returns in financial markets. We hope to inspire the community to develop more trend-based strategies and encourage you to test out this strategy on other asset classes from the original paper.
+
\ No newline at end of file
diff --git a/04 Strategy Library/357 Commodities Futures Trend Following/05 Algorithm.html b/04 Strategy Library/357 Commodities Futures Trend Following/05 Algorithm.html
new file mode 100644
index 0000000..c56a62c
--- /dev/null
+++ b/04 Strategy Library/357 Commodities Futures Trend Following/05 Algorithm.html
@@ -0,0 +1,6 @@
+
+ Y. Lempérière, C. Deremble, P. Seager, M. Potters, J. P. Bouchaud (2014). Two centuries of trend following. Online Copy
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/01 Introduction.html b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/01 Introduction.html
new file mode 100644
index 0000000..654173f
--- /dev/null
+++ b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/01 Introduction.html
@@ -0,0 +1,4 @@
+
+ Growth stocks refer to high-quality, successful companies whose earnings are expected to continue growing at an above-average rate relative to the market.
+ Growth stocks generally have high price-to-earnings (P/E) ratios and high price-to-book(P/B) ratios. At times, growth stocks are considered expensive and overvalued. The value stocks refer to stocks which have high dividend payout ratios or low financial ratios such as P/E ratios and P/B ratios. The value stocks are often considered undervalued by the market. This algorithm will create the long-short positions based on the relation between investor sentiment and the performance of value stocks over growth stocks.
+
diff --git "a/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/01 \347\256\200\344\273\213.cn.html" "b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/01 \347\256\200\344\273\213.cn.html"
new file mode 100644
index 0000000..c26b591
--- /dev/null
+++ "b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/01 \347\256\200\344\273\213.cn.html"
@@ -0,0 +1,3 @@
+
diff --git a/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/02 Method.html b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/02 Method.html
new file mode 100644
index 0000000..a29b638
--- /dev/null
+++ b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/02 Method.html
@@ -0,0 +1,129 @@
+
The measure of investment sentiment
+
+ To measure investors' sentiment, we use gauges: the CBOE equity put-call ratio and the market volatility (VIX) index.
+ The VIX index is constructed using the implied volatilities on S&P 500 index options and shows the market's expectation of 30-day volatility.
+ The CBOE equity put-call ratio is calculated by dividing the trading volume of CBOE equity put options by the trading volume of CBOE equity call options.
+ A rising put-call ratio means equity traders are buying more puts than calls and indicates a bearish sentiment in the market while a falling put-call ratio
+ is considered as the bullish market sentiment.
+
+
+ We import the daily VIX data from Quandl. CBOE provides the volume put-call ratio data from 11-01-2006 to present so we import the custom data from CBOE.
+
+
+
+class SentimentAndStyleRotationAlgorithm(QCAlgorithm):
+ def Initialize(self):
+ self.SetStartDate(2010, 1, 1)
+ self.SetEndDate(2018, 7, 1)
+ self.SetCash(100000)
+ self.AddData(QuandlVix, "CBOE/VIX", Resolution.Daily)
+ self.AddData(CBOE, "PutCallRatio", Resolution.Daily)
+
+class QuandlVix(PythonQuandl):
+ '''Quandl VIX data class'''
+ def __init__(self):
+ self.ValueColumnName = "VIX Close"
+
+class CBOE(PythonData):
+ '''Cboe Equity Volume Put/Call Ratios (11-01-2006 to present) Custom Data Class'''
+ def GetSource(self, config, date, isLiveMode):
+ return SubscriptionDataSource("http://www.cboe.com/publish/scheduledtask/mktdata/datahouse/equitypc.csv", SubscriptionTransportMedium.RemoteFile)
+
+ def Reader(self, config, line, date, isLiveMode):
+ if not (line.strip() and line[0].isdigit()): return None
+ index = CBOE()
+ index.Symbol = config.Symbol
+
+ try:
+ # Example File Format:
+ # DATE CALL PUT TOTAL P/C Ratio
+ # 11/1/06 976510 623929 1600439 0.64
+ data = line.split(',')
+ index.Time = datetime.strptime(data[0], "%m/%d/%Y").strftime("%Y-%m-%d")
+ index.Value = Decimal(data[4])
+
+ except ValueError:
+ return None
+
+ return index
+
+
+
The Measure of the Growth and Value Stocks
+
+ All stocks on NYSE and NASDAQ are used as the investment universe. In CoarseSelectionFunction, we eliminate ETFs which don't have fundamental data.
+ In FineSelectionFunction, stocks are sorted into deciles based on a size measure - market capitalization. We use only the first three size deciles
+ for the algorithm to avoid potential problems with small illiquid stocks.
+
+
+
+def FineSelectionFunction(self, fine):
+ if self.month_start:
+ self.selection = True
+
+ fine = [i for i in fine if i.EarningReports.BasicAverageShares.ThreeMonths>0
+ and i.EarningReports.BasicEPS.TwelveMonths>0
+ and i.ValuationRatios.PERatio>0
+ and i.ValuationRatios.PBRatio>0]
+ # Calculate the market cap and add the "MakretCap" property to fine universe object
+ for i in fine:
+ i.MarketCap = float(i.EarningReports.BasicAverageShares.ThreeMonths * (i.EarningReports.BasicEPS.TwelveMonths*i.ValuationRatios.PERatio))
+ # sort fine object by MarketCap
+ sotrted_market_cap = sorted(fine, key = lambda x:x.MarketCap, reverse=True)
+ decile_top1 = sotrted_market_cap[:floor(len(sotrted_market_cap)/10)]
+ decile_top2 = sotrted_market_cap[floor(len(sotrted_market_cap)/10):floor(len(sotrted_market_cap)*2/10)]
+ decile_top3 = sotrted_market_cap[floor(len(sotrted_market_cap)*2/10):floor(len(sotrted_market_cap)*3/10)]
+
+
+
+ In the next step, we subdivide each size decile into five portfolios based on the P/B ratio. For each of the first three size deciles, the value portfolio consists of all firms included in the quintile with the lowest P/B ratio, and the growth portfolio consists stocks with the highest P/B ratio.
+
+
+
+sorted_PB1 = sorted(decile_top1, key = lambda x: x.ValuationRatios.PBRatio)
+sorted_PB2 = sorted(decile_top2, key = lambda x: x.ValuationRatios.PBRatio)
+sorted_PB3 = sorted(decile_top3, key = lambda x: x.ValuationRatios.PBRatio)
+# The value portfolio consists of all firms included in the quintile with the lowest P/B ratio
+PB_bottom1 = sorted_PB1[:floor(len(decile_top1)/5)]
+PB_bottom2 = sorted_PB2[:floor(len(decile_top2)/5)]
+PB_bottom3 = sorted_PB3[:floor(len(decile_top3)/5)]
+self.value_portfolio = [i.Symbol for i in PB_bottom1 + PB_bottom2 + PB_bottom3]
+# The growth portfolio consists of all firms included in the quintile with the highest P/B ratio
+PB_top1 = sorted_PB1[-floor(len(decile_top1)/5):]
+PB_top2 = sorted_PB2[-floor(len(decile_top2)/5):]
+PB_top3 = sorted_PB3[-floor(len(decile_top3)/5):]
+self.growth_portfolio = [i.Symbol for i in PB_top1 + PB_top2 + PB_top3]
+
+
+
+
The Relation Between Investor Sentiment and Equity Style
+
+ According to the research paper from Lee and Song, When Do Value Stocks Outperform Growth Stocks?: Investor Sentiment and Equity Style Rotation Strategies,
+ value stocks tend to outperform growth stocks when the CBOE equity put-call ratio is relatively low, and the VIX is relatively high. The value portfolio significantly underperforms the growth portfolio when the put-call ratio and VIX are both high.
+ To convert the daily put-call ratio and VIX data into monthly value, we take an average over the recent one month and the previous six months.
+
+
+ If the recent monthly average CBOE put-call ratio is lower than its six-month average and the one-month average of VIX is higher than its six-month average, the algorithm goes long on an equally weighted portfolio consisting of value stocks (the lowest P/B quintile) from the top three size deciles. If recent monthly average CBOE put-call ratio and the VIX index are both higher than their six-month average, the algorithm goes short the value stocks.
+ Otherwise, the algorithm goes long both value stocks and growth stocks. The position holding period is three months, and the portfolio is rebalanced every three months.
+
+
+
+stocks_invested = [x.Key for x in self.Portfolio if x.Value.Invested]
+for i in stocks_invested:
+ if i not in self.value_portfolio+self.growth_portfolio:
+ self.Liquidate(i)
+
+if self.vix_SMA_1.Current.Value > self.vix_SMA_6.Current.Value:
+ if self.PCRatio_SMA_1.Current.Value < self.PCRatio_SMA_6.Current.Value:
+ long_weight = 1/len(self.value_portfolio)
+ for long in self.value_portfolio:
+ self.SetHoldings(long, long_weight)
+ elif self.PCRatio_SMA_1.Current.Value > self.PCRatio_SMA_6.Current.Value:
+ short_weight = 1/len(self.value_portfolio)
+ for short in self.value_portfolio:
+ self.SetHoldings(short, -short_weight)
+else:
+ long_weight = 1/len(self.value_portfolio+self.growth_portfolio)
+ for long in self.value_portfolio+self.growth_portfolio:
+ self.SetHoldings(long, long_weight)
+
+
diff --git "a/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/02 \346\226\271\346\263\225.cn.html" "b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/02 \346\226\271\346\263\225.cn.html"
new file mode 100644
index 0000000..3104b1b
--- /dev/null
+++ "b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/02 \346\226\271\346\263\225.cn.html"
@@ -0,0 +1,120 @@
+
+stocks_invested = [x.Key for x in self.Portfolio if x.Value.Invested]
+for i in stocks_invested:
+ if i not in self.value_portfolio+self.growth_portfolio:
+ self.Liquidate(i)
+
+if self.vix_SMA_1.Current.Value > self.vix_SMA_6.Current.Value:
+ if self.PCRatio_SMA_1.Current.Value < self.PCRatio_SMA_6.Current.Value:
+ long_weight = 1/len(self.value_portfolio)
+ for long in self.value_portfolio:
+ self.SetHoldings(long, long_weight)
+ elif self.PCRatio_SMA_1.Current.Value > self.PCRatio_SMA_6.Current.Value:
+ short_weight = 1/len(self.value_portfolio)
+ for short in self.value_portfolio:
+ self.SetHoldings(short, -short_weight)
+else:
+ long_weight = 1/len(self.value_portfolio+self.growth_portfolio)
+ for long in self.value_portfolio+self.growth_portfolio:
+ self.SetHoldings(long, long_weight)
+
+
diff --git a/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/03 Algorithm.html b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/03 Algorithm.html
new file mode 100644
index 0000000..cff2414
--- /dev/null
+++ b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git "a/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/03 \347\256\227\346\263\225.cn.html" "b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/03 \347\256\227\346\263\225.cn.html"
new file mode 100644
index 0000000..cff2414
--- /dev/null
+++ "b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/03 \347\256\227\346\263\225.cn.html"
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/04 Source.html b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/04 Source.html
new file mode 100644
index 0000000..d965226
--- /dev/null
+++ b/04 Strategy Library/36 Sentiment and Style Rotation Effect in Stocks/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/37 Momentum and State of Market Filters/01 Introduction.html b/04 Strategy Library/37 Momentum and State of Market Filters/01 Introduction.html
new file mode 100644
index 0000000..4d5fa7a
--- /dev/null
+++ b/04 Strategy Library/37 Momentum and State of Market Filters/01 Introduction.html
@@ -0,0 +1,7 @@
+
+ The momentum effect states that what was strongly going up in the near past will probably continue to go up shortly. It is one of the most used trading anomalies, but the strategy using only the momentum can suffer significant drawdowns sometimes.
+
+ Some research papers show that the return of momentum strategies depend on the overall market conditions.
+ This state of the market can be defined in various ways like the investors' sentiment, prior market returns and so on.
+ Therefore, this algorithm will combine the momentum effect with the market state filter to turn off the momentum trading in down market state times.
+
diff --git a/04 Strategy Library/37 Momentum and State of Market Filters/02 Method.html b/04 Strategy Library/37 Momentum and State of Market Filters/02 Method.html
new file mode 100644
index 0000000..31414d9
--- /dev/null
+++ b/04 Strategy Library/37 Momentum and State of Market Filters/02 Method.html
@@ -0,0 +1,114 @@
+
+ As we know, a stock market index tracks the price changes of a select group of stocks and compiles those stock price changes into a single value.
+ For example, S&P500 is composed of only 500 large-cap stocks. A broad market index is characterized by including stocks from companies of all sizes(large, mid and small-cap based on their values).
+ The most popular U.S. broad market indexes include the Russell 3000, the Wilshire 5000 Total Market Index and the MSCI U.S. Broad Market Index. Those broad-based market indexes attempt to cover the entire market
+ and their return can be a good benchmark of the current market state.
+
+
+
+class MomentumandStateofMarkeFiltersAlgorithm(QCAlgorithm):
+ def Initialize(self):
+ self.SetStartDate(2011, 1, 1)
+ self.SetEndDate(2018, 1, 1)
+ self.SetCash(100000)
+ # add Wilshire 5000 Total Market Index data from Dropbox
+ self.AddData(Wilshire5000, "W5000", Resolution.Daily)
+ # calculate the index yearly return
+ self.W5000Return = self.ROC("W5000", 252)
+ # initialize the RateOfChange indicator of Wilshire 5000 total market index
+ history = self.History(["W5000"], 500, Resolution.Daily)
+ for tuple in history.loc["W5000"].itertuples():
+ self.W5000Return.Update(tuple.Index, tuple.value)
+
+
+
+ In this algorithm, we choose the Wilshire 5000 Total Market Index to be the market state measure. For the period of index return, longer horizons should capture more dramatic changes in the state of the market, but longer horizons also reduce the number of observations of changes in the market's state. Here we choose 12 months return according to the paper Market States and Momentum from Guttierez, Cooper and Hameed.
+ The daily index price comes from the Yahoo Finance.
+
+
+
+class Wilshire5000(PythonData):
+ "Class to import Wilshire 5000 Total Market Index data from Dropbox"
+
+ def GetSource(self, config, date, isLiveMode):
+ return SubscriptionDataSource("https://www.dropbox.com/s/z9rof4fr9cqzgpt/W5000.csv?dl=1",
+ SubscriptionTransportMedium.RemoteFile)
+ def Reader(self, config, line, date, isLiveMode):
+ if not (line.strip() and line[1].isdigit()): return None
+ index = Wilshire5000()
+ index.Symbol = config.Symbol
+ try:
+ # Example File Format: (Data starts from 01/04/2010)
+ # Date Open High Low Close Adj Close Volume
+ # 1/4/10 11549.13965 11749.37012 11549.13965 11743.54004 11743.54004 0
+ data = line.split(',')
+ index.Time = datetime.strptime(data[0], "%Y-%m-%d")
+ index.Value = Decimal(data[5])
+ except:
+ return None
+ return index
+
+
+
+
+ The investment universe contains all stocks on NYSE and NASDAQ with a price higher than $1. We use the momentum indicator to gauge the momentum effect.
+ In CoarseSelectionFunction, the MOM indicator value for each symbol in coarse is updated with the adjusted price and saved in the dictionary self.mom.
+
+
+
+def CoarseSelectionFunction(self, coarse):
+ coarse = [x for x in coarse if (x.HasFundamentalData and x.AdjustedPrice > 1)]
+ for i in coarse:
+ if i.Symbol not in self.mom:
+ self.mom[i.Symbol] = SymbolData(i.Symbol, self.lookback)
+ self.mom[i.Symbol].MOM.Update(self.Time, i.AdjustedPrice)
+
+
+
+ When the indicator is ready, stocks are then sorted based on the previous six months momentum value.
+ Top 20 Stocks with the highest MOM are in the long stock list, 20 Stocks with the lowest MOM are in the short stock list.
+
+ The strategy is rebalanced monthly. At the beginning of each month, we identify the state of the market.
+ If the market’s one-year return is positive, we define the state of the market as "UP" otherwise the state is "DOWN".
+ When the market is in "UP" state, we go long on the previous six-month winners (highest Momentum) and goes short on the last six-month losers (lowest Momentum).
+ Stocks are equally weighted. If the market is in "DOWN" state, we liquidate all asset holdings and invest in the long-term Treasury bond ETF to control the downside risk.
+
+
+
+def OnData(self, data):
+ if self.month_start and self.selection:
+ self.month_start = False
+ self.selection = False
+ if self.long is None or self.short is None: return
+ # if the previous 12 months return on the broad equity market was positive
+ if self.W5000Return.Current.Value > 0:
+ stocks_invested = [x.Key for x in self.Portfolio if x.Value.Invested]
+ for i in stocks_invested:
+ if i not in self.long+self.short:
+ self.Liquidate(i)
+ short_weight = 0.5/len(self.short)
+ # goes short on the prior six-month losers (lowest decile)
+ for short_symbol in self.short:
+ self.SetHoldings(short_symbol, -short_weight)
+ # goes long on the prior six-month winners (highest decile)
+ long_weight = 0.5/len(self.long)
+ for long_symbol in self.long:
+ self.SetHoldings(long_symbol, long_weight)
+ else:
+ self.Liquidate()
+ self.SetHoldings(self.tlt, 1)
+
+
diff --git a/04 Strategy Library/37 Momentum and State of Market Filters/03 Algorithm.html b/04 Strategy Library/37 Momentum and State of Market Filters/03 Algorithm.html
new file mode 100644
index 0000000..926770b
--- /dev/null
+++ b/04 Strategy Library/37 Momentum and State of Market Filters/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/37 Momentum and State of Market Filters/04 Source.html b/04 Strategy Library/37 Momentum and State of Market Filters/04 Source.html
new file mode 100644
index 0000000..ad4f813
--- /dev/null
+++ b/04 Strategy Library/37 Momentum and State of Market Filters/04 Source.html
@@ -0,0 +1,5 @@
+
+ Accrual anomaly is based upon the reasoning that it is important to measure if a company's earnings are based on real cash inflow or on revenue recognition from questionable accounting practices. Since companies with lower levels of accruals have more certain real earnings, they should earn higher market returns. This strategy will take a long position in low accrual companies and a short position in high accrual accompanies. It is important to note that this strategy requires fundamental data from the current and past year in order to perform its analysis. As a result, it won't be implementable in live trading at this time.
+
\ No newline at end of file
diff --git a/04 Strategy Library/38 Accrual Anomaly/02 Method.html b/04 Strategy Library/38 Accrual Anomaly/02 Method.html
new file mode 100644
index 0000000..e800787
--- /dev/null
+++ b/04 Strategy Library/38 Accrual Anomaly/02 Method.html
@@ -0,0 +1,69 @@
+
+ The first step is coarse and fine universe selection. Using coarse selection, we create an investment universe with stocks that have fundamental data. The universes will be saved so that we can perform analysis on the annual changes of specific balance sheet data in the following year.
+
+
+
+ def CoarseSelectionFunction(self, coarse):
+ if self.yearly_rebalance:
+ self.filtered_coarse = [x.Symbol for x in coarse if (x.HasFundamentalData)
+ and (x.Market == "usa")]
+ return self.filtered_coarse
+ else:
+ return []
+
+def FineSelectionFunction(self, fine):
+ if self.yearly_rebalance:
+ fine = [x for x in fine if (float(x.FinancialStatements.BalanceSheet.CurrentAssets.Value) > 0)
+ and (float(x.FinancialStatements.BalanceSheet.CashAndCashEquivalents.Value) > 0)
+ and (float(x.FinancialStatements.BalanceSheet.CurrentLiabilities.Value) > 0)
+ and (float(x.FinancialStatements.BalanceSheet.CurrentDebt.Value) > 0)
+ and (float(x.FinancialStatements.BalanceSheet.IncomeTaxPayable.Value) > 0)
+ and (float(x.FinancialStatements.IncomeStatement.DepreciationAndAmortization.Value) > 0)]
+
+ if not self.previous_fine:
+ self.previous_fine = fine
+ self.yearly_rebalance = False
+ return []
+ else:
+ self.filtered_fine = self.CalculateAccruals(fine,self.previous_fine)
+ sorted_filter = sorted(self.filtered_fine, key=lambda x: x.bs_acc)
+ self.filtered_fine = [i.Symbol for i in sorted_filter]
+ self.previous_fine = fine
+ return self.filtered_fine
+ else:
+ return []
+
+
+
+ During fine universe selection we take the stocks from the previous and current year and calculate their balance sheet based accrual values. The stocks are then sorted in ascending order based upon the implemented formula. Note that we account for size difference across the sample firms by scaling the accruals by the average of the beginning and end-of-year book value of total assets.
+
+
+
+ def CalculateAccruals(self, current, previous):
+ accruals = []
+ for stock_data in current:
+ try:
+ prev_data = None
+ for x in previous:
+ if x.Symbol == stock_data.Symbol:
+ prev_data = x
+ break
+
+ delta_assets = float(stock_data.FinancialStatements.BalanceSheet.CurrentAssets.Value)-float(prev_data.FinancialStatements.BalanceSheet.CurrentAssets.Value)
+ delta_cash = float(stock_data.FinancialStatements.BalanceSheet.CashAndCashEquivalents.Value)-float(prev_data.FinancialStatements.BalanceSheet.CashAndCashEquivalents.Value)
+ delta_liabilities = float(stock_data.FinancialStatements.BalanceSheet.CurrentLiabilities.Value)-float(prev_data.FinancialStatements.BalanceSheet.CurrentLiabilities.Value)
+ delta_debt = float(stock_data.FinancialStatements.BalanceSheet.CurrentDebt.Value)-float(prev_data.FinancialStatements.BalanceSheet.CurrentDebt.Value)
+ delta_tax = float(stock_data.FinancialStatements.BalanceSheet.IncomeTaxPayable.Value)-float(prev_data.FinancialStatements.BalanceSheet.IncomeTaxPayable.Value)
+ dep = float(stock_data.FinancialStatements.IncomeStatement.DepreciationAndAmortization.Value)
+ avg_total = (float(stock_data.FinancialStatements.BalanceSheet.TotalAssets.Value)+float(prev_data.FinancialStatements.BalanceSheet.TotalAssets.Value))/2
+
+ stock_data.bs_acc = ((delta_assets-delta_cash)-(delta_liabilities-delta_debt-delta_tax)-dep)/avg_total
+ accruals.append(stock_data)
+ except:
+ pass
+ return accruals
+
+
+
+ In OnData(), we short top decile of the stocks in the sorted list and long the bottom decile of stocks. The portfolio is rebalanced every year at the start of June.
+
\ No newline at end of file
diff --git a/04 Strategy Library/39 Asset Growth Effect/01 Introduction.html b/04 Strategy Library/39 Asset Growth Effect/01 Introduction.html
new file mode 100644
index 0000000..f9177b2
--- /dev/null
+++ b/04 Strategy Library/39 Asset Growth Effect/01 Introduction.html
@@ -0,0 +1,6 @@
+
+ The asset growth effect is based upon the reasoning that high asset growth stocks underperform stocks with low asset growth. Some papers suggest that the return premium achieved by low asset growth stocks is consistent with the compensation for risk. There are two popular arguments to suggest this return premium. One arguments is that as firms grow, the asset mix of the firm becomes less risky as assets-in-place displace the value of assets the firm's expected to invest in the future. The second argument is that there is a systematic market mispricing of growing businesses due to the extrapolation of past gains to growth for high asset growth companies.
+
+
+ This strategy will take a long position in low asset growth companies, and a short position in high asset growth accompanies. It is important to note that this strategy requires fundamental data from the current and past year to perform its analysis. As a result, this strategy would need a year in live trading to determine signals.
+
\ No newline at end of file
diff --git "a/04 Strategy Library/39 Asset Growth Effect/01 \347\256\200\344\273\213.cn.html" "b/04 Strategy Library/39 Asset Growth Effect/01 \347\256\200\344\273\213.cn.html"
new file mode 100644
index 0000000..69d32c7
--- /dev/null
+++ "b/04 Strategy Library/39 Asset Growth Effect/01 \347\256\200\344\273\213.cn.html"
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/04 Strategy Library/39 Asset Growth Effect/02 Method.html b/04 Strategy Library/39 Asset Growth Effect/02 Method.html
new file mode 100644
index 0000000..0335c63
--- /dev/null
+++ b/04 Strategy Library/39 Asset Growth Effect/02 Method.html
@@ -0,0 +1,57 @@
+
+ The first step is coarse and fine universe selection. Using coarse selection, we create an investment universe with all non-financial U.S. stocks listed on NYSE, AMEX, and NASDAQ that contain fundamental data. The universes will be saved so that we can perform analysis on the annual changes of the total assets in the following year.
+
+
+
+def CoarseSelectionFunction(self, coarse):
+ if self.yearly_rebalance:
+ filtered_coarse = [x.Symbol for x in coarse if (x.HasFundamentalData)
+ and (x.Market == "usa")]
+ return filtered_coarse
+ else:
+ return []
+
+def FineSelectionFunction(self, fine):
+ if self.yearly_rebalance:
+ fine = [x for x in fine if x.FinancialStatements.BalanceSheet.TotalAssets.Value > 0
+ and ((x.SecurityReference.ExchangeId == "NYS") or (x.SecurityReference.ExchangeId == "NAS") or (x.SecurityReference.ExchangeId == "ASE"))
+ and (x.CompanyReference.IndustryTemplateCode!="B")
+ and (x.CompanyReference.IndustryTemplateCode!="I")]
+ if not self.previous_fine:
+ self.previous_fine = fine
+ self.yearly_rebalance = False
+ return []
+ else:
+ self.filtered_fine = self.Calculate(fine,self.previous_fine)
+ sorted_filter = sorted(self.filtered_fine, key=lambda x: x.delta_assets)
+ self.filtered_fine = [i.Symbol for i in sorted_filter]
+ self.previous_fine = fine
+ return self.filtered_fine
+ else:
+ return []
+
+
+
+ During fine universe selection we take the stocks from the previous and current year and calculate their total asset growth. The stocks are then sorted in ascending order based upon the implemented calculation. Note that we account for size difference across the sample firms by scaling the growth by last year's total assets.
+
+
+
+def Calculate(self, current, previous):
+ growth = []
+ for stock_data in current:
+ try:
+ prev_data = None
+ for x in previous:
+ if x.Symbol == stock_data.Symbol:
+ prev_data = x
+ break
+ stock_data.delta_assets = (float(stock_data.FinancialStatements.BalanceSheet.TotalAssets.Value)-float(prev_data.FinancialStatements.BalanceSheet.TotalAssets.Value))/float(prev_data.FinancialStatements.BalanceSheet.TotalAssets.Value)
+ growth.append(stock_data)
+ except:
+ pass
+ return growth
+
+
+
+ In OnData(), we short top decile of the stocks in the sorted list and long the bottom decile of stocks. The portfolio is rebalanced every year at the end of June.
+
+def CoarseSelectionFunction(self, coarse):
+ if self.yearly_rebalance:
+ filtered_coarse = [x.Symbol for x in coarse if (x.HasFundamentalData)
+ and (x.Market == "usa")]
+ return filtered_coarse
+ else:
+ return []
+
+def FineSelectionFunction(self, fine):
+ if self.yearly_rebalance:
+ fine = [x for x in fine if x.FinancialStatements.BalanceSheet.TotalAssets.Value > 0
+ and ((x.SecurityReference.ExchangeId == "NYS") or (x.SecurityReference.ExchangeId == "NAS") or (x.SecurityReference.ExchangeId == "ASE"))
+ and (x.CompanyReference.IndustryTemplateCode!="B")
+ and (x.CompanyReference.IndustryTemplateCode!="I")]
+ if not self.previous_fine:
+ self.previous_fine = fine
+ self.yearly_rebalance = False
+ return []
+ else:
+ self.filtered_fine = self.Calculate(fine,self.previous_fine)
+ sorted_filter = sorted(self.filtered_fine, key=lambda x: x.delta_assets)
+ self.filtered_fine = [i.Symbol for i in sorted_filter]
+ self.previous_fine = fine
+ return self.filtered_fine
+ else:
+ return []
+
\ No newline at end of file
diff --git a/04 Strategy Library/40 Pairs Trading with Country ETFs/01 Introduction.html b/04 Strategy Library/40 Pairs Trading with Country ETFs/01 Introduction.html
new file mode 100644
index 0000000..f9bd0fd
--- /dev/null
+++ b/04 Strategy Library/40 Pairs Trading with Country ETFs/01 Introduction.html
@@ -0,0 +1,6 @@
+
+ Pairs trading is a non-directional, market-neutral trading strategy which seeks to identify the price divergence from two highly correlated assets.
+ Pairs trading assumes the co-movement and the mean reversion of two asset prices. It indicates that the price of selected assets
+ tend to move together, and when they diverge, we can exploit the investment opportunity by taking a market neutral position as we assume their price will tend to move back to the average price over time.
+ In this algorithm, we use a large family of international exchange-traded funds(ETFs) to examine the performance of the pairs trading strategy.
+
diff --git a/04 Strategy Library/40 Pairs Trading with Country ETFs/02 Method.html b/04 Strategy Library/40 Pairs Trading with Country ETFs/02 Method.html
new file mode 100644
index 0000000..8a84d14
--- /dev/null
+++ b/04 Strategy Library/40 Pairs Trading with Country ETFs/02 Method.html
@@ -0,0 +1,69 @@
+
The selection of pairs
+
+ The investment universe consists of 25 international ETFs. The pair selection is based on a rolling time period called the formation period.
+ During each formation period, we save the history closing price of each ETF. Here we use a Python list-like container calleddeque to keep a fixed-length price series. From these prices, we compute normalized cumulative price indices which are comparable across the ETFs in the group.
+ According to the paper Pairs Trading on International ETFs from Panagiotis, Dimitrios and Tao,
+ here the formation period is 120 days.
+
+ Where \(r_t^n\) is the simple return of the n-th ETF. \(R_t^n\) is the index value.
+
+
+ For each formation period, we compute the average absolute distance among all pairs in the group and
+ then rank the distances from the smallest to largest to identify the trading opportunities.
+ The top 5 pairs with the smallest distance are used in the subsequent 20 day trading period.
+ The definition of distance is
+
+ Now we consider the top 5 pairs. For each of the one month trading period, we compute the 120-day normalized cumulative price indices and compare them to a fraction of the distance value \(D_t^{a,b}\) for each pair (a,b). Assume the threshold is 0.5, if the index value of asset A is greater than asset B by 0.5 times the current distance \(D_t^{a,b}\),
+ then we sell asset A and buy asset B. The quantity of A and B is based on the dollar neutral. We invest the same amount of money in the long leg and the short leg, vice versa if the index value of asset B is greater than asset A by 0.5 times the distance. When the difference between index A and index B falls into the range \(\left(-0.5D_t^{a,b},0.5D_t^{a,b}\right)\),
+ we liquidate the pair. The above procedure is repeated for all top 5 pairs. At the start of next month, the new pairs are selected and trade for next month.
+
+
+
+for i in self.sorted_pairs:
+ pair = Pair(i[0], i[1], self.history_price[i[0].Value], self.history_price[i[1].Value])
+ index_a = pair.index_a[-1]
+ index_b = pair.index_b[-1]
+ delta = pair.distance()
+ if index_a - index_b > self.threshold*delta:
+ if not self.Portfolio[pair.symbol_a].Invested and not self.Portfolio[pair.symbol_b].Invested:
+ ratio = self.Portfolio[pair.symbol_a].Price / self.Portfolio[pair.symbol_b].Price
+ quantity = int(self.CalculateOrderQuantity(pair.symbol_a, 0.2))
+ self.Sell(pair.symbol_a, quantity)
+ self.Buy(pair.symbol_b, floor(ratio*quantity))
+
+ elif index_a - index_b < -self.threshold*delta:
+ if not self.Portfolio[pair.symbol_a].Invested and not self.Portfolio[pair.symbol_b].Invested:
+ ratio = self.Portfolio[pair.symbol_b].Price / self.Portfolio[pair.symbol_a].Price
+ quantity = int(self.CalculateOrderQuantity(pair.symbol_b, 0.2))
+ self.Sell(pair.symbol_b, quantity)
+ self.Buy(pair.symbol_a, floor(ratio*quantity))
+
+ # the position is closed when prices revert back
+ elif self.Portfolio[i[0]].Invested and self.Portfolio[i[1]].Invested:
+ self.Liquidate(pair.symbol_a)
+ self.Liquidate(pair.symbol_b)
+
+
diff --git a/04 Strategy Library/40 Pairs Trading with Country ETFs/03 Algorithm.html b/04 Strategy Library/40 Pairs Trading with Country ETFs/03 Algorithm.html
new file mode 100644
index 0000000..36343ed
--- /dev/null
+++ b/04 Strategy Library/40 Pairs Trading with Country ETFs/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/40 Pairs Trading with Country ETFs/04 Source.html b/04 Strategy Library/40 Pairs Trading with Country ETFs/04 Source.html
new file mode 100644
index 0000000..e9da602
--- /dev/null
+++ b/04 Strategy Library/40 Pairs Trading with Country ETFs/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/58 VIX Predicts Stock Index Returns/01 Introduction.html b/04 Strategy Library/58 VIX Predicts Stock Index Returns/01 Introduction.html
new file mode 100644
index 0000000..a519011
--- /dev/null
+++ b/04 Strategy Library/58 VIX Predicts Stock Index Returns/01 Introduction.html
@@ -0,0 +1,6 @@
+
+ VIX index is the weighted average of the implied volatilities computed from a total of eight near-the-money, nearby and second nearby American option contracts on the underlying S&P100 index. The index is calculated on an intraday basis by the CBOE.
+ The extreme levels of the VIX index are a strong indicator of equity index returns.
+ One could anticipate that the higher the fear in the markets, indicated by the VIX index, the higher the subsequent returns on the broad equity index.
+ In this algorithm, we will explore if VIX index is the forward-looking indicator of future stock index returns.
+
diff --git a/04 Strategy Library/58 VIX Predicts Stock Index Returns/02 Method.html b/04 Strategy Library/58 VIX Predicts Stock Index Returns/02 Method.html
new file mode 100644
index 0000000..3564d32
--- /dev/null
+++ b/04 Strategy Library/58 VIX Predicts Stock Index Returns/02 Method.html
@@ -0,0 +1,49 @@
+
+ To assess if the implied volatility turns out to be relevant trading signals for
+ long and short positions, we must first define what we mean by large or small implied volatility levels.
+ At any given time, we create 20 equally spaced percentiles for the history close price of VIX in the last two years.
+ By 20 equally spaced percentiles, it means the 5%, 10%, . . . , 95% percentiles. Then the current VIX index price is compared to these percentiles and ranked accordingly.
+
+
+ We import the daily VIX data from Quandl. The correspondent stock index is S&P100 index. We use the iShares S&P 100 ETF OEF
+ In the first step, we create a rolling window to save the history VIX price. The history request is used to initialize the rolling window.
+
+ The rolling past 2-year history of the VIX index is then split to create 20 equally spaced percentiles.
+ The algorithm goes long on the equity index if the VIX index on the current day is higher than on any other day during the rolling 2-year window or if the VIX index value is in the highest 2 percentile boxes.
+ If the VIX index on the current day is lower than on any other day during the rolling 2-year window or if the VIX index value is in the lowest two percentile boxes. The algorithm goes short on the equity index.
+
+
+
+def OnData(self, data):
+ if not data.ContainsKey(self.vix): return
+ self.window.Add(self.Securities[self.vix].Price)
+ if not self.window.IsReady: return
+ history_close = [i for i in self.window]
+
+ if self.Securities[self.vix].Price > np.percentile(history_close, 90):
+ self.SetHoldings("OEF", 1)
+ elif self.Securities[self.vix].Price < np.percentile(history_close, 10):
+ self.SetHoldings("OEF", -1)
+
+
diff --git a/04 Strategy Library/58 VIX Predicts Stock Index Returns/03 Algorithm.html b/04 Strategy Library/58 VIX Predicts Stock Index Returns/03 Algorithm.html
new file mode 100644
index 0000000..529a2d1
--- /dev/null
+++ b/04 Strategy Library/58 VIX Predicts Stock Index Returns/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/58 VIX Predicts Stock Index Returns/04 Source.html b/04 Strategy Library/58 VIX Predicts Stock Index Returns/04 Source.html
new file mode 100644
index 0000000..1afea81
--- /dev/null
+++ b/04 Strategy Library/58 VIX Predicts Stock Index Returns/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/61 Lunar Cycle in Equity Market/01 Introduction.html b/04 Strategy Library/61 Lunar Cycle in Equity Market/01 Introduction.html
new file mode 100644
index 0000000..49a362d
--- /dev/null
+++ b/04 Strategy Library/61 Lunar Cycle in Equity Market/01 Introduction.html
@@ -0,0 +1,8 @@
+
+ The lunar phase is the shape of the direct sunlight portion of the Moon as viewed from Earth.
+ The lunar phases gradually and cyclically change over the period of a month.
+ Lunar phases have proven effects on human biology and psychology.
+ Investors are subject to various psychological and behavioral biases and mood fluctuations.
+ Therefore if lunar phases affect mood, by extension, these phases may affect investor behavior and thus asset prices.
+ This tutorial we will build an algorithm based upon the Moon phase.
+
diff --git a/04 Strategy Library/61 Lunar Cycle in Equity Market/02 Method.html b/04 Strategy Library/61 Lunar Cycle in Equity Market/02 Method.html
new file mode 100644
index 0000000..450d0cf
--- /dev/null
+++ b/04 Strategy Library/61 Lunar Cycle in Equity Market/02 Method.html
@@ -0,0 +1,65 @@
+
+ The lunar calendar data is obtained from the United States Naval Observatory (USNO) website. We import the custom data as a CSV file.
+ The four phases of the lunar cycle are New Moon, First Quarter, Full Moon and Last Quarter. They are in string format in the data file so
+ we convert the string names to numbers as New Moon(0), First Quarter(1), Full Moon(2) and Last Quarter(3).
+
+
+
+class MoonPhase(PythonData):
+ "Class to import Phases of the Moon data from Dropbox"
+
+ def GetSource(self, config, date, isLiveMode):
+ return SubscriptionDataSource("https://www.dropbox.com/s/q9rt06tpfjlvymt/MoonPhase.csv?dl=1", SubscriptionTransportMedium.RemoteFile)
+
+ def Reader(self, config, line, date, isLiveMode):
+ index = MoonPhase()
+ index.Symbol = config.Symbol
+ try:
+ # Example File Format: (Data starts from 01/07/2004)
+ # date phase
+ # 2004 Jan 07 15:40 Full Moon
+ data = line.split(',')
+ if data[0] == "date": return None
+ index.Time = datetime.strptime(data[0], "%Y %b %d %H:%M").replace(hour=0, minute=0)
+ if data[1] == "New Moon":
+ index.Value = 0
+ elif data[1] == "First Quarter":
+ index.Value = 1
+ elif data[1] == "Full Moon":
+ index.Value = 2
+ elif data[1] == "Last Quarter":
+ index.Value = 3
+ except:
+ return None
+
+ return index
+
+
+
+
+ Research shows that the effect is strongest in emerging markets.
+ Here we choose the iShares MSCI Emerging Markets Index ETF EEM.
+ The algorithm therefore goes long in emerging market index ETF 7 days before the new moon and switch to a short position on ETF 7 days before the full moon.
+ The benchmark is set to EEM.
+
+
+
+
+def Initialize(self):
+ self.SetStartDate(2004, 1, 1)
+ self.SetEndDate(2018, 8, 1)
+ self.SetCash(100000)
+ # import the custom data
+ self.AddData(MoonPhase, "phase", Resolution.Daily)
+ self.AddEquity("EEM", Resolution.Daily)
+ self.SetBenchmark("EEM")
+
+def OnData(self, data):
+ # long in emerging market index ETF 7 days before the new moon (It's the Last Quarter)
+ if self.Securities["phase"].Price == 3 and not self.Portfolio["EEM"].IsLong:
+ self.SetHoldings("EEM", 1)
+ # short on emerging market index ETF 7 days before the full moon (It's the First Quarter)
+ elif self.Securities["phase"].Price == 1 and not self.Portfolio["EEM"].IsShort:
+ self.SetHoldings("EEM", -1)
+
+
diff --git a/04 Strategy Library/61 Lunar Cycle in Equity Market/03 Algorithm.html b/04 Strategy Library/61 Lunar Cycle in Equity Market/03 Algorithm.html
new file mode 100644
index 0000000..8caed63
--- /dev/null
+++ b/04 Strategy Library/61 Lunar Cycle in Equity Market/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/61 Lunar Cycle in Equity Market/04 Source.html b/04 Strategy Library/61 Lunar Cycle in Equity Market/04 Source.html
new file mode 100644
index 0000000..2a93cea
--- /dev/null
+++ b/04 Strategy Library/61 Lunar Cycle in Equity Market/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/66 Combining Momentum Effect with Volume/01 Introduction.html b/04 Strategy Library/66 Combining Momentum Effect with Volume/01 Introduction.html
new file mode 100644
index 0000000..0b90427
--- /dev/null
+++ b/04 Strategy Library/66 Combining Momentum Effect with Volume/01 Introduction.html
@@ -0,0 +1,5 @@
+
+ The Momentum traders take on a long or short position in the stock, in the hopes that the momentum will continue in the same direction.
+ The momentum strategy has a higher degree of volatility than most other strategies.
+ In the tutorial, we'll introduce the trading volume factor to enhance the portfolio return and control the risk of momentum strategy.
+
diff --git a/04 Strategy Library/66 Combining Momentum Effect with Volume/02 Method.html b/04 Strategy Library/66 Combining Momentum Effect with Volume/02 Method.html
new file mode 100644
index 0000000..a2593a9
--- /dev/null
+++ b/04 Strategy Library/66 Combining Momentum Effect with Volume/02 Method.html
@@ -0,0 +1,108 @@
+
+ The investment universe consists of all stocks on NYSE and NASDAQ. The momentum is usually defined by the stock return in the last N months.
+ The indicator RateOfChange is constructed to represent the return. The lookback period is one year.
+
+ The ROC indicator and volume are updated everyday in CoarseSelectionFunction. Securities which do not have fundamental data are eliminated.
+
+
+
+
+ def CoarseSelectionFunction(self, coarse):
+ for i in coarse:
+ if i.Symbol not in self.dataDict:
+ self.dataDict[i.Symbol] = SymbolData(i.Symbol, self.lookback)
+ self.dataDict[i.Symbol].ROC.Update(i.EndTime, i.AdjustedPrice)
+ self.dataDict[i.Symbol].Volume = i.Volume
+
+ if self.monthly_rebalance:
+ # drop stocks which have no fundamental data
+ filteredCoarse = [x for x in coarse if (x.HasFundamentalData)]
+ return [i.Symbol for i in filteredCoarse]
+ else:
+ return []
+
+
+
+ Trading volume (turnover) serves as a useful indicator of the level of investor interest in stocks.
+ The number of sellers tends to exceed the number of buyers when the stock falls into disfavor, which will lead to a falling share price.
+ When a stock is popular, the number of buyers exceeds the number of sellers, the price tends to rise.
+ As a result, a firm’s turnover may be a measure of investors' interest in the firm's stock so it could help to identify the future trend of stocks.
+ Here the turnover is calculated as the ratio of the number of shares traded each day to the number of shares outstanding.
+
+
+ In FineSelectionFunction, after the indicator is ready for all symbols in dictionary self.dataDict, turnover is calculated
+ with the Volume and EarningReports.BasicAverageShares.
+
+
+
+def FineSelectionFunction(self, fine):
+ if self.monthly_rebalance:
+ dataReady = {symbol: symbolData for (symbol, symbolData) in self.dataDict.items() if symbolData.ROC.IsReady}
+ if len(dataReady) < 100:
+ self.filteredFine = []
+ else:
+ sortedFine = [i for i in fine if i.EarningReports.BasicAverageShares.ThreeMonths != 0 and i.Symbol in dataReady]
+ sortedFineSymbols = [i.Symbol for i in sortedFine]
+ filteredData = {symbol: symbolData for (symbol, symbolData) in dataReady.items() if symbol in sortedFineSymbols}
+ for i in sortedFine:
+ if i.Symbol in filteredData and filteredData[i.Symbol].Volume != 0:
+ filteredData[i.Symbol].Turnover = i.EarningReports.BasicAverageShares.ThreeMonths / filteredData[i.Symbol].Volume
+
+
+
+ Stocks are sorted into deciles every month based on previous 12-month returns.
+ Each momentum decile is then divided into terciles based on turnover. The long and short portfolios are constructed with the highest turnover from the top momentum decile and the highest volume from the bottom momentum decile respectively.
+
+
+
+for i in sortedFine:
+ if i.Symbol in filteredData and filteredData[i.Symbol].Volume != 0:
+ filteredData[i.Symbol].Turnover = i.EarningReports.BasicAverageShares.ThreeMonths / filteredData[i.Symbol].Volume
+sortedByROC = sorted(filteredData.values(), key = lambda x: x.ROC.Current.Value, reverse = True)
+topROC = sortedByROC[:int(len(sortedByROC)*0.2)]
+bottomROC = sortedByROC[-int(len(sortedByROC)*0.2):]
+HighTurnoverTopROC = sorted(topROC, key = lambda x: x.Turnover, reverse = True)
+HighTurnoverBottomROC = sorted(bottomROC, key = lambda x: x.Turnover, reverse = True)
+self.long = [i.Symbol for i in HighTurnoverTopROC[:int(len(HighTurnoverTopROC)*0.01)]]
+self.short = [i.Symbol for i in HighTurnoverBottomROC[:int(len(HighTurnoverBottomROC)*0.01)]]
+self.filteredFine = self.long + self.short
+self.portfolios.append(self.filteredFine)
+
+
+
+ A long-short portfolio is held for three months, and then it is rebalanced.
+ Therefore, the investor buys 1/3 of its portfolio for three consecutive months and rebalances 1/3 of its portfolio each month.
+ We save each portfolio in deque list self.portfolios and liquidate the portfolio three-months ago when rebalancing.
+
+
+
+def OnData(self, data):
+ if self.monthly_rebalance and self.filteredFine:
+ self.filteredFine = None
+ self.monthly_rebalance = False
+
+ # 1/3 of the portfolio is rebalanced every month
+ if len(self.portfolios) == self.portfolios.maxlen:
+ for i in list(self.portfolios)[0]:
+ self.Liquidate(i)
+
+ # stocks are equally weighted and held for 3 months
+ short_weight = 1/len(self.short)
+ for i in self.short:
+ self.SetHoldings(i, -1/3*short_weight)
+
+ long_weight = 1/len(self.long)
+ for i in self.long:
+ self.SetHoldings(i, 1/3*long_weight)
+
+
diff --git a/04 Strategy Library/66 Combining Momentum Effect with Volume/03 Algorithm.html b/04 Strategy Library/66 Combining Momentum Effect with Volume/03 Algorithm.html
new file mode 100644
index 0000000..57f98de
--- /dev/null
+++ b/04 Strategy Library/66 Combining Momentum Effect with Volume/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/66 Combining Momentum Effect with Volume/04 Source.html b/04 Strategy Library/66 Combining Momentum Effect with Volume/04 Source.html
new file mode 100644
index 0000000..44c69e4
--- /dev/null
+++ b/04 Strategy Library/66 Combining Momentum Effect with Volume/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/71 Short Term Reversal with Futures/01 Introduction.html b/04 Strategy Library/71 Short Term Reversal with Futures/01 Introduction.html
new file mode 100644
index 0000000..68196fe
--- /dev/null
+++ b/04 Strategy Library/71 Short Term Reversal with Futures/01 Introduction.html
@@ -0,0 +1,6 @@
+
+ The short-term reversal strategy buys stocks which are past losers and sells stocks which are past winners.
+ It is commonly used in the equity market. This algorithm will explore the reversal effect in the futures market.
+ Research also suggests that trading volume contains information about future market movements. The algorithm will
+ be constructed with both the volume and return reversal effect.
+
diff --git a/04 Strategy Library/71 Short Term Reversal with Futures/02 Method.html b/04 Strategy Library/71 Short Term Reversal with Futures/02 Method.html
new file mode 100644
index 0000000..6b0c293
--- /dev/null
+++ b/04 Strategy Library/71 Short Term Reversal with Futures/02 Method.html
@@ -0,0 +1,108 @@
+
+ The daily continuous futures data with the adjusted price is from Quandl.
+ The investment universe consists of 24 types of US futures contracts: 4 currencies, five financial indices, eight agricultural products, and seven commodities.
+ The contracts are all front month contracts.
+
+ The algorithm uses a weekly time frame(Wednesday-Wednesday interval). Therefore the self.Schedule.On() will fire the trading every Wednesday.
+ To compare the weekly change of volume and open interest, we create the deque list with the length to be two to save the history data frame of
+ the most recent week and the week before.
+
+
+
+ def Initialize(self):
+ self.SetStartDate(2017, 7, 10)
+ self.SetEndDate(2018, 8, 1)
+ self.SetCash(10000000)
+
+ self.tickers = ["CME_SF1_EF", "CME_MP1_FF", "CME_CD1_EF", "CME_ED8_FF", # Currencies
+ "CME_NQ1_EF", "CME_MD1_EF", "CME_ES1_EF", "CME_YM1_EF", "CME_NK1_EF", # Financial indices
+ "CME_C1_EF", "CME_SM1_EF", "ICE_CC1_EF", "CME_LC1_EF", # Agricultural product
+ "CME_KW1_EF", "CME_S1_EF", "ICE_KC1_EF", "CME_LC1_EF",
+ "CME_HG1_FF", "CME_GC1_EF", "SHFE_AL1_EF", "SHFE_CU1_EF", # Commodities
+ "CME_CL1_EF", "ICE_T1_FR", "CME_HO1_EF"]
+ self.length = len(self.tickers)
+ for ticker in self.tickers:
+ self.AddData(Futures, ticker)
+ # create the deque list to save the weekly history dataframe
+ self.window = deque(maxlen=2)
+ # rebalance the portfolio every week on Wednesday
+ self.Schedule.On(self.DateRules.Every(DayOfWeek.Wednesday, DayOfWeek.Wednesday), self.TimeRules.At(0, 0), self.WeeklyTrade)
+
+
+
+ In the weekly rebalance function, weekly history data frame is saved. The contract is defined as the high(low) volume contract if the contract's volume changes between the period from t-1 to t and period from t-2 to t-1 is above(below) the median volume change of all contracts,
+ In addition, all contracts are also assigned to either high-open interest (top 50% of changes in open interest) or low-open interest groups (bottom 50% of changes in open interest) based on lagged changes in open interest between the period from t-1 to t and period from t-2 to t-1.
+ We created the method CalculateChange to calculate the increment value and rank the contracts based on the weekly history data frame.
+
+
+
+
+ def WeeklyTrade(self):
+ hist = self.History(self.tickers, self.Time-timedelta(days=7), self.Time,Resolution.Daily)
+ self.window.append(hist)
+ if len(self.window) == self.window.maxlen:
+ hist_t2 = self.window[0] # the weekly history dataframe two week ago
+ hist_t1 = self.window[1] # the weekly history dataframe a week ago
+ top_vol, bottom_vol = self.CalculateChange("volume", hist_t2, hist_t1)
+ top_OI, bottom_OI = self.CalculateChange("open_interest", hist_t2, hist_t1)
+
+
+
+
+
+ def CalculateChange(self, column_name, hist_t2, hist_t1):
+ # calculate the weekly change and sort by the colume value
+ value_t2 = hist_t2[column_name].unstack(level=0).sum(axis=0)
+ value_t1 = hist_t1[column_name].unstack(level=0).sum(axis=0)
+ delta = (value_t1 - value_t2).sort_values(ascending=True)
+ top = list(delta[:int(self.length*0.5)].index)
+ bottom = list(delta[-int(self.length*0.5):].index)
+ return top, bottom
+
+
+
+
+ We take the intersection of the top volume group and bottom open interest group. The trading candidates are selected from this group.
+ Next futures in the intersection are sorted based on the return in the previous week.
+ The algorithm goes long on futures from the high-volume, low-open interest group with the lowest return and shorts the contract with the highest return.
+
+
+
+# the intersection of top volume group and bottom open interest group
+trade_group = list(set(top_vol) & set(bottom_OI))
+returns = {}
+for ticker in trade_group:
+ res = (hist_t1.loc[ticker]["settle"][-1] - hist_t2.loc[ticker]["settle"][-1]) / hist_t2.loc[ticker]["settle"][-1]
+ returns[ticker] = res
+
+sortedByReturn = sorted(returns, key = lambda x: returns[x])
+
+if len(sortedByReturn) >= 2:
+ if self.Portfolio.Invested:
+ self.Liquidate()
+ self.SetHoldings(sortedByReturn[-1], -0.3)
+ self.SetHoldings(sortedByReturn[0], 0.3)
+
+
diff --git a/04 Strategy Library/71 Short Term Reversal with Futures/03 Algorithm.html b/04 Strategy Library/71 Short Term Reversal with Futures/03 Algorithm.html
new file mode 100644
index 0000000..d3f5c48
--- /dev/null
+++ b/04 Strategy Library/71 Short Term Reversal with Futures/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/71 Short Term Reversal with Futures/04 Source.html b/04 Strategy Library/71 Short Term Reversal with Futures/04 Source.html
new file mode 100644
index 0000000..168dc1b
--- /dev/null
+++ b/04 Strategy Library/71 Short Term Reversal with Futures/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/77 Beta Factors in Stocks/01 Introduction.html b/04 Strategy Library/77 Beta Factors in Stocks/01 Introduction.html
new file mode 100644
index 0000000..4b193a4
--- /dev/null
+++ b/04 Strategy Library/77 Beta Factors in Stocks/01 Introduction.html
@@ -0,0 +1,10 @@
+
+ Beta is a statistical measure of a stock's volatility in relation to the market. Stock analysts use this measure to get a sense of stocks' risk profiles.
+ It is also a key component of the capital asset pricing model (CAPM), A stock's price variability is essential to consider when assessing risk. It represents the co-movement instead of the volatility. Therefore, it is possible for a stock to have zero beta and higher volatility than the market.
+
+
+ In the real world, some investors are prohibited from using leverage and other investors’ leverage is limited by margin requirements.
+ Therefore, their only way to achieve higher returns is to buy more risky stocks, which would cause the overvaluation of higher-beta stocks.
+ This behavior suggests that high-beta (risky) stocks should deliver lower risk-adjusted returns than low-beta stocks.
+ In this algorithm, we'll use the leverage to explore the inefficiency of the beta factor.
+
diff --git a/04 Strategy Library/77 Beta Factors in Stocks/02 Method.html b/04 Strategy Library/77 Beta Factors in Stocks/02 Method.html
new file mode 100644
index 0000000..e043cf6
--- /dev/null
+++ b/04 Strategy Library/77 Beta Factors in Stocks/02 Method.html
@@ -0,0 +1,125 @@
+
+ The investment universe consists of all stocks in Nasdaq and NYSE.
+ We use the Wilshire 5000 Total Market Index which covers all stocks actively traded in the United States.
+
+ The formula for calculating beta is the covariance of the return of an asset with the return of the market divided by the variance of the return of the market over a certain period.
+
+\[\beta_i=\frac{cov(R_i,R_{m})}{Var(R_m)}\]
+
+ We choose the 1-year rolling window as the period in the beta calculation. We created the SymbolData class to update the rolling window of return
+ and the calculation of beta.
+
+ In CoarseSelectionFunction, we filter the stocks which price is lower than five as they are not active in the market.
+ When the return rolling window is ready, Stocks are then ranked in ascending order on the basis of their estimated beta.
+ The algorithm goes long on five stocks at the bottom beta list and short on five stocks at the top beta list.
+
+
+
+ def CoarseSelectionFunction(self, coarse):
+
+ if self.Securities["W5000"].Price is not None:
+ self.market_price.append(self.Securities["W5000"].Price)
+ for i in coarse:
+ if i.Symbol not in self.data:
+ self.data[i.Symbol] = SymbolData(i.Symbol)
+ self.data[i.Symbol].Update(i.AdjustedPrice)
+
+ if self.monthly_rebalance:
+ sortedByPrice = [i.Symbol for i in coarse if i.AdjustedPrice>5]
+ ready_data = {symbol: data for symbol, data in self.data.items() if symbol in sortedByPrice and data.IsReady()}
+ if len(ready_data) > 20:
+ self.market_return = np.diff(np.array(self.market_price))/np.array(self.market_price)[:-1]
+ # sort the dictionary in ascending order by beta value
+ sorted_beta = sorted(ready_data, key = lambda x: ready_data[x].beta(self.market_return))
+ self.long = sorted_beta[:5]
+ self.short = sorted_beta[-5:]
+ return self.long+self.short
+ else:
+ self.monthly_rebalance = False
+ return []
+ else:
+ return []
+
+
+
+ In each portfolio, securities are weighted by the ranked betas. Lower-beta stocks have larger weights in the low-beta portfolio and higher-beta
+ stocks have larger weights in the high-beta portfolio. The portfolios are rebalanced every calendar month.
+
+
+
+def OnData(self, data):
+ if not self.monthly_rebalance: return
+ if self.long is None or self.short is None: return
+
+ long_invested = [x.Key for x in self.Portfolio if x.Value.IsLong]
+ short_invested = [x.Key for x in self.Portfolio if x.Value.IsShort]
+
+ for i in long_invested:
+ if i not in self.long:
+ self.Liquidate(i)
+
+ for i in short_invested:
+ if i not in self.short:
+ self.Liquidate(i)
+
+ long_scale_factor = 0.5/sum(range(1,len(self.long)+1))
+ for rank, symbol in enumerate(self.long):
+ self.SetHoldings(symbol, (len(self.long)-rank+1)*long_scale_factor)
+
+ short_scale_factor = 0.5/sum(range(1,len(self.long)+1))
+ for rank, symbol in enumerate(self.short):
+ self.SetHoldings(symbol, -(rank+1)*short_scale_factor)
+
+
+ self.monthly_rebalance = False
+ self.long = None
+ self.short = None
+
+
diff --git a/04 Strategy Library/77 Beta Factors in Stocks/03 Algorithm.html b/04 Strategy Library/77 Beta Factors in Stocks/03 Algorithm.html
new file mode 100644
index 0000000..91f1e5a
--- /dev/null
+++ b/04 Strategy Library/77 Beta Factors in Stocks/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/77 Beta Factors in Stocks/04 Source.html b/04 Strategy Library/77 Beta Factors in Stocks/04 Source.html
new file mode 100644
index 0000000..f65d0bf
--- /dev/null
+++ b/04 Strategy Library/77 Beta Factors in Stocks/04 Source.html
@@ -0,0 +1,5 @@
+
diff --git a/04 Strategy Library/78 Beta Factor in Country Equity Indexes/01 Introduction.html b/04 Strategy Library/78 Beta Factor in Country Equity Indexes/01 Introduction.html
new file mode 100644
index 0000000..6d6f826
--- /dev/null
+++ b/04 Strategy Library/78 Beta Factor in Country Equity Indexes/01 Introduction.html
@@ -0,0 +1,6 @@
+
+ Some investors are prohibited from using leverage and other investors’ leverage is limited by margin requirements.
+ Their only way to achieve higher returns is to buy more risky stocks which makes these assets more expensive.
+ High-beta and risky assets should therefore deliver lower risk-adjusted returns than low-beta assets.
+ Investors could exploit this inefficiency by using ETFs. This algorithm is going to explore this phenomenon.
+
diff --git a/04 Strategy Library/78 Beta Factor in Country Equity Indexes/02 Method.html b/04 Strategy Library/78 Beta Factor in Country Equity Indexes/02 Method.html
new file mode 100644
index 0000000..d2c9c93
--- /dev/null
+++ b/04 Strategy Library/78 Beta Factor in Country Equity Indexes/02 Method.html
@@ -0,0 +1,113 @@
+
+ The implementation of this algorithm uses the alpha framework.
+ The algorithm picks 35 country indexes ETFs as the trading universe. As the symbols in the universe don't change over time,
+ we use the ManualUniverseSelectionModel to subscribe the daily data for those symbols.
+
+
+ Beta is a statistical measure of a stock's volatility in relation to the market.
+ Stock analysts use this measure to get a sense of stocks' risk profiles.
+ The formula for calculating beta is the covariance of the return of an asset with the return of the market divided by the variance of the return of the market over a certain period.
+
+ We use S&P500 ETF as the market measure. The beta for each country is calculated with respect to the SPY using a 1-year rolling window.
+ SymbolData class save the one-year rolling window price data.
+
+ self.assets is a dictionary to save the price series for each country ETF. The key is the ETF symbol.
+ For new symbols added to the algorithm, we request the one-year history data to initialize the price series.
+
+
+
+def OnSecuritiesChanged(self, algorithm, changes):
+ for added in changes.AddedSecurities:
+ if added.Symbol.Value == "SPY":
+ self.market_price = deque(maxlen=253)
+ hist_SPY = algorithm.History(["SPY"], 500, Resolution.Daily)
+ for i in hist_SPY.loc["SPY"].itertuples():
+ self.market_price.append(i.close)
+
+ if added not in self.assets and added.Symbol.Value != "SPY":
+ hist = algorithm.History([added.Symbol.Value], 500, Resolution.Daily)
+ if not hist.empty:
+ self.assets[added.Symbol] = SymbolData(added)
+ for i in hist.loc[added.Symbol.Value].itertuples():
+ self.assets[added.Symbol].Price.append(i.close)
+
+ for removed in changes.RemovedSecurities:
+ self.assets.pop(removed.Symbol)
+
+
+
+ In the Alpha model, Update(self, algorithm, data) method updates this model with the latest data from the algorithm.
+ This method is called each time the algorithm receives data for subscribed securities. In this method, we update the price series with new trade bars.
+ The price series is converted to return series. We plug the market return and the country ETF return into the beta formula.
+ ETFs are then ranked in ascending order by their estimated beta. The ranked ETFs are assigned to one of two portfolios: low beta and high beta.
+ Each portfolio contains a quarter of the total assets.
+
+
+
+def Update(self, algorithm, data):
+ if data.ContainsKey("SPY"):
+ self.market_price.append(float(algorithm.Securities["SPY"].Price))
+ for key, value in self.assets.items():
+ if data.ContainsKey(key):
+ value.Price.append(float(algorithm.Securities[key].Price))
+ insights = []
+ if self.month != algorithm.Time.month:
+ self.month = algorithm.Time.month
+ beta_values = {}
+ market_return = np.diff(np.array(self.market_price))/np.array(self.market_price)[:-1]
+ long = None
+ for key, value in self.assets.items():
+ if key != "SPY" and len(value.Price) == value.Price.maxlen:
+ asset_return = np.diff(np.array(value.Price))/np.array(value.Price)[:-1]
+ beta_values[key] = self.beta(asset_return, market_return)
+ sorted_by_beta = sorted(beta_values, key = lambda x: beta_values[x])
+
+
+
+ The algorithm shorts the high-beta portfolio and longs the low-beta portfolio. Securities are rebalanced every calendar month.
+ PortfolioConstructionModel is set to emit the target weight monthly.
+ The time period of insight is from the current day to the end of the calendar month.
+ In Python calendar library, calendar.monthrange(year, month) returns the number of days in a month for the specified year and month.
+ The insight direction is set to be flat for symbols removed from the long/short list at the end of the month.
+
+
+
+
+long = sorted_by_beta[:int(0.25*len(sorted_by_beta))]
+short = sorted_by_beta[-int(0.25*len(sorted_by_beta)):]
+# day: the weekday of first day of the month
+# num_days: number of days in month
+day, num_days = calendar.monthrange(algorithm.Time.year, algorithm.Time.month)
+insight_period = num_days - algorithm.Time.day - 1
+if long and short:
+ invested = [x.Key for x in algorithm.Portfolio if x.Value.Invested]
+ for i in invested:
+ if algorithm.Portfolio[i].IsLong and i not in long:
+ insights.append(Insight.Price(i, timedelta(days=1), InsightDirection.Flat))
+ if algorithm.Portfolio[i].IsShort and i not in short:
+ insights.append(Insight.Price(i, timedelta(days=1), InsightDirection.Flat))
+ for i in long:
+ insights.append(Insight.Price(i, timedelta(days=insight_period), InsightDirection.Up))
+ for i in short:
+ insights.append(Insight.Price(i, timedelta(days=insight_period), InsightDirection.Down))
+
+
diff --git a/04 Strategy Library/78 Beta Factor in Country Equity Indexes/03 Algorithm.html b/04 Strategy Library/78 Beta Factor in Country Equity Indexes/03 Algorithm.html
new file mode 100644
index 0000000..0447f1a
--- /dev/null
+++ b/04 Strategy Library/78 Beta Factor in Country Equity Indexes/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/78 Beta Factor in Country Equity Indexes/04 Source.html b/04 Strategy Library/78 Beta Factor in Country Equity Indexes/04 Source.html
new file mode 100644
index 0000000..3c11e0b
--- /dev/null
+++ b/04 Strategy Library/78 Beta Factor in Country Equity Indexes/04 Source.html
@@ -0,0 +1,5 @@
+
+ Pre-holiday days on the market are often characterized with lower liquidity as a lot of market participants are not involved in the market or they lower their exposure.
+ Historical research shows that stock prices often behave in a specific manner in each of the two trading days preceding these holidays.
+ This anomaly in equities is often called the pre-holiday effect. It is the market in-efficiency for short-term traders to gain on the final trading day before a holiday.
+ In this algorithm, we'll construct a simple strategy to exploit this pre-holiday effect in the equity market.
+
+ TradingCalendar class can help us find all the available holidays during a period of time.
+ GetDaysByType returns trading days of the specified TradingDayType that contains trading events associated with the range of dates.
+ Here we choose the type to be TradingDayType.PublicHoliday and list all holidays from today to the next two days. As PublicHoliday includes weekends,
+ we use the type TradingDayType.Weekend to subtract weekend holidays.
+
+
+
+ def OnData(self, data):
+ calendar1 = self.TradingCalendar.GetDaysByType(TradingDayType.PublicHoliday, self.Time, self.Time+timedelta(days=2))
+ calendar2 = self.TradingCalendar.GetDaysByType(TradingDayType.Weekend, self.Time, self.Time+timedelta(days=2))
+ holidays = [i.Date for i in calendar1]
+ weekends = [i.Date for i in calendar2]
+ public_holidays = list(set(holidays) - set(weekends))
+
+
+
+ The investment vehicle is SPDR S&P500 ETF. The algorithm will trade the ETF if there are holidays within the next two days and stays in cash during other trading days.
+
+
+
+if not self.Portfolio.Invested and len(holidays)>0:
+ self.SetHoldings("SPY", 1)
+elif self.Portfolio.Invested and len(holidays)==0:
+ self.Liquidate()
+
diff --git a/04 Strategy Library/85 Momentum in Mutual Fund Returns/01 Introduction.html b/04 Strategy Library/85 Momentum in Mutual Fund Returns/01 Introduction.html
new file mode 100644
index 0000000..ec8c6d8
--- /dev/null
+++ b/04 Strategy Library/85 Momentum in Mutual Fund Returns/01 Introduction.html
@@ -0,0 +1,9 @@
+
+ Researchers have shown that the historical returns of a mutual fund and the nearness of its net asset value (NAV) to
+ a previous high can provide significant predictive power about the fund's future returns. In respect to the
+ historical returns, some have attributed the persistence to investor herding and macroeconomic variables. When it
+ comes to the NAV, some suggest the outperformance of funds with a NAV near its trailing high is a result of
+ anchoring bias in investors' psychology. As we do not have access to invest in individual mutual funds on the QC
+ platform or access to NAV metrics, in this tutorial, we trade asset management firms and use their respective share
+ price as a proxy for fund performance and NAV.
+
diff --git a/04 Strategy Library/85 Momentum in Mutual Fund Returns/02 Method.html b/04 Strategy Library/85 Momentum in Mutual Fund Returns/02 Method.html
new file mode 100644
index 0000000..a43b163
--- /dev/null
+++ b/04 Strategy Library/85 Momentum in Mutual Fund Returns/02 Method.html
@@ -0,0 +1,186 @@
+
Universe Selection
+
+ In coarse universe selection, we return symbols that have fundamental data.
+
+
+
+def SelectCoarse(self, algorithm, coarse):
+ if self.month == algorithm.Time.month:
+ return Universe.Unchanged
+
+ return [x.Symbol for x in coarse if x.HasFundamentalData]
+
+
+
+
+ In fine universe selection, we return symbols that Morningstar has classified as being in the asset management industry.
+
+
+
+def SelectFine(self, algorithm, fine):
+ self.month = algorithm.Time.month
+
+ return [f.Symbol for f in fine if f.AssetClassification.MorningstarIndustryCode == MorningstarIndustryCode.AssetManagement]
+
+
+
+
Alpha Construction
+
+ When constructing the alpha model, we can provide parameters for the lookback windows and the percentage of the universe to
+ long/short. Both of these arguments are validated in the constructor. By default, this alpha model uses the trailing 6 months to
+ calculate the rate of change factor and the trailing 12 months to calculate the nearness to historical highs.
+
+
+
+def __init__(self, roc_lookback_months=6, nearness_lookback_months=12, holding_months=6, pct_long_short=10):
+ if roc_lookback_months <= 0 or nearness_lookback_months <= 0 or holding_months <= 0:
+ algorithm.Quit(f"Requirement violated: roc_lookback_months > 0 and nearness_lookback_months > 0 and holding_months > 0")
+
+ if pct_long_short <= 0 or pct_long_short > 50:
+ algorithm.Quit(f"Requirement violated: 0 < pct_long_short <= 50")
+
+ self.roc_lookback_months = roc_lookback_months
+ self.nearness_lookback_months = nearness_lookback_months
+ self.holding_months = holding_months
+ self.pct_long_short = pct_long_short
+
+
+
+
+ For each security added to the universe, we construct a ROCAndNearness indicator which warm up the lookback windows and registers
+ a data consolidator. When a security is removed from the universe, we unsubscribe the associated consolidator.
+
+
+
+def OnSecuritiesChanged(self, algorithm, changes):
+ for added in changes.AddedSecurities:
+ roc_and_nearness = ROCAndNearness(added.Symbol, algorithm, self.roc_lookback_months, self.nearness_lookback_months)
+ self.symbol_data_by_symbol[added.Symbol] = roc_and_nearness
+
+ for removed in changes.RemovedSecurities:
+ symbol_data = self.symbol_data_by_symbol.pop(removed.Symbol, None)
+ if symbol_data:
+ symbol_data.dispose()
+
+
+
+
Alpha Update
+
+ On the first trading day of each month, we rank the symbols in the universe and emit insights for the portfolio construction
+ model. We instruct the alpha model to emit insights on a monthly basis by adding the following guard to the Update method.
+
+
+
+def Update(self, algorithm, data):
+ # Emit insights on a monthly basis
+ time = algorithm.Time
+ if self.month == time.month:
+ return []
+ self.month = time.month
+
+ ...
+
+
+
+
Alpha Ranking
+
+ We only rank symbols that have enough history to fill the rate of change lookback window. Therefore, we define the
+ IsReady method of the ROCAndNearness as
+
+ To rank the symbols, we start by filling a DataFrame with the rate of change and nearness to trailing high values for each
+ symbol. When the DataFrame is full, we rank the symbols by both metrics and sum the ranks. The symbols with a larger final
+ sum have a greater index in the `ranked_symbols` list.
+
+
+
+def Update(self, algorithm, data):
+ ...
+ ranking_df = pd.DataFrame()
+ for symbol, symbol_data in self.symbol_data_by_symbol.items():
+ if data.ContainsKey(symbol) and symbol_data.IsReady:
+ row = pd.DataFrame({'ROC': symbol_data.roc, 'Nearness': symbol_data.nearness}, index=[symbol])
+ ranking_df = ranking_df.append(row)
+ ranked_symbols = ranking_df.rank().sum(axis=1).sort_values().index
+ ...
+
+
+
+
+ Calculating the rate of change and nearness factors is done by slicing the historical data into the approriate lookback window
+ size, and then computing the respective values.
+
+ We return insights that instruct the portfolio construction model to form a balance long-short portfolio. The percentage of the
+ universe we long and short is customizable in the alpha model constructor. Here, we long the 25% of symbols with the highest
+ rank, short the 25% of symbols with the lowest ranks, and instruct the portfolio construction model to hold positions for 6 months.
+
+
+
+def Update(self, algorithm, data):
+ ...
+ insights = []
+ num_long_short = int(len(ranked_symbols) * (self.pct_long_short / 100))
+ if num_long_short > 0:
+ hold_duration = Expiry.EndOfMonth(time) + relativedelta(months=self.holding_months-1, seconds=-1)
+ for symbol in ranked_symbols[-num_long_short:]:
+ insights.append(Insight.Price(symbol, hold_duration, InsightDirection.Up))
+ for symbol in ranked_symbols[:num_long_short]:
+ insights.append(Insight.Price(symbol, hold_duration, InsightDirection.Down))
+ return insights
+
+
+
+
Portfolio Construction
+
+ We utilize a custom portfolio construction model that rebalances monthly and performs allocations based on the net direction of
+ insights for each symbol. A symbol that has two active insights with an up direction will have twice the allocation than a symbol
+ with only one. Furthermore, a symbol that has an up active insight and a down active insight will have no position. We calculate
+ the net direction of the symbols with the following helper method.
+
+
+
+def get_net_direction(self, insights):
+ net_direction_by_symbol = {}
+ num_directional_insights = 0
+
+ for insight in insights:
+ symbol = insight.Symbol
+ direction = insight.Direction
+ if symbol in net_direction_by_symbol:
+ net_direction_by_symbol[symbol] += direction
+ else:
+ net_direction_by_symbol[symbol] = direction
+
+ num_directional_insights += abs(direction)
+
+ return net_direction_by_symbol, num_directional_insights
+
+
+
+
diff --git a/04 Strategy Library/85 Momentum in Mutual Fund Returns/03 Algorithm.html b/04 Strategy Library/85 Momentum in Mutual Fund Returns/03 Algorithm.html
new file mode 100644
index 0000000..93109c0
--- /dev/null
+++ b/04 Strategy Library/85 Momentum in Mutual Fund Returns/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/85 Momentum in Mutual Fund Returns/04 Relative Performance.html b/04 Strategy Library/85 Momentum in Mutual Fund Returns/04 Relative Performance.html
new file mode 100644
index 0000000..26cb3ef
--- /dev/null
+++ b/04 Strategy Library/85 Momentum in Mutual Fund Returns/04 Relative Performance.html
@@ -0,0 +1,81 @@
+
+ To analyze the value of this trading strategy, we compare its performance to buying-and-holding the S&P 500 index
+ ETF, SPY. We can see the results from the table below. The strategy has a lower Sharpe ratio than the SPY for all of
+ the time frames we tested, except for the downfall of the 2020 stock market crash. During this time it greatly
+ outperformed the SPY, achieving a 10.4 Sharpe ratio. We also notice that the strategy generates more consistent
+ returns than the benchmark, documented by the lower annual standard deviation of returns throughout all the testing
+ periods.
+
+ We find the lack of performance for this strategy is not largely attributed to the trading fees. After ignoring the
+ transaction fees, spread costs, and slippage, the strategy still has a lower Sharpe ratio than the benchmark. See
+ the backtest results here.
+
diff --git a/04 Strategy Library/85 Momentum in Mutual Fund Returns/05 Market & Competition Qualification.html b/04 Strategy Library/85 Momentum in Mutual Fund Returns/05 Market & Competition Qualification.html
new file mode 100644
index 0000000..fbc487d
--- /dev/null
+++ b/04 Strategy Library/85 Momentum in Mutual Fund Returns/05 Market & Competition Qualification.html
@@ -0,0 +1,15 @@
+
+ Although this strategy passes several of the
+ metrics required for Alpha Streams and
+ the Quant League competition, it requires further work to meet the following requirements:
+
+
+
+
+
Profitable
+
PSR >= 80%
+
Max drawdown duration <= 6 months
+
Insights contain the following properties: Symbol, Duration, Direction, and Weight
+
Minute or second data resolution
+
Insight Weighting or Equal Weighting Portfolio Construction model
+
\ No newline at end of file
diff --git a/04 Strategy Library/85 Momentum in Mutual Fund Returns/06 Conclusion.html b/04 Strategy Library/85 Momentum in Mutual Fund Returns/06 Conclusion.html
new file mode 100644
index 0000000..763902d
--- /dev/null
+++ b/04 Strategy Library/85 Momentum in Mutual Fund Returns/06 Conclusion.html
@@ -0,0 +1,17 @@
+
+ The momentum pattern examined throughout this tutorial has a greater Sharpe ratio than the SPY during the downfall
+ of the 2020 stock market crash and has more a lower annual standard deviation of returns than the SPY over all the
+ periods we tested. However, we conclude the strategy, which is loosely based on the research of Sapp (2010), does
+ not consistently outperform our benchmark. To continue the development of this strategy, future areas of research
+ include:
+
+
+
+
+
+ Incorporating historical returns and NAV of mutual funds to better-reflect the strategy documented by Saap (2010).
+
+
Adjusting the parameters in the ROCAndNearnessAlphaModel.
+
Performing more filtering and sorting in the AssetManagementUniverseSelection model.
+
Testing other portfolio construction techniques.
+
diff --git a/04 Strategy Library/85 Momentum in Mutual Fund Returns/07 References.html b/04 Strategy Library/85 Momentum in Mutual Fund Returns/07 References.html
new file mode 100644
index 0000000..29e36f1
--- /dev/null
+++ b/04 Strategy Library/85 Momentum in Mutual Fund Returns/07 References.html
@@ -0,0 +1,5 @@
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/91 Momentum and Style Rotation Effect/01 Introduction.html b/04 Strategy Library/91 Momentum and Style Rotation Effect/01 Introduction.html
new file mode 100644
index 0000000..3d2db27
--- /dev/null
+++ b/04 Strategy Library/91 Momentum and Style Rotation Effect/01 Introduction.html
@@ -0,0 +1,5 @@
+
+ Based on the market cap, we can divide the stocks into large-cap, mid-cap and small-cap stocks. In each of those categories, we can subdivide them into value stocks and growth stocks. The growth stocks typically grow revenues faster than the market average and have relatively high P/E ratios and P/B ratios. The value stocks have relatively low P/E ratios and P/B ratios. There are six styles in total.
+ We've demonstrated various momentum strategies to generate excess returns at the firm, industry, and country level.
+ In this algorithm, we'll explore the momentum effect at the style index ETF level.
+
diff --git a/04 Strategy Library/91 Momentum and Style Rotation Effect/02 Method.html b/04 Strategy Library/91 Momentum and Style Rotation Effect/02 Method.html
new file mode 100644
index 0000000..2efbe7b
--- /dev/null
+++ b/04 Strategy Library/91 Momentum and Style Rotation Effect/02 Method.html
@@ -0,0 +1,49 @@
+
+ We choose six index ETFs to represent different equity styles(small-cap value, mid-cap value, large-cap value,
+ small-cap growth, mid-cap growth, large-cap growth). After adding the assets, we save the momentum indicator in
+ the dictionary self.mom for each style. The formation period of 12-month is used to gauge the value of momentum.
+
+
+
+def Initialize(self):
+
+ self.SetStartDate(2001, 1, 1)
+ self.SetEndDate(2018, 8, 1)
+ self.SetCash(100000)
+
+ tickers = ["IJJ", # iShares S&P Mid-Cap 400 Value Index ETF
+ "IJK", # iShares S&P Mid-Cap 400 Growth ETF
+ "IJS", # iShares S&P Small-Cap 600 Value ETF
+ "IJT", # iShares S&P Small-Cap 600 Growth ETF
+ "IVE", # iShares S&P 500 Value Index ETF
+ "IVW"] # iShares S&P 500 Growth ETF
+
+ lookback = 12*20
+
+ # Save all momentum indicator into the dictionary
+ self.mom = dict()
+ for ticker in tickers:
+ symbol = self.AddEquity(ticker, Resolution.Daily).Symbol
+ self.mom[symbol] = self.MOM(symbol, lookback)
+
+
+
+ Six ETFs are ranked based on their prior 12-month performance in the formation period. The algorithm
+ goes long the top performing ETF and short the ETF at the bottom and holds the position for one month.
+ The portfolio is rebalanced at the start of next month.
+
+
+
+def Rebalance(self):
+ # Order the MOM dictionary by value
+ sorted_mom = sorted(self.mom, key = lambda x: self.mom[x].Current.Value)
+
+ # Liquidate the ETFs that are no longer selected
+ for symbol in sorted_mom[1:-1]:
+ if self.Portfolio[symbol].Invested:
+ self.Liquidate(symbol, 'No longer selected')
+
+ self.SetHoldings(sorted_mom[-1], -0.5) # Short the ETF with lowest MOM
+ self.SetHoldings(sorted_mom[0], 0.5) # Long the ETF with highest MOM
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/91 Momentum and Style Rotation Effect/03 Algorithm.html b/04 Strategy Library/91 Momentum and Style Rotation Effect/03 Algorithm.html
new file mode 100644
index 0000000..ae7ab5e
--- /dev/null
+++ b/04 Strategy Library/91 Momentum and Style Rotation Effect/03 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/04 Strategy Library/91 Momentum and Style Rotation Effect/04 Source.html b/04 Strategy Library/91 Momentum and Style Rotation Effect/04 Source.html
new file mode 100644
index 0000000..d09e0bf
--- /dev/null
+++ b/04 Strategy Library/91 Momentum and Style Rotation Effect/04 Source.html
@@ -0,0 +1,5 @@
+
+The Price to Earnings ratio, also known as the P/E ratio, is the ratio of a company's
+market price per share to the company's earnings per share.
+
+
+ \[Price \ to \ Earnings\ Ratio=\frac{Market \ price \ per \ share}{Earnings \ per \ share \ from \ the \ most \ recent \ financial \ year}\]
+
+
+The P/E ratio is often used by investors to determine the valuation of a company's stock. Research suggests that a portfolio that consists of stocks with relatively low P/E
+ratio outperforms a portfolio that consists of stocks with relatively high P/E ratio.
+
+We pick the 10 stocks that have the lowest P/E ratio in our universe, at the beginning of each year,
+and we invest an equal amount of capital in each stock.
+
+
+
+To construct the universe, first, we eliminate stocks which don't have fundamental data and
+stocks that have a lower price than $5 per share, using the CoarseSelectionFunction.
+
+
+
+
+ def CoarseSelectionFunction(self, coarse):
+
+ if self.Time.year == self.year:
+ return self.symbols
+
+ # drop stocks which have no fundamental data or have low price
+ CoarseWithFundamental = [x for x in coarse if x.HasFundamentalData and x.Price > 5]
+ sortedByDollarVolume = sorted(CoarseWithFundamental, key=lambda x: x.DollarVolume, reverse=False)
+
+ return [i.Symbol for i in sortedByDollarVolume[:self._NumCoarseStocks]]
+
+
+
+
+Then, in the FineSelectionFunction, we retrieve the list of 10 stocks, that have the lowest P/E ratio.
+
+
+
+
+
+ def FineSelectionFunction(self, fine):
+
+ if self.Time.year == self.year:
+ return self.symbols
+
+ self.year = self.Time.year
+
+ fine = [x for x in fine if x.ValuationRatios.PERatio > 0]
+ sortedPERatio = sorted(fine, key=lambda x: x.ValuationRatios.PERatio)
+
+ self.symbols = [i.Symbol for i in sortedPERatio[:self._NumStocksInPortfolio]]
+
+ return self.symbols
+
+
+
+
+In OnData(), we buy the 10 stocks that have the lowest P/E ratio in our universe. We rebalance the portfolio at the beginning of each year.
+
+The portfolio significantly outperforms the benchmark, S&P 500, during the three and half years backtest period, from the beginning of the year 2016 to July of the year 2019.
+
+
+The universe of stocks is filtered using dollar volume and price criteria. Most of the stocks chosen by the algorithm during the backtest period are small market capitalization stocks.
+
+
+In theory, there is an additional factor, to the small P/E ratio factor, contributing to the excess returns of the portfolio, relative to the benchmark. This additional factor is known as the size factor, where size in this respect, is the market capitalization of a stock.
+
+
+Ranking portfolios on market capitalization and subsequently tracking their performance has demonstrated that portfolio of stocks with a small market capitalization outperforms a portfolio of stocks with large market capitalization. Another investment strategy in the strategy library, Small Market Capitalization Stock Premium, demonstrates how to form a portfolio that only consists of stocks with relatively low market capitalization.
+
+ Persson E, Ståhlberg C (2006). P/E and EV/EBITDA Investment Strategies vs. the Market (Master's thesis, Linköping University, Linköping, Sweden). Online Copy
+
+
+
+ Fama, Eugene F. and French, Kenneth R., Multifactor Explanations of Asset Pricing Anomalies. J. OF FINANCE, Vol. 51 No. 1, March 1996. Available at SSRN: https://ssrn.com/abstract=7365
+
+ This tutorial provides a basic introduction to the Python programming language. If you are new to Python, you should run the code snippets while reading this tutorial. If you are an advanced Python user, please feel free to skip this chapter.
+
diff --git a/05 Introduction to Financial Python[]/01 Data Types and Data Structures/02 Basic Variable Types.html b/05 Introduction to Financial Python[]/01 Data Types and Data Structures/02 Basic Variable Types.html
new file mode 100755
index 0000000..1f3b20b
--- /dev/null
+++ b/05 Introduction to Financial Python[]/01 Data Types and Data Structures/02 Basic Variable Types.html
@@ -0,0 +1,69 @@
+
+The basic types of variables in Python are: strings, integers, floating point numbers and booleans.
+
+
+ Strings in python are identified as a contiguous set of characters represented in either single quotes (' ') or double quotes (" ").
+
+ An integer is a round number with no values after the decimal point.
+
+
+
my_int = 10
+print(my_int)
+[out]: 10
+print(type(my_int))
+[out]: type 'int'
+
+
+
+ The built-in function int() can convert a string into an integer.
+
+
+
my_string = "100"
+print(type(my_string))
+[out]: type 'str'
+my_int = int(my_string)
+print(type(my_int))
+[out]: type 'int'
+
+
+
+ A floating point number, or a float, is a real number in mathematics. In Python we need to include a value after a decimal point to define it as a float.
+
+
+
my_float = 1.0
+print(type(my_float))
+[out]: type 'float'
+my_int = 1
+print(type(my_int))
+[out]: type 'int'
+
+
+
+ As you can see above, if we don't include a decimal value, the variable would be defined as an integer. The built-in function float() can convert a string or an integer into a float.
+
+ A boolean, or bool, is a binary variable. Its value can only be True or False. It is useful when we do some logic operations, which would be covered in our next chapter.
+
diff --git a/05 Introduction to Financial Python[]/01 Data Types and Data Structures/03 Basic Math Operations.html b/05 Introduction to Financial Python[]/01 Data Types and Data Structures/03 Basic Math Operations.html
new file mode 100755
index 0000000..997b322
--- /dev/null
+++ b/05 Introduction to Financial Python[]/01 Data Types and Data Structures/03 Basic Math Operations.html
@@ -0,0 +1,19 @@
+
+ The basic math operators in python are demonstrated below:
+
diff --git a/05 Introduction to Financial Python[]/01 Data Types and Data Structures/04 Data Collections.html b/05 Introduction to Financial Python[]/01 Data Types and Data Structures/04 Data Collections.html
new file mode 100755
index 0000000..12a2744
--- /dev/null
+++ b/05 Introduction to Financial Python[]/01 Data Types and Data Structures/04 Data Collections.html
@@ -0,0 +1,141 @@
+
List
+
+A list is an ordered collection of values. A list is mutable, which means you can change a list's value without changing the list itself. Creating a list is simply putting different comma-separated values between square brackets.
+
+ The values in a list are called "elements". We can access list elements by indexing. Python index starts from 0. So if you have a list of length n, the index of the first element will be 0, and that of the last element will be n − 1. By the way, the length of a list can be obtained by the built-in function len().
+
+ The slice starts from the first element indicated, but excludes the last element indicated. Here we select all elements starting from index 1, which refers to the second element:
+
+ When there are repeated instances of "Hello", the first one is removed.
+
+
Tuple
+
+ A tuple is a data structure type similar to a list. The difference is that a tuple is immutable, which means you can't change the elements in it once it's defined. We create a tuple by putting comma-separated values between parentheses.
+
+
+
my_tuple = ('Welcome','to','QuantConnect')
+
+
+
+ Just like a list, a tuple can be sliced by using index.
+
+ Set is an easy way to remove duplicate elements from a list.
+
+
Dictionary
+
+ A dictionary is one of the most important data structures in Python. Unlike sequences which are indexed by integers, dictionaries are indexed by keys which can be either strings or floats.
+
+
+ A dictionary is an unordered collection of key : value pairs, with the requirement that the keys are unique. We create a dictionary by placing a comma-separated list of key : value pairs within the braces.
+
diff --git a/05 Introduction to Financial Python[]/01 Data Types and Data Structures/05 Common String Operations.html b/05 Introduction to Financial Python[]/01 Data Types and Data Structures/05 Common String Operations.html
new file mode 100755
index 0000000..0c25160
--- /dev/null
+++ b/05 Introduction to Financial Python[]/01 Data Types and Data Structures/05 Common String Operations.html
@@ -0,0 +1,59 @@
+
+A string is an immutable sequence of characters. It can be sliced by index just like a tuple:
+
+
+
my_str = 'Welcome to QuantConnect'
+print(my_str[8:])
+[out]: to QuantConnect
+
+
+
+ There are many methods associated with strings. We can use string.count() to count the occurrences of a character in a string, use string.find() to return the index of a specific character, and use string.replace() to replace characters.
+
+
+
+print("Counting the number of e's in this sentence".count('e'))
+[out]: 6
+print('The first time e appears in this sentence'.find('e'))
+[out]: 2
+print('all the a in this sentence now becomes e'.replace('a','e'))
+[out]: ell the e in this sentence now becomes e
+
+
+
+ The most commonly used method for strings is string.split(). This method will split the string by the indicated character and return a list:
+
+ Another way to format a string is to use the % symbol.
+
+
+
print 'pi is %f' % 3.14
+[out]: pi is 3.140000
+print('%s to %s' % ('Welcome', 'QuantConnect'))
+[out]: Welcome to QuantConnect
+
+
+
+ %s is a placeholder that takes in a string. Similarly %f takes a float and %d takes an integer.
+
diff --git a/05 Introduction to Financial Python[]/01 Data Types and Data Structures/06 Summary.html b/05 Introduction to Financial Python[]/01 Data Types and Data Structures/06 Summary.html
new file mode 100755
index 0000000..3bdfaa1
--- /dev/null
+++ b/05 Introduction to Financial Python[]/01 Data Types and Data Structures/06 Summary.html
@@ -0,0 +1,3 @@
+
+ We have seen the basic data types and data structures in Python. It's important to keep practicing to become familiar with these data structures. In the next tutorial, we will cover for and while loops and logical operations in Python.
+
diff --git a/05 Introduction to Financial Python[]/02 Logical Operations and Loops/01 Introduction.html b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/01 Introduction.html
new file mode 100755
index 0000000..e3e2862
--- /dev/null
+++ b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ We discussed the basic data types and data structures in Python in the last tutorial. This chapter covers logical operations and loops in Python, which are very common in programming.
+
diff --git a/Tutorial Series/Introduction to Financial Python/.ipynb_checkpoints/Tutorial02 Logical Operations and Loops-checkpoint.ipynb b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/02 Logical Operations and Loops.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Financial Python/.ipynb_checkpoints/Tutorial02 Logical Operations and Loops-checkpoint.ipynb
rename to 05 Introduction to Financial Python[]/02 Logical Operations and Loops/02 Logical Operations and Loops.ipynb
diff --git a/05 Introduction to Financial Python[]/02 Logical Operations and Loops/02 Logical Operations.html b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/02 Logical Operations.html
new file mode 100755
index 0000000..983c12f
--- /dev/null
+++ b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/02 Logical Operations.html
@@ -0,0 +1,62 @@
+
+ Like most programming languages, Python has comparison operators:
+
+
+
+
print 1 == 0 # 1 equals 0
+print 1 == 1 # 1 equals 1
+print 1 != 0 # 1 is not equal to 0
+print 5 >= 5 # 5 is greater than or equal to 5
+print 5 >= 6 # 5 is greater than or equal to 6
+[out]:
+False
+True
+True
+True
+False
+
+
+
+
+ Each statement above has a boolean value, which must be either True or False, but not both.
+
+
+ We can combine simple statements P and Q to form complex statements using logical operators:
+
+
+
The statement "P and Q" is true if both P and Q are true, otherwise it is false.
+
The statement "P or Q" is false if both P and Q are false, otherwise it is true.
+
The statement "not P" is true if P is false, and vice versa.
+
+
+
+
+
print 2 > 1 and 3 > 2
+print 2 > 1 and 3 < 2
+print 2 > 1 or 3 < 2
+print 2 < 1 and 3 < 2
+[out]:
+True
+False
+True
+False
+
+
+
+
+ When dealing with a very complex logical statement that involves in several statements, we can use brackets to separate and combine them.
+
+
+
+
+
print (3 > 2 or 1 < 3) and (1!=3 and 4>3) and not ( 3 < 2 or 1 < 3 and (1!=3 and 4>3))
+print 3 > 2 or 1 < 3 and (1!=3 and 4>3) and not ( 3 < 2 or 1 < 3 and (1!=3 and 4>3))
+[out]:
+False
+True
+
+
+
+
+ Comparing the above two statements, we can see that it's wise to use brackets when we make a complex logical statement.
+
diff --git a/05 Introduction to Financial Python[]/02 Logical Operations and Loops/03 If Statement.html b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/03 If Statement.html
new file mode 100755
index 0000000..98c8f4e
--- /dev/null
+++ b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/03 If Statement.html
@@ -0,0 +1,51 @@
+
+ An if statement executes a segment of code only if its condition is true. A standard if statement consists of 3 segments: if, elif and else.
+
+
+
+
+
+
if condition1:
+ # if condition1 is true, execute the code here
+ # and ignore the rest of this if statement
+elif condition2:
+ # if condition1 is false, and condition2 is true, execute the code here
+ # and ignore the rest of this if statement
+else:
+ # if none of the above conditions is True, execute the code here
+
+
+
+
+ An if statement doesn't necessarily has elif and else part. If it's not specified, the indented block of code will be executed when the condition is true, otherwise the whole if statement will be skipped.
+
+
+
+
+
+
i = 0
+if i == 0: print 'i == 0 is True'
+[out]: i==0 is True
+
+
+
+
+ As we mentioned above, we can write some complex statements here:
+
+
+
+
+
+
p = 1 > 0
+q = 2 > 3
+if p and q:
+ print 'p and q is true'
+elif p and not q:
+ print 'q is false'
+elif q and not p:
+ print 'p is false'
+else:
+ print 'None of p and q is true'
+[out]: q is false
+
+
diff --git a/05 Introduction to Financial Python[]/02 Logical Operations and Loops/04 Loop Structure.html b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/04 Loop Structure.html
new file mode 100755
index 0000000..fe5b599
--- /dev/null
+++ b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/04 Loop Structure.html
@@ -0,0 +1,113 @@
+
+ Loops are an essential part of programming. The "for" and "while" loops run a block of code repeatedly.
+
+
+
While Loop
+
+
+ A "while" loop will run repeatedly until a certain condition has been met.
+
+
+
+
+
+
i = 0
+while i < 5:
+ print i
+ i += 1
+[out]:
+0
+1
+2
+3
+4
+
+
+
+
+ When making a while loop, we need to ensure that something changes from iteration to iteration so that the while loop will terminate, otherwise, it will run forever. Here we used i += 1 (short for i = i + 1) to make i larger after each iteration. This is the most commonly used method to control a while loop.
+
+
+
For Loop
+
+
+ A "for" loop will iterate over a sequence of value and terminate when the sequence has ended.
+
+
+
+
+
+
for x in [1,2,3,4,5]: print x
+[out]:
+1
+2
+3
+4
+5
+
+
+
+
+ We can also add if statements in a for loop. Here is a real example from our pairs trading algorithm:
+
+
+
+
+
+
stocks = ['AAPL','GOOG','IBM','FB','F','V', 'G', 'GE']
+selected = ['AAPL','IBM']
+new_list = []
+for stock in stocks:
+ if stock not in selected:
+ new_list.append(stock)
+print new_list
+[out]: ['GOOG', 'FB', 'F', 'V', 'G', 'GE']
+
+
+
+
+ Here we iterated all the elements in the list 'stocks'. Later in this chapter, we will introduce a smarter way to do this, which is just a one-line code.
+
+
+
Break and continue
+
+
+ These are two commonly used commands in a for loop. If "break" is triggered while a loop is executing, the loop will terminate immediately:
+
diff --git a/05 Introduction to Financial Python[]/02 Logical Operations and Loops/05 List Comprehension.html b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/05 List Comprehension.html
new file mode 100755
index 0000000..72537b0
--- /dev/null
+++ b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/05 List Comprehension.html
@@ -0,0 +1,63 @@
+
+ List comprehension is a Pythonic way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence. For example, if we want to create a list of squares using for loop:
+
+
+
+
+
+
squares = []
+for i in [1,2,3,4,5]:
+ squares.append(i**2)
+print squares
+[out]: [1, 4, 9, 16, 25]
+
+
+
+
+ Using list comprehension:
+
+
+
+
+
+
foo = [1,2,3,4,5]
+squares = [x**2 for x in foo]
+print squares
+[out]: [1, 4, 9, 16, 25]
+
+
+
+
+ Recall the example above where we used a for loop to select stocks. Here we use list comprehension:
+
+
+
+
+
+
stocks = ['AAPL','GOOG','IBM','FB','F','V', 'G', 'GE']
+selected = ['AAPL','IBM']
+new_list = [x for x in stocks if x not in selected]
+print new_list
+[out]: ['GOOG', 'FB', 'F', 'V', 'G', 'GE']
+
+
+
+
+ A list comprehension consists of square brackets containing an expression followed by a "for" clause, and possibly "for" or "if" clauses. For example:
+
+
+
+
+
+
print [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
+print [str(x) + ' vs ' + str(y) for x in ['AAPL','GOOG','IBM','FB']
+ for y in ['F','V','G','GE'] if x != y]
+[out]:
+[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
+['AAPL vs F', 'AAPL vs V', 'AAPL vs G', 'AAPL vs GE', 'GOOG vs F', 'GOOG vs V', 'GOOG vs G', 'GOOG vs GE', 'IBM vs F', 'IBM vs V', 'IBM vs G', 'IBM vs GE', 'FB vs F', 'FB vs V', 'FB vs G', 'FB vs GE']
+
+
+
+
+ List comprehension is an elegant way to organize one or more for loops when creating a list.
+
diff --git a/05 Introduction to Financial Python[]/02 Logical Operations and Loops/06 Summary.html b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/06 Summary.html
new file mode 100755
index 0000000..cb27d18
--- /dev/null
+++ b/05 Introduction to Financial Python[]/02 Logical Operations and Loops/06 Summary.html
@@ -0,0 +1,3 @@
+
+ This chapter has introduced logical operations, loops, and list comprehension. In the next chapter, we will introduce functions and object-oriented programming, which will enable us to make our codes clean and versatile.
+
diff --git a/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/01 Introduction.html b/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/01 Introduction.html
new file mode 100755
index 0000000..4bd9a07
--- /dev/null
+++ b/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ In the last tutorial we introduced logical operations, loops and list comprehension. We will introduce functions and object-oriented programming in this chapter, which will enable us to build complex algorithms in more flexible ways.
+
diff --git a/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/02 Functions.html b/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/02 Functions.html
new file mode 100755
index 0000000..dc8cd02
--- /dev/null
+++ b/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/02 Functions.html
@@ -0,0 +1,27 @@
+
+ A function is a reusable block of code. We can use a function to output a value, or do anything else we want. We can easily define our own function by using the keyword "def".
+
+ The keyword "def" is followed by the function name and the parenthesized list of formal parameters. The statements that form the body of the function start at the next line, and must be indented. The product() function above has "x" and "y" as its parameters. A function doesn't necessarily have parameters:
+
+
+
+
+
def say_hi():
+ print "Welcome to QuantConnect'
+say_hi()
+[out]: Welcome to QuantConnect
+
+
diff --git a/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/03 Built-in Function.html b/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/03 Built-in Function.html
new file mode 100755
index 0000000..69758bf
--- /dev/null
+++ b/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/03 Built-in Function.html
@@ -0,0 +1,115 @@
+
+ range() is a function that creates a list containing an arithmetic sequence. It's often used in for loops. The arguments must be integers. If the "step" argument is omitted, it defaults to 1.
+
+ len() is another function used together with range() to create a for loop. This function returns the length of an object. The argument must be a sequence or a collection.
+
+
+
+
+
+tickers = ['AAPL', 'GOOGL', 'IBM', 'FB', 'F', 'V', 'G', 'GE']
+print "The number of tickers is {}".format(len(tickers))
+for k in range(len(tickers)):
+ print k + 1, tickers[k]
+[out]:
+The number of tickers is 8
+1 AAPL
+2 GOOGL
+3 IBM
+4 FB
+5 F
+6 V
+7 G
+8 GE
+
+
+
+ Note: If you want to print only the tickers without those numbers, then simply write "for ticker in tickers: print ticker"
+
+
+map() is a function that applies a specific function to every item of a sequence or collection, and returns a list of the results.
+
+ Python is an object-oriented programming language. It's important to understand the concept of "objects" because almost every kind of data from QuantConnect API is an object.
+
+
+
Class
+
+ A class is a type of data, just like a string, float, or list. When we create an object of that data type, we call it an instance of a class.
+
+
+
+ In Python, everything is an object - everything is an instance of some class. The data stored inside an object are called attributes, and the functions which are associated with the object are called methods.
+
+
+
+ For example, as mentioned above, a list is an object of the "list" class, and it has a method list.sort().
+
+
+
+ We can create our own objects by defining a class. We would do this when it's helpful to group certain functions together. For example, we define a class named "Stock" here:
+
+ The "Stock" class has attributes "ticker", "open", "close", "volume" and "rate_return". Inside the class body, the first method is called __init__, which is a special method. When we create a new instance of the class, the __init__ method is immediately executed with all the parameters that we pass to the "Stock" object. The purpose of this method is to set up a new "Stock" object using data we have provided.
+
+
+
+ Here we create two Stock objects named "apple" and "google".
+
+ By calling the update() function, we updated the open and close prices of a stock. Please note that when we use the attributes or call the methods inside a class, we need to specify them as self.attribute or self.method(), otherwise Python will deem them as global variables and thus raise an error.
+
+
+
+ We can add an attribute to an object anywhere:
+
+ Inheritance is a way of arranging classes in a hierarchy from the most general to the most specific. A "child" class is a more specific type of a "parent" class because a child class will inherit all the attribues and methods of its parent. For example, we define a class named "Child" which inherits "Stock":
+
+
+
+
+
class Child(Stock):
+ def __init__(self, name):
+ self.name = name
+
+As seen above, the new class Child has inherited the methods from Stock.
diff --git a/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/05 Summary.html b/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/05 Summary.html
new file mode 100755
index 0000000..03fd971
--- /dev/null
+++ b/05 Introduction to Financial Python[]/03 Functions and Objective-Oriented Programming/05 Summary.html
@@ -0,0 +1,7 @@
+
+ In this chapter we have introduced functions and classes. When we write a QuantConnect algorithm, we would define our algorithm as a class (QCAlgorithm). This means our algorithm inherited the QC API methods from QCAlgorithm class.
+
+
+
+ In the next chapter, we will introduce NumPy and Pandas, which enable us to conduct scientific calculations in Python.
+
diff --git a/05 Introduction to Financial Python[]/04 NumPy and Basic Pandas/01 Introduction.html b/05 Introduction to Financial Python[]/04 NumPy and Basic Pandas/01 Introduction.html
new file mode 100755
index 0000000..3a2904f
--- /dev/null
+++ b/05 Introduction to Financial Python[]/04 NumPy and Basic Pandas/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ Now that we have introduced the fundamentals of Python, it's time to learn about NumPy and Pandas.
+
diff --git a/05 Introduction to Financial Python[]/04 NumPy and Basic Pandas/02 NumPy.html b/05 Introduction to Financial Python[]/04 NumPy and Basic Pandas/02 NumPy.html
new file mode 100755
index 0000000..3388671
--- /dev/null
+++ b/05 Introduction to Financial Python[]/04 NumPy and Basic Pandas/02 NumPy.html
@@ -0,0 +1,102 @@
+
+ NumPy is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays. It also has strong integration with Pandas, which is another powerful tool for manipulating financial data.
+
+
+ Python packages like NumPy and Pandas contain classes and methods which we can use by importing the package:
+
+
+
+
import numpy as np
+
+
+
Basic NumPy Arrays
+
+
+ A NumPy array is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. Here we make an array by passing a list of Apple stock prices:
+
+ Notice that the type of array is "ndarray" which is a multi-dimensional array. If we pass np.array() a list of lists, it will create a 2-dimensional array.
+
+ If we want to access the matrix by column instead:
+
+
+
+
print 'First column:', Ar[:,0]
+[out]: First column: [1 2]
+print 'Second column:', Ar[:,1]
+[out]: Second column: [3 4]
+
+
+
Array Functions
+
+
+ Some functions built in NumPy that allow us to perform calculations on arrays. For example, we can apply the natural logarithm to each element of an array:
+
+ Series are usually accessed using the iloc[] and loc[] methods. iloc[] is used to access elements by integer index, and loc[] is used to access the index of the series.
+
+
+
+ iloc[] is necessary when the index of a series are integers, take our previous defined series as example:
+
+ If we intended to take the second element of the series, we would make a mistake here, because the index are integers. In order to access to the element we want, we use iloc[] here:
+
+
+
+
+
print s.iloc[1]
+[out]: 145.83
+
+
+
+
+ While working with time series data, we often use time as the index. Pandas provides us with various methods to access the data by time index.
+
+ Here we have introduced NumPy and Pandas for scientific computing in Python. In the next chapter, we will dive into Pandas to learn resampling and manipulating Pandas DataFrame, which are commonly used in financial data analysis.
+
diff --git a/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/01 Introduction.html b/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/01 Introduction.html
new file mode 100755
index 0000000..b99780b
--- /dev/null
+++ b/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ In the last chapter we had a glimpse of Pandas. In this chapter we will learn about resampling methods and the DataFrame object, which is a powerful tool for financial data analysis.
+
diff --git a/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/02 Fetching Data.html b/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/02 Fetching Data.html
new file mode 100755
index 0000000..181f0fc
--- /dev/null
+++ b/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/02 Fetching Data.html
@@ -0,0 +1,98 @@
+
+ Here we use the Quandl API to retrieve data...
+
diff --git a/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/03 Resampling.html b/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/03 Resampling.html
new file mode 100755
index 0000000..dc555b3
--- /dev/null
+++ b/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/03 Resampling.html
@@ -0,0 +1,218 @@
+
+ series.resample(freq) is a class called "DatetimeIndexResampler" which groups data in a Series object into regular time intervals. The argument "freq" determines the length of each interval.
+
+
+ series.resample.mean() is a complete statement that groups data into intervals, and then compute the mean of each interval. For example, if we want to aggregate the daily data into monthly data by mean:
+
+ Besides the mean() method, other methods can also be used with the resampler:
+
+
+
+
+
std = aapl.resample('W').std() # standard deviation
+max = aapl.resample('W').max() # maximum value
+min = aapl.resample('W').min() # minimum value
+
+
+
+
+ Often we want to calculate monthly returns of a stock, based on prices on the last day of each month. To fetch those prices, we use the series.resample.agg() method:
+
+ Another two methods frequently used on Series are .diff() and .pct_change(). The former calculates the difference between consecutive elements, and the latter calculates the percentage change.
+
+ As expected, since there is a 'backward fill' method, there must be a 'forward fill' method, or 'ffill' in short. However we can't use it here because the NaN is the first value.
+
+
+
+ We can also simply remove NaN values by .dropna()
+
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial05 Pandas-Resampling and DataFrame.html b/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/04 DataFrame.html
old mode 100644
new mode 100755
similarity index 53%
rename from Tutorial Series/Introduction to Financial Python/Tutorial05 Pandas-Resampling and DataFrame.html
rename to 05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/04 DataFrame.html
index 7805251..1a716b7
--- a/Tutorial Series/Introduction to Financial Python/Tutorial05 Pandas-Resampling and DataFrame.html
+++ b/05 Introduction to Financial Python[]/05 Pandas-Resampling and DataFrame/04 DataFrame.html
@@ -1,247 +1,44 @@
-In the last chapter we had a glimpse of Pandas. In this chapter we will learn about resampling methods and the DataFrame object, which is a powerful tool for financial data analysis.
-
-Here we use data from the yahoo_finance API.
-
-
-Recall that we can fetch a specific data point using series['yyyy-mm-dd']. We can also fetch the data in a specific month using series['yyyy-mm'].
-
-
-series.resample(freq) is a class called "DatetimeIndexResampler" which groups data in a Series object into regular time intervals. The argument "freq" determines the length of each interval.
-
-series.resample.mean() is a complete statement that groups data into intervals, and then compute the mean of each interval. For example, if we want to aggregate the daily data into monthly data by mean:
-
-
-Besides the mean() method, other methods can also be used with the resampler:
-
std = aapl.resample('W').std() # standard deviation
-max = aapl.resample('W').max() # maximum value
-min = aapl.resample('W').min() # minimum value
-
-OFten we want to calculate monthly returns of a stock, based on prices on the last day of each month. To fetch those prices, we use the series.resample.agg() method:
-
-
-Another two methods frequently used on Series are .diff() and .pct_change(). The former calculates the difference between consecutive elements, and the latter calculates the percentage change.
-
-
-Notice that we induced a NaN value while calculating percentage changes i.e. returns.
-
-When dealing with NaN values, we usually either removing the data point or fill it with a specific value. Here we fill it with 0:
-
-
-As expected, since there is a 'backward fill' method, there must be a 'forward fill' method, or 'ffill' in short. However we can't use it here because the NaN is the first value.
-
-We can also simply remove NaN values by .dropna()
-
-
-The DataFrame is the most commonly used data structure in Pandas. It is essentially a table, just like an Excel spreadsheet.
-
-More precisely, a DataFrame is a collection of Series objects, each of which may contain different data types. A DataFrame can be created from various data types: dictionary, 2-D numpy.ndarray, a Series or another DataFrame.
-
-
Create DataFrames
-
-The most common method of creating a DataFrame is passing a dictionary:
-
+ The DataFrame is the most commonly used data structure in Pandas. It is essentially a table, just like an Excel spreadsheet.
+
+
+ More precisely, a DataFrame is a collection of Series objects, each of which may contain different data types. A DataFrame can be created from various data types: dictionary, 2-D numpy.ndarray, a Series or another DataFrame.
+
+
Create DataFrames
+
+ The most common method of creating a DataFrame is passing a dictionary:
+
+ We can fetch values in a DataFrame by columns and index. Each column in a DataFrame is essentially a Pandas Series. We can fetch a column by square brackets: df['column_name']
+
+
+ If a column name contains no spaces, then we can also use df.column_name to fetch a column:
+
-We can fetch values in a DataFrame by columns and index. Each column in a DataFrame is essentially a Pandas Series. We can fetch a column by square brackets: df['column_name']
+
-If a column name contains no spaces, then we can also use df.column_name to fetch a column:
-
-Here the calculation introduced a NaN value. If the DataFrame is large, we would not be able to observe it. isnull() provides a convenient way to check abnormal values.
-
missing = aapl_bar.isnull()
+
+ Here the calculation introduced a NaN value. If the DataFrame is large, we would not be able to observe it. isnull() provides a convenient way to check abnormal values.
+
-The row labelled "unique" indicates the number of unique values in each column. Since the "rate_return" column has 2 unique values, it has at least one missing value.
+
+ The row labelled "unique" indicates the number of unique values in each column. Since the "rate_return" column has 2 unique values, it has at least one missing value.
+
+
+ We can deduce the number of missing values by comparing "count" with "freq". There are 12 counts and 11 False values, so there is one True value which corresponds to the missing value.
+
+
+ We can also find the rows with missing values easily:
+
-We can deduce the number of missing values by comparing "count" with "freq". There are 12 counts and 11 False values, so there is one True value which corresponds to the missing value.
+
-We can also find the rows with missing values easily:
-
print missing[missing.rate_return == True]
+
print missing[missing.rate_return == True]
Open High Low Close rate_return
Date
-2016-01-31 False False False False True
+2016-01-31 False False False False True
+
+
+
+
+ Usually when dealing with missing data, we either delete the whole row or fill it with some value. As we introduced in the Series chapter, the same method dropna() and fillna() can be applied to a DataFrame.
+
-Usually when dealing with missing data, we either delete the whole row or fill it with some value. As we introduced in the Series chapter, the same method dropna() and fillna() can be applied to a DataFrame.
-
drop = aapl_bar.dropna()
+
+
+
drop = aapl_bar.dropna()
print drop
print '\n--------------------------------------------------\n'
fill = aapl_bar.fillna(0)
@@ -447,14 +305,21 @@
+ By default the DataFrame are joined with all of the data. This default options results in zero information loss. We can also merge them by intersection, this is called 'inner join':
+
-By default the DataFrame are joined with all of the data. This default options results in zero information loss. We can also merge them by intersection, this is called 'inner join':
-
+ 'Append' is essentially to concat two DataFrames by axis = 0, thus here is an alternative way to append:
+
+
+
+
+
concat = pd.concat([aapl_bar, df_2017], axis = 0)
print concat
Close High Low Open rate_return
Date
@@ -644,8 +550,13 @@
DataFrame Concat
2017-03-31 143.66 144.2700 143.01 143.72 NaN
2017-04-30 143.65 144.3000 143.27 144.09 NaN
-Please note that if the two DataFrame have some columns with the same column names, these columns are considered to be the same and will be merged. It's very important to have the right column names. If we change a column names here:
-
+ Please note that if the two DataFrame have some columns with the same column names, these columns are considered to be the same and will be merged. It's very important to have the right column names. If we change a column names here:
+
2017-01-31 121.15 121.35 121.3900 120.62 NaN NaN
2017-02-28 137.08 136.99 137.4350 136.70 NaN NaN
2017-03-31 143.72 143.66 144.2700 143.01 NaN NaN
-2017-04-30 144.09 143.65 144.3000 143.27 NaN NaN
-
-Since the column name of 'Open' has been changed, the new DataFrame has an new column named 'Change'.
-
-
Summary
-
-Hereby we introduced the most import part of python: resampling and DataFrame manipulation. We only introduced the most commonly used method in Financial data analysis. There are also many methods used in data mining, which are also beneficial. You can always check the Pandas official documentations for help.
\ No newline at end of file
+2017-04-30 144.09 143.65 144.3000 143.27 NaN NaN
+
+
+
+ Since the column name of 'Open' has been changed, the new DataFrame has an new column named 'Change'.
+
+ Hereby we introduced the most import part of python: resampling and DataFrame manipulation. We only introduced the most commonly used method in Financial data analysis. There are also many methods used in data mining, which are also beneficial. You can always check the Pandas official documentations for help.
+
diff --git a/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/01 Introduction.html b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/01 Introduction.html
new file mode 100755
index 0000000..b02e12a
--- /dev/null
+++ b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ In this chapter we are going to introduce some basic concepts in quantitative finance. We start with rate of return, mean and variance. You may think it's simple to calculate these values, however, there are number of different methods to calculate them. It's important to choose the appropriate calculation methods case by case.
+
diff --git a/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/02 Rate of Return.html b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/02 Rate of Return.html
new file mode 100755
index 0000000..aab985e
--- /dev/null
+++ b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/02 Rate of Return.html
@@ -0,0 +1,138 @@
+
Single-period Return
+
+ The single-period rate of return can be calculated as following:
+
+ Let's say we bought a stock at $100, and half a year later it will grow to $102. A year later the price will come to $104. How to calculate our total return? Well, we can either deem it as a single-period:
+
+ Here we make calculations twice a year. It's called semi-annual compounding. How about quarterly compounding? Let's assume the stock prices at the end of each quarter are \(p_1, p_2, p_3, p_4\) respectively.
+
+\[r = (1+r_1)*(1+r_2)*(1+r_3)*(1+r_4) -1\]
+
+ The rate of return we calculate here is called cumulative return or overall return. It measures the total return of this asset over a period of time.
+
+
+ Now consider the following situation: we have two strategies: strategy A and strategy B. We backtested strategy A for 1 years and the cumulative return is 20%, while we backtested strategy B for 3 months(one quarter) and the cumulative return is 6%. Which strategy has a high rate of return? Our commonly used method is to convert all the returns into compounding annual return, regardless of the investing horizon of each strategy. We can compare the returns of strategies with different time horizon now. Since there are four quarters in a year,the annual return of strategy B is
+
+\[(1+0.06)^4 = 1+r\]
+\[ r = 0.262\]
+
+ Strategy B has an higher compounding annual return when we compare 26% with 20%.
+
+
Logarithm Return
+
+ In the above example, strategy A has 6% return over three months. Nominally, the annual return would be 4*6% = 24%.
+ This nominal annual interest rate is called the stated annual interest rate.
+ It is calculated as the periodic interest rate times the number of periods per year. It works according to the simple interest and does not take into account the compounding periods, while the effective annual interest rate is 26% as we calculated above and it does account for intra-year compounding.
+ The effective annual interest rate is an essential tool that allows the evaluation of the real return on investment.
+ If we assume the number of compounding periods in one year is n, the formula to convert the stated annual interest rate to the effective annual interest rate is
+
+ Now imagine the price of asset is changing every second or even every millisecond, the period of compounding n approaches infinite. This is called continuous compounding. The calculation formula is given below:
+
+ Here we got the logarithmic return, or continuously compounded return. This return is the nominal return with the interest compounding every millisecond. To see how it is close to effective interest rate, recall the equation above:
+
where the second equality holds due to Taylor Expansion and the interest rate being small. This is frequently used when calculating returns, because once we take the logarithm of asset prices, we can calculate the logarithm return by simply doing a subtraction. Here we use Apple stock prices as an example:
+
+ Here we calculated the daily logarithmic return of Apple stock. Given that we know the daily logarithm return of in this month, we can calculate the monthly return by simply sum all the daily returns up.
+
+ It may sounds incorrect to sum up the daily returns, but we can prove that it's mathematically correct. Let's assume the stock prices in a period of time are represented by \([p_0, p_1, p_2, p_3.....p_n]\). Then the cumulative rate of return is given by:
+
+ According to the equation above, we can simple sum up each logarithmic return in a period to get the cumulative return. The convenience of this method is also one of the reasons why we use logarithmic return in quantitative finance.
+
diff --git a/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/03 Mean.html b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/03 Mean.html
new file mode 100755
index 0000000..72b9534
--- /dev/null
+++ b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/03 Mean.html
@@ -0,0 +1,35 @@
+
Arithmetic Mean
+
+ Mean is a measure of the central tendency of a data series. It capture the key character of the distribution of the data series. When we talk about mean, by default it refers to arithmetic mean. It's defined as the sum of the values divided by the number of observations:
+
+\[\mu = \frac{\sum_{i = 1}^{n}x_i}{n}\]
+
+ Where \((x_1,x_2,x_3.....x_n)\) is our data series.
+
+
+ In python we can use NumPy.mean() to do the calculation:
+
+ The geometric mean is an average that is useful for data series of positive numbers that are better interpreted according to their product, such as growth rate. It's calculated by:
+
+\[\bar{x} = \sqrt[n]{x_1x_2x_3...x_n}\]
+
+ Let's calculate the geometric mean of a series of single-period return:
+
+ Now the equation becomes the form which we are familiar with:
+
+\[(1+\bar{r})^t = \frac{p_t}{p_0}\]
+
+ This is why we said it make sense when applied to growth rates.
+
diff --git a/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/04 Variance and Standard Deviation.html b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/04 Variance and Standard Deviation.html
new file mode 100755
index 0000000..f11f818
--- /dev/null
+++ b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/04 Variance and Standard Deviation.html
@@ -0,0 +1,27 @@
+
Variance
+
+ Variance is a measure of dispersion. In finance, most of the time variance is a synonym for risk. The higher the variance of an asset price is, the higher risk the asset bears. Variance is usually represented by \(\sigma^2\), and it's calculated by
+
+ In python we can use NumPy.var to calculate it:
+
+
+
+
print np.var(aapl.log_price)
+
+
+
Standard Deviation
+
+ The most commonly used measure of dispersion in finance is standard deviation. It's usually represented by \(\sigma\). It's obvious to see the relation between standard deviation and variance:
+
diff --git a/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/05 Summary.html b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/05 Summary.html
new file mode 100755
index 0000000..1cc6f60
--- /dev/null
+++ b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/05 Summary.html
@@ -0,0 +1,3 @@
+
+ We introduced different types of rate of return in this chapter, which could be a little bit tricky when we calculate them. Mean and standard deviation are also very important concepts when we conduct hypothesis test or measure the risk associated with a asset. We will use those concepts intensively in our later chapter.
+
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial06 Rate of Return, Mean and Variance.ipynb b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/06 Rate of Return, Mean and Variance.ipynb
old mode 100644
new mode 100755
similarity index 84%
rename from Tutorial Series/Introduction to Financial Python/Tutorial06 Rate of Return, Mean and Variance.ipynb
rename to 05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/06 Rate of Return, Mean and Variance.ipynb
index 3980d14..8c4c7b6
--- a/Tutorial Series/Introduction to Financial Python/Tutorial06 Rate of Return, Mean and Variance.ipynb
+++ b/05 Introduction to Financial Python[]/06 Rate of Return, Mean and Variance/06 Rate of Return, Mean and Variance.ipynb
@@ -9,19 +9,19 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "0.02\n"
+ "0.020000000000000018\n"
]
}
],
"source": [
"import numpy as np\n",
"rate_return = 102.0/100 - 1\n",
- "print rate_return"
+ "print(rate_return)"
]
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 2,
"metadata": {},
"outputs": [
{
@@ -66,88 +66,79 @@
"#take log return\n",
"aapl['log_price'] = np.log(aapl.Close)\n",
"aapl['log_return'] = aapl.log_price.diff()\n",
- "print aapl"
+ "print(aapl)"
]
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "0.0273081001636\n"
+ "0.0273081001636184\n"
]
}
],
"source": [
"month_return = aapl.log_return.sum()\n",
- "print month_return"
+ "print(month_return)"
]
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "4.94597446551\n"
+ "4.94597446550658\n"
]
}
],
"source": [
- "print np.mean(aapl.log_price)"
+ "print(np.mean(aapl.log_price))"
]
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "0.000142032804482\n"
+ "0.00014203280448152512\n"
]
}
],
"source": [
- "print np.var(aapl.log_price)"
+ "print(np.var(aapl.log_price))"
]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
}
],
"metadata": {
"kernelspec": {
- "display_name": "Python 2",
+ "display_name": "Python 3",
"language": "python",
- "name": "python2"
+ "name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
- "version": 2
+ "version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.13"
+ "pygments_lexer": "ipython3",
+ "version": "3.6.4"
}
},
"nbformat": 4,
diff --git a/05 Introduction to Financial Python[]/07 Random Variables and Distributions/01 Introduction.html b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/01 Introduction.html
new file mode 100755
index 0000000..d557aea
--- /dev/null
+++ b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ In the last chapter we learned the definition of mean and variance, which are kind of point estimation. Point estimation means using sample data to calculate a single value which is to serve as a 'best estimation' of an unknown population. However, this it not enough because point estimations can be deceiving. We need to use more rigorous methods to test our ideas. That's why we consider distribution and hypothesis testing. Random variable distribution is the basis for almost all quantitative finance topics: linear regression, CAPM, Black-Scholes, binomial tree pricing, etc.
+
diff --git a/05 Introduction to Financial Python[]/07 Random Variables and Distributions/02 Random Variables.html b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/02 Random Variables.html
new file mode 100755
index 0000000..82718e8
--- /dev/null
+++ b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/02 Random Variables.html
@@ -0,0 +1,3 @@
+
+ First let's start with the concept of random variable. A random variable can be thought of as a drawing from a distribution whose outcome prior to the draw is uncertain. Imagine rolling a dice, you know that your chance of getting each is 1/6, but you don't know what's the number of your next roll is. If we roll the dice N times and record the number of each roll, a collection of those numbers is called discrete random variable. A discrete variable can take on a finite number of values. For our example, we can only take numbers from {1,2,3,4,5,6}. The other kind of variable is continuous random variable. A continuous variable can take on any value in a given range. You can think the rate of return as a continuous variable, it theoretically can take any value from \((-\infty, +\infty)\).
+
diff --git a/05 Introduction to Financial Python[]/07 Random Variables and Distributions/03 Distributions.html b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/03 Distributions.html
new file mode 100755
index 0000000..933b38c
--- /dev/null
+++ b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/03 Distributions.html
@@ -0,0 +1,178 @@
+
+ Each random variable follows a probability distribution, which is a function that can be thought of as providing the probabilities of occurrence of different possible outcomes in an experiment. In our dice example, the probability distribution of each number is 1/6. We usually use \(P(X)\) to represent a probability distribution function, where X is the outcome value. In our example, \(P(1) = P(2) = p(3) = 1/6\). However, we can't use this for a continuous distribution, because the probability of drawing a specific number from a continuous variable is 0, due to the infinite possible outcomes we have. Instead, we use probability density function(PDF) function to describe the probability that a value is in a specific range. We cover this later. For each probability distribution function, we have a cumulative distribution function(CDF). It is defined as \(P(X\leq x)\), which models the probability that the random variable X will take a value less than or equal to x. For discrete random variables, we just sum up the values less than or equal to x and then divide it with number of observations.
+
+
+
Uniform Distribution
+
+ Uniform distribution is the simplest type of probability distribution. A discrete uniform distribution has equal weight assigned to all outcomes. Both rolling a dice and tossing a fare coin are classical uniform distributions. Here we use python to simulate rolling a dice 10000 times.
+
+
+
+
+
import random
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+#define a function to simulate rolling a dice
+def dice():
+ number= [1,2,3,4,5,6]
+ return random.choice(number)
+
+series = np.array([dice() for x in range(10000)])
+print series
+
+
+
+
+ We create a series of random variables here. We can plot the values on the x-axis and put their numbers of occurrences on the y-axis to have a direct view of the distribution:
+
+ Let's say we want to know the frequency that the observations are less than or equal to 3. In other words we want to seek the value of \(P(X\leq 3)\).
+
+
+
+
print len([x for x in series if x <= 3])/float(len(series))
+[out]: 0.4956
+print np.mean(series)
+[out]: 3.5103
+
+
+
+ \(P(X\leq 3)\) is very close to 0.5. This is not surprising because we rolled the dice 1000 times, and the frequency that the observations are less than or equal to 3 should be close to the real probability, which is 0.5. For a given uniform distribution, it's straightforward to calculate its mean: it's the center of the distribution because every outcome is of equal weight. For our dice example, we can think of it as
+
+ More generally, if we a assume the minimum value in a uniform distribution is a and the maximum value is b, the mean can be given by:
+
+\[\bar{u} = \frac{a+b}{2}\]
+
+ Usually we use \(\bar{u}\) to represents the population mean, or the 'real mean'. Here we create a sample with 1000 observations, the mean we calculated above is the sample mean. Sample mean usually doesn't equal to the theoretical population mean unless the number of observation approaches to infinity. The variance is given by:
+
+\[\sigma^2 = \frac{(b-a)^2}{12}\]
+
+ Deducing the formula is out of our lecture scope. It's useful to realize for a given standard distribution, we can formularize its mean and variance.
+
+
Binomial Distribution
+
+ A binomial distribution is a discrete probability distribution of the number of successes in a sequence of n independent experiments. Let's assume that the market has 50% probability goes up and 50% probability goes down, and we observe it in the next 10 days, what's the distribution of the number of days it goes up? This is a binomial distribution example. In general, if we carry out the experiment n times, and each outcome is independent, with the same probability of success p, the probability of getting exactly k successes is given by the function:
+
+
+\[P(X = K) = C_n^k p^k (1-p)^{n-k}\]
+
+ Where
+
+\[C_n^k = \frac{n!}{(n-k)!k!}\]
+
+ Under such circumstance we say X follows the binomial distribution \(X \sim B(n,p)\). Let's simulate a binomial experiment with success rate p = 0.7 and experiment times n = 10
+
+
+
+
+
def trial():
+ number = [1,2,3,4,5,6,7,8,9,10]
+ a = random.choice(number)
+ if a<= 7:
+ return 1
+ else:
+ return 0
+
+
+
+ Each time we execute trial(), we did an experiment. If it succeed, it will return 1, otherwise it will return 0. Now we are going to do the experiment 10 times:
+
+
+
+
+
res = [trial() for x in range(10)]
+print sum(res)
+[out]: 7
+
+
+
+ Now we did the experiment 10 times, and the number of success is sum(res). However, it just means during these 10 experiments we succeed sum(res) times. If we want to see the binomial distribution, we need experiment N times. When n is large enough, our frequency will approach the theoretical probability. Here we simulate each outcome 10000 times:
+
+
+
+
+
def binomial(number):
+ l = []
+ for i in range(10000):
+ res = [trial() for x in range(10)]
+ l.append(sum(res))
+ return len([x for x in l if x == number])/float(len(l))
+print binomial(8)
+[out]: 0.2367
+
+
+
+ The number printed above is the simulated probability that we succeed 8 times if we experiment 10 times. For each possible outcome, we simulate the probability:
+
+ Here we got the simulated result of the binomial distribution. Now we are going to check if the simulated frequencies close enough to the theoretical probabilities. Let's take X = 7 and X = 8 as example:
+
+ Another good property of binomial distribution is that its mean and variance are simple enough:
+
+\[\bar{u} = np\]
+\[\sigma^2 = np(1-P)\]
+
+ We will not introduce the deduction here, but if you are interested in it, we encourage you to do it yourself, based on the probability functions we provided above.
+
diff --git a/05 Introduction to Financial Python[]/07 Random Variables and Distributions/04 Normal Distribution.html b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/04 Normal Distribution.html
new file mode 100755
index 0000000..6ab172b
--- /dev/null
+++ b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/04 Normal Distribution.html
@@ -0,0 +1,78 @@
+
+ Before looking at normal distribution, let's first talk about continues distribution. As we mentioned above, we use a probability density function(PDF) to model the probability that our value is taken our a specific range. We define it as:
+
+\[P(a<X<b) = \int_{a}^{b}f_x(x)dx\]
+
+ Now we can talk about the normal distribution. The normal distribution is most commonly used distribution in natural sciences, of course also in financial research. The PDF of normal distribution is given as follows:
+
+ Where \(\mu\) is the mean of the normal distribution, and \(\sigma\) is the standard deviation.
+
+
+ Generally, if a random variable X follows normal distribution, we represent it by \(X\sim N(\mu, \sigma^2)\). Specifically, if a normal distribution has a 0 mean and 1 standard deviation, we called it standard normal distribution. Now let's simulate a standard normal distribution using Python packages to see what it looks like:
+
+ Financial data is highly disordered and is considered to has lots of noise. Most of the time we believe those noise follows normal distribution. It's also widely believed that the return on an asset over a short period of time follows normal distribution. Let's check it with the daily logarithm rates of return on SPY:
+
+ We calculated the logarithm daily return of S&P 500 index from 2009 to present. Let's first have a look at the what the time-series return data looks like:
+
+ If we observe the x-axis and y-axis carefully, we can see the return of asset is not a standard normal distribution. The peak of the standard normal distribution plot is around 0.4, while it's over 0.6 for this chart. This is because the standard deviation \(\sigma\) of the return is obviously not 1. We can demonstrate the normal distribution with different mean and variance by simulation:
+
+
diff --git a/05 Introduction to Financial Python[]/07 Random Variables and Distributions/05 Summary.html b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/05 Summary.html
new file mode 100755
index 0000000..1b84d06
--- /dev/null
+++ b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/05 Summary.html
@@ -0,0 +1,3 @@
+
+ In this chapter we introduced random variable, the difference between discrete random distribution and continuous random distribution, and most importantly, normal distribution. In the next chapter we will introduce how to use these distributions to test our idea or generating trading signals.
+
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial07 Random Variable and Distributions.ipynb b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/07 Random Variable and Distributions.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Financial Python/Tutorial07 Random Variable and Distributions.ipynb
rename to 05 Introduction to Financial Python[]/07 Random Variables and Distributions/07 Random Variable and Distributions.ipynb
diff --git a/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/01 Introduction.html b/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/01 Introduction.html
new file mode 100755
index 0000000..fd72d46
--- /dev/null
+++ b/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/01 Introduction.html
@@ -0,0 +1,6 @@
+
+ In the last chapter we discussed random variables and random distributions. Now we are going to use the distributions we learned to test our hypothesis and also to model the financial data. When building a trading strategy, it's essential to do some research. However, you won't be able to test your idea using all the data, because it's infinity. You can only use a sample to do your experiment. That's why we need to understand the difference between population and sample, and then use confidence interval to test our hypothesis.
+
+
+ As we mentioned before, both mean and standard deviation are point estimation, and they can be deceiving because sample means are different from population means. Financial data is generated every day now and in the future, thus even though we can use all the data available, it's still just a sample. This is why we need to use confidence interval to attempt to determine how accurate our sample mean estimation is.
+
diff --git a/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/02 Confidence Interval.html b/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/02 Confidence Interval.html
new file mode 100755
index 0000000..2d4404b
--- /dev/null
+++ b/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/02 Confidence Interval.html
@@ -0,0 +1,112 @@
+
Sample Error
+
+ Let's use the daily return on S&P 500 index from Aug 2010 to present is our population. If we take the recent 10 daily returns to calculate the mean, will it be the same as the population mean? How about increasing the sample size to 1000?
+
+
+
+
+
import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+qb = QuantBook()
+spy = qb.AddEquity("SPY").Symbol
+
+#get SPY data from August 2010 to the present
+start_date = datetime(2010, 8, 1, 0, 0, 0)
+end_date = qb.Time
+spy_table = qb.History(spy, start_date, end_date, Resolution.Daily)
+
+spy_total = spy_table[['open','close']]
+#calculate log returns
+spy_log_return = np.log(spy_total.close).diff().dropna()
+print('Population mean:', np.mean(spy_log_return))
+[out]: Population mean: 0.000443353825615
+print('Population standard deviation:',np.std(spy_log_return))
+[out]: Population standard deviation: 0.00784267293815
+
+
+
+
+ Now let's check the recent 10 days sample and recent 1000 days sample:
+
+
+
+
+
+print('10 days sample returns:', np.mean(spy_log_return.tail(10)))
+[out]: 10 days sample returns: 0.000845189915474
+print('10 days sample standard deviation:', np.std(spy_log_return.tail(10)))
+[out]: 10 days sample standard deviation: 0.00313558001122
+print('1000 days sample returns:', np.mean(spy_log_return.tail(1000)))
+[out]: 1000 days sample returns: 0.000462827047221
+print('1000 days sample standard deviation:', np.std(spy_log_return.tail(1000)))
+[out]: 1000 days sample standard deviation: 0.00766589174299
+
+
+
+ As we expected, the two samples has different means and variances.
+
+
+
Confidence Interval
+
+ In order to estimate the range of population mean, we define standard error of the mean as follows:
+
+\[SE = \frac{\sigma}{\sqrt{n}}\]
+
+ Where \(\sigma \) is the sample standard deviation and \(n\) is the sample size.
+
+
+ Generally, if we want to estimate an interval of the population so that 95% of the time the interval will contain the population mean, the interval is calculated as:
+
+\[(\mu - 1.96*SE, \mu + 1.96*SE)\]
+
+ Where \(\mu\) is the sample mean and SE is the standard error.
+
+
+ This interval is called confidence interval. We usually use 1.96 to calculate a 95% confidence interval because we assume that the sample mean follows normal distribution. We will cover this in detail later. Let's try to calculate the confidence interval using the samples above:
+
+
+
+
+#apply the formula above to calculate confidence interval
+bottom_1 = np.mean(spy_log_return.tail(10))-1.96*np.std(spy_log_return.tail(10))/(np.sqrt(len((spy_log_return.tail(10)))))
+upper_1 = np.mean(spy_log_return.tail(10))+1.96*np.std(spy_log_return.tail(10))/(np.sqrt(len((spy_log_return.tail(10)))))
+bottom_2 = np.mean(spy_log_return.tail(1000))-1.96*np.std(spy_log_return.tail(1000))/(np.sqrt(len((spy_log_return.tail(1000)))))
+upper_2 = np.mean(spy_log_return.tail(1000))+1.96*np.std(spy_log_return.tail(1000))/(np.sqrt(len((spy_log_return.tail(1000)))))
+#print the outcomes
+print('10 days 95% confidence inverval:', (bottom_1,upper_1))
+[out]: 10 days 95% confidence inverval: (-0.0010982627102681939, 0.002788642541217079)
+print('1000 days 95% confidence inverval:', (bottom_2,upper_2))
+[out]: 1000 days 95% confidence inverval: (-1.230984558013321e-05, 0.00093796394002165957)
+
+
+
+
+ As we can see, the 95% confidence interval became much narrower if we increase the sample size from 10 to 1000. Imagine that if N goes positive infinite, then we have \(\lim_{n\rightarrow \infty}\frac{\sigma}{\sqrt{n}} = 0\). The confidence interval would become a certain value, which is the sample mean!
+
+
+
Confidence Interval of Normal Distribution
+
+ Normal Distribution is so commonly used that we should be able to remember some critical values of it. Specifically, we usually use 90%, 95% and 99% as the confidence level of a confidence interval. The critical values for these three confidence levels are 1.64, 1.96, and 2.32 respectively. in other words:
+
+ The same for other confidence intervals. It's also important to remember the famous 'Three sigma rule' or '68-95-99.7' rule associated with normal distribution. This is used to remember the confidence level of the intervals with a width of two, four and six standard deviation. Mathematically:
+
+\[P(\mu - \sigma \leq X \leq \mu+\sigma)\approx 0.6827\]
+\[P(\mu - 2\sigma \leq X \leq \mu+2\sigma)\approx 0.9545\]
+\[P(\mu - 3\sigma \leq X \leq \mu+3\sigma)\approx 0.9973\]
+
+ This can also be remembered by using the chart:
+
+
+
Central Limit Theory
+
+ As we mentioned, if we use the sample to estimate the confidence interval of the population, the 95% confidence interval is:
+
+\[(\mu - 1.96*SE, \mu + 1.96*SE)\]
+
+ Now you may have some sense to the number 1.96. It's the 95% critical value of a normal distribution. Does this means we assume the mean of sample follows a normal distribution? The answer is yes. This assumption is supported by central limit theorem. This theorem tells us that given a sufficiently large sample size from a population with a finite level of variance, the mean of all samples from the same population will be approximately equal to the mean of the population, and the means of the samples will be approximately normal distributed. This is the foundation of population mean confidence interval estimation.
+
diff --git a/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/03 Hypothesis testing.html b/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/03 Hypothesis testing.html
new file mode 100755
index 0000000..e25e886
--- /dev/null
+++ b/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/03 Hypothesis testing.html
@@ -0,0 +1,94 @@
+
+ Now we can talk about hypothesis testing. Hypothesis test is essentially test your inference based on a sample. Let's use our dataset, the daily return of S&P 500 us our population. Assume that we don't know the mean of this population. I guess that the mean of this population is 0. Is my guess correct? I need to test this hypothesis with my sample. Let's start from observing our sample:
+
+ We know how to calculate the confidence interval now. If I were right, i.e. the population mean is 0, then the 90% confidence interval of the sample with 1000 observations should be:
+
+ Our mean of the sample is out of the 90% confidence interval. This means on a 90% confidence level, we can claim that the mean of our population is not 0. In other word, we rejected the hypothesis that the daily return on S&P500 from aug 2010 is zero. Can we claim that with 95% confidence level?
+
+ This time the sample mean is within the confidence interval. Thus we can't reject my hypothesis. In other words, we can't claim with 95% confidence level that the mean return is positive. Even though we can claim it with 90% confidence level. We have actually already finished a hypothesis testing above! In general, we have null hypothesis \(H_0\) and alternative hypothesis. They are usually in the following forms:
+
+ If the tested value is outside the confidence interval, we reject the null hypothesis, or accept the alternative hypothesis; If the tested value is within the confidence interval, we can't reject the null hypothesis. Although the hypothesis testing method we used above is straightforward, it's not so convenient to implement. Instead, we reverse the process to calculate the critical value, or Z-score. Z-score is defined as:
+
+ We know that the critical value for the 90% confidence level is 1.64 and that for the 95% confidence level is 95%. The higher the Z score is, the further the tested value is from the hypothesized value(which is 0 in this example). Thus with 90% confidence level, we are far away enough from zero and we reject the null hypothesis. However with 95% confidence level, we are not far away enough from zero, so we can't reject the null hypothesis. One reason of doing in this way is that we can know how wide our confidence interval is. In our example, the z-score is 1.8488. We can know the width is the confidence interval referring to a normal distribution table. Of course we can do this in Python:
+
+
+
+
+
import scipy.stats as st
+print((1 - st.norm.cdf(1.9488)))
+[out]: 0.025659656888
+
+
+
+ It's worth noting that st.norm.cdf will return the probability that a value take from the distribution is less than our tested value. In other words, 1 - st.norm.cdf(1.9488) will return the probability that the value is greater than our tested value, which is 0.025659 in this example. This calculated number is called p-value. If our confidence level our confidence interval is 95%, then we have 2.5% on the left side and 2.5% on the right side. This is called two-tail test. If our null hypothesis is \(\mu = 0\), we are conducting two-tail test because the tested sample mean can be either positive enough or negative enough to reject the null hypothesis. We can see it from the chart:
+
+
+
+ If we use 95% confidence interval, we need a p-value less than 0.025 to reject the null hypothesis. However, now our p-value is 0.025659, which is greater than 0.025, thus we can't reject the null hypothesis. It's obviously less than 0.05, so we can still reject the null hypothesis with 90% confidence level. Now let's test the hypothesis that population mean = 0 again with a large sample, which has 1200 observations:
+
+ Using the a larger sample, now we can reject the null hypothesis with a higher confidence interval! our p-value is 0.0105, and it's a two-tail test, so our confidence level of the interval is 1-(0.0105*2) = 0.979. We can say at most with 97.9% confidence interval, we can claim that the population mean is not zero. We already know that the population mean is not 0. As our sample size increasing, the accurate rate of our hypothesis goes up.
+
diff --git a/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/04 Summary.html b/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/04 Summary.html
new file mode 100755
index 0000000..724eb85
--- /dev/null
+++ b/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/04 Summary.html
@@ -0,0 +1,3 @@
+
+ In this chapter we introduced confidence interval, especially that for the normal distribution, and hypothesis test. Now we know how to test our idea rigorously. Normal distribution and it's confidence interval can be applied to many quantitative finance theories, we will see it frequently in our following tutorials.
+
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial08 Confidence Interval and Hypothesis Testing.ipynb b/05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/08 Confidence Interval and Hypothesis Testing.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Financial Python/Tutorial08 Confidence Interval and Hypothesis Testing.ipynb
rename to 05 Introduction to Financial Python[]/08 Confidence Interval and Hypothesis Testing/08 Confidence Interval and Hypothesis Testing.ipynb
diff --git a/05 Introduction to Financial Python[]/09 Simple Linear Regression/01 Introduction.html b/05 Introduction to Financial Python[]/09 Simple Linear Regression/01 Introduction.html
new file mode 100755
index 0000000..142730d
--- /dev/null
+++ b/05 Introduction to Financial Python[]/09 Simple Linear Regression/01 Introduction.html
@@ -0,0 +1,77 @@
+
+ In finance and economics filed, most of the models are linear ones. We can see linear regression everywhere, from the foundation of the model portfolio theory to the nowadays popular Fama-French asset pricing model. It's very important to understand how linear regression works in order to have a comprehensive understanding of those theories.
+
+
+ If we are holding a stock, we must be curious about the relationship between our stock return and the market return. Let's say we hold Amazon stock on the first day of this year. In order to see the relation directly, we plot the daily return of our stock on the y-axis and plot the S&P 500 index daily return on the x-axis.
+
+
+
+
import numpy as np
+import pandas as pd
+import quandl
+quandl.ApiConfig.api_key = '_fgkxjSbt5389zGt4crC'
+#get data from quandl
+spy_table = quandl.get('BCIW/_SPXT')
+amzn_table = quandl.get('WIKI/AMZN')
+#fetch data from Jan 2017 to Jun 2017
+spy = spy_table.loc['2017':'2017-6',['Close']]
+amzn = amzn_table.loc['2017':'2017-6',['Close']]
+#calculate log return
+spy_log = np.log(spy.Close).diff().dropna()
+amzn_log = np.log(amzn.Close).diff().dropna()
+df = pd.concat([spy_log,amzn_log],axis = 1).dropna()
+df.columns = ['spx','amzn']
+print df.tail()
+
+
+
+
+
+
+
spy
+
amzn
+
+
+
2016-12-22
+
-0.004462
+
-0.005543
+
+
+
2016-12-23
+
0.001372
+
-0.007531
+
+
+
2016-12-23
+
0.000928
+
0.000946
+
+
+
2016-12-23
+
-0.005671
+
-0.009081
+
+
+
2016-12-23
+
0.002086
+
-0.020172
+
+
+
+
+ We successfully create a DataFrame contains the daily logarithm return of Amazon stock and S&P500. Now let's plot it:
+
+
+
+
+
import matplotlib.pyplot as plt
+plt.figure(figsize = (15,10))
+plt.scatter(df.spy,df.amzn)
+plt.show()
+
+
+
+
+
+ The plot is scattered, but we can see they are approximately correlated: generally the higher SPX's daily return is, the higher Amazon stock's return is. This is called positively correlated. We will cover it in the following tutorials.
+
diff --git a/05 Introduction to Financial Python[]/09 Simple Linear Regression/02 Slope and Intercept.html b/05 Introduction to Financial Python[]/09 Simple Linear Regression/02 Slope and Intercept.html
new file mode 100755
index 0000000..f1d15b8
--- /dev/null
+++ b/05 Introduction to Financial Python[]/09 Simple Linear Regression/02 Slope and Intercept.html
@@ -0,0 +1,16 @@
+
+ It's natural that we want to model the relation between these two rates of return. Intuitively we use a straight line to model it, this is called Linear Regression. In order to find the best straight line, it's natural to think that the vertical distances between the points of the data set and the fitted line should be minimized. Those vertical distances are called residual. Our objective is to make the sum of squared residuals as small as possible. This method is called ordinary least square, or OLS method. We use x and y to represent the two variable, S&P 500 daily returns and AMZN daily returns. The linear relation is:
+
+
+\[Y = Y = \alpha + \beta*X + \epsilon\]
+
+ Where \(\alpha\) is called intercept, \(\beta\) is called slope. Generally, if the scatter points can be represented by\(\left\{\right (x_1,y_1),(x_2, y_2),(x_3,y_3)...(x_n,y_n) \left\}\right\), then the intercept and slope are given by:
+
+ Where \(\bar{x}\) is the mean of X, \(\bar{y}\) is the mean of Y.
+
+
+ In python, we don't need to do the above calculation manually because we have package for it. But it still very important to understand the calculation process of \(\beta\) in order the understand the modern portfolio theory and CAPM, which we will cover in the future.
+
diff --git a/05 Introduction to Financial Python[]/09 Simple Linear Regression/03 Python Implementation.html b/05 Introduction to Financial Python[]/09 Simple Linear Regression/03 Python Implementation.html
new file mode 100755
index 0000000..0e0f7d9
--- /dev/null
+++ b/05 Introduction to Financial Python[]/09 Simple Linear Regression/03 Python Implementation.html
@@ -0,0 +1,51 @@
+
+ In python, we have a very power package for mathematical models, which is named 'statsmodels'.
+
+
+
+
import statsmodels.formula.api as sm
+model = sm.ols(formula = 'amzn~spy',data = df).fit()
+print model.summary()
+
+
+
+
+
+ We built a simple linear regression model above by using the ols() function in statsmodels. The 'model' instance has lots of properties. The most commonly used one is parameters, or slope and intercept. We can access to them by:
+
+ The red line is the fitted linear regression straight line. As we can see there are lot of statistical results in the summary table. Now let's talk about some important statistical parameters.
+
+
diff --git a/05 Introduction to Financial Python[]/09 Simple Linear Regression/04 Parameter Significance.html b/05 Introduction to Financial Python[]/09 Simple Linear Regression/04 Parameter Significance.html
new file mode 100755
index 0000000..5f85774
--- /dev/null
+++ b/05 Introduction to Financial Python[]/09 Simple Linear Regression/04 Parameter Significance.html
@@ -0,0 +1,11 @@
+
+ From the summary table we can see 'std err'. This means standard errors of the intercept and slope. The null hypothesis here is \(H_0: \beta = 0\), and the alternative hypothesis is \(H_1: \beta \neq 0\). This hypothesis score is calculated by:
+
+ The distribution used here is 'Student's t-distribution'. It's different from normal distribution but used in the similar way. The column 't' in this table is the test score, and 'p>|t|' is the p-value. By observing the p-value, we can see that the significance level of spy, or the slope, is very high because the p-value is close to zero. In other words, we have 99.999 confidence to claim that the slope is not 0, and there exists linear relation between X and Y. However, regarding the intercept, the p-value is 0.923, which means we have only 7.7% confidence level that the value of intercept is not 0. We can also see from the plot that the line crosses the origin. The following 2 columns are the lower band and upper band of the parameters at 95% confidence interval. At 95% confidence level, we can claim that the true value of the parameter is within this range.
+
diff --git a/05 Introduction to Financial Python[]/09 Simple Linear Regression/05 Model Significance.html b/05 Introduction to Financial Python[]/09 Simple Linear Regression/05 Model Significance.html
new file mode 100755
index 0000000..00c8cca
--- /dev/null
+++ b/05 Introduction to Financial Python[]/09 Simple Linear Regression/05 Model Significance.html
@@ -0,0 +1,14 @@
+Sum of Squared Errors, or SSE, is used to measure the difference between the fitted value and the actual value. It's given by:
+\[SSE = \sum_{i=1}^{n}(y_i - \hat{y_i})^2 = \sum_{i = 1}^{n}\hat{\epsilon_i}^2\]
+
+ If the linear model perfectly fitted the sample, the SSE would be zero. The reason we use squared error here is that the positive and negative errors would offset each other if we simply summed them up. Another measurement of the dispersion of the sample is called total sum of squares, or SS.. it's given by:
+
+\[SS = \sum_{i = i}^{n}(y_i - \bar{y}_i)^2\]
+
+ If you are familiar with variance, we can see that SS divided by the number of sample n is the sample variance. From SSE and SS, we can calculate the Coefficient of Determination, or r-square for short. R-square means the proportion of variation that 'explained' by the linear relationship between X and Y, it's calculated by:
+
+ Let's assume that the model perfectly fitted the sample, which means all of the sample points lie on the straight line. Then the SSE would become zero, and the r-square would become 1. This means perfect fitness. The higher r-square is, the more parts of variation can be explained by the linear relation, the higher significance level the model is.
+ Some other parameters, such as F-statistic, AIC and BIC, are related to multiple linear regression, with would be cover in the next chapter.
+
diff --git a/05 Introduction to Financial Python[]/09 Simple Linear Regression/06 Summary.html b/05 Introduction to Financial Python[]/09 Simple Linear Regression/06 Summary.html
new file mode 100755
index 0000000..97c4201
--- /dev/null
+++ b/05 Introduction to Financial Python[]/09 Simple Linear Regression/06 Summary.html
@@ -0,0 +1,3 @@
+
+ In this chapter we introduced how to implement simple linear in python, and focused on how to read the summary table. In next chapter we will introduced multiple linear regression, which are commonly used to built models in finance and economics.
+
+ In the last chapter we introduced simple linear regression, which has only one independent variable. In this chapter we will learn about linear regression with multiple independent variables.
+
+
+ A simple linear regression model is written in the following form:
+
+\[ Y = \alpha + \beta X + \epsilon \]
+
+
+ A multiple linear regression model with p variables is given by:
+
+\[ Y = \alpha + \beta_1 X_1 + \beta_2 X_2 + \dots + \beta_p X_p + \epsilon \]
diff --git a/05 Introduction to Financial Python[]/10 Multiple Linear Regression/02 Python Implementation.html b/05 Introduction to Financial Python[]/10 Multiple Linear Regression/02 Python Implementation.html
new file mode 100755
index 0000000..6b532d0
--- /dev/null
+++ b/05 Introduction to Financial Python[]/10 Multiple Linear Regression/02 Python Implementation.html
@@ -0,0 +1,282 @@
+
+ In the last chapter we used the S&P 500 index to predict Amazon stock returns. Now we will add more variables to improve our model's predictions. In particular, we shall consider Amazon's competitors.
+
+
+
+
+
import numpy as np
+import pandas as pd
+import quandl
+import matplotlib.pyplot as plt
+import statsmodels.formula.api as sm
+
+# Get stock prices
+quandl.ApiConfig.api_key = 'tAyfv1zpWnyhmDsp91yv'
+spy_table = quandl.get('BCIW/_SPXT')
+amzn_table = quandl.get('WIKI/AMZN')
+ebay_table = quandl.get('WIKI/EBAY')
+wal_table = quandl.get('WIKI/WMT')
+aapl_table = quandl.get('WIKI/AAPL')
+
+
+
+ Then we fetch closing prices starting from 2016:
+
+ Similarly, we can build a multiple linear regression model:
+
+
+
+
+
model = sm.ols(formula = 'amzn ~ spy + ebay + wal', data = df).fit()
+print model.summary()
+
+
+
+
+
+
+
coef
+
std err
+
t
+
P>|t|
+
[0.025
+
0.975]
+
+
+
Intercept
+
0.0001
+
0.001
+
0.134
+
0.894
+
-0.002
+
0.002
+
+
+
spy
+
1.0468
+
0.170
+
6.155
+
0.000
+
0.712
+
1.382
+
+
+
ebay
+
-0.0795
+
0.058
+
-1.364
+
0.174
+
-0.194
+
0.035
+
+
+
wal
+
-0.0865
+
0.089
+
-0.976
+
0.330
+
-0.261
+
0.088
+
+
+
aapl
+
0.1529
+
0.084
+
1.831
+
0.068
+
-0.012
+
0.317
+
+
+
+
+ As seen from the summary table, the p-values for Ebay, Walmart and Apple are 0.174, 0.330 and 0.068 respectively, so none of them are significant at a 95% confidence level. The multiple regression model has a higher \( R^2 \) than the simple one: 0.254 vs 0.234. Indeed, \( R^2 \) cannot decrease as the number of variables increases. Why? If an extra variable is added to our regression model, but it cannot account for variations in the response (amzn), then its estimated coefficient will simply be zero. It's as though that variable was never included in the model, so \( R^2 \) will not change. However, it is not always better to add hundreds of variables or we will overfit our model. We'll talk about this in a later chapter.
+
+
+
+ Can we improve our model further? Here we try the Fama-French 5-factor model, which is an important model in asset pricing theory. We will cover it in the later tutorials.
+
+
+
+ The data needed are publicly available on French's website. We have saved a copy for convenience. The following code fetches the data.
+
+
+
+
+
+import urllib2
+from datetime import datetime
+
+url = 'https://www.quantconnect.com/tutorials/wp-content/uploads/2017/08/F-F_Research_Data_5_Factors_2x3_daily.csv'
+response = urllib2.urlopen(url)
+fama_table = pd.read_csv(response)
+
+# Convert time column into index
+fama_table.index = [datetime.strptime(str(x), "%Y%m%d")
+ for x in fama_table.iloc[:,0]]
+# Remove time column
+fama_table = fama_table.iloc[:,1:]
+
+
+
+
+ With the data, we can construct a Fama-French factor model:
+
+ The Fama-French 5-factor model has a higher \( R^2 \) of 0.387. We can compare the predictions from simple linear regression and Fama-French multiple regression by plotting them together on one chart:
+
+ Although it's hard to see from the chart above, the predicted return from multiple regression is closer to the actual return. Usually we don't plot the predictions to determine which model is better; we read the summary table.
+
diff --git a/05 Introduction to Financial Python[]/10 Multiple Linear Regression/03 Model Significance Test.html b/05 Introduction to Financial Python[]/10 Multiple Linear Regression/03 Model Significance Test.html
new file mode 100755
index 0000000..63be11a
--- /dev/null
+++ b/05 Introduction to Financial Python[]/10 Multiple Linear Regression/03 Model Significance Test.html
@@ -0,0 +1,13 @@
+
+ Instead of using \( R^2 \) to assess whether our regression model is a good fit to the data, we can perform a hypothesis test: the F test.
+ The null and alternative hypotheses of an F test are:
+
+
+\[ H_0: \beta_1 = \beta_2 = \dots = \beta_p = 0 \]
+\[ H_1: \text{At least one coefficient is not 0} \]
+
+
+ We won't explain F test procedure in detail here. You just need to understand the null and alternative hypotheses. In the summary table of an F test, the 'F-statistic' is the F score, while 'prob (F-statistic)' is the p-value. Performing this test on the Fama-French model, we get a p-value of `2.21e-24` so we are almost certain that at least one of the coefficient is not 0.
+ If the p-value is larger than 0.05, you should consider rebuilding your model with other independent variables.
+ In simple linear regression, an F test is equivalent to a t test on the slope, so their p-values will be the same.
+
diff --git a/05 Introduction to Financial Python[]/10 Multiple Linear Regression/04 Residual Analysis.html b/05 Introduction to Financial Python[]/10 Multiple Linear Regression/04 Residual Analysis.html
new file mode 100755
index 0000000..5089062
--- /dev/null
+++ b/05 Introduction to Financial Python[]/10 Multiple Linear Regression/04 Residual Analysis.html
@@ -0,0 +1,69 @@
+
+ Linear regression requires that the predictors and response have a linear relationship. This assumption holds if the residuals are zero on average, no matter what values the predictors \( X_1, \dots, X_p \) take.
+ Often it's also assumed that the residuals are independent and normally distributed with the same variance (homoskedasticity), so that we can contruct prediction intervals, for example.
+ To check whether these assumptions hold, we need to analyse the residuals. In statistical arbitrage, residual analysis can also be used to generate signals.
+
+
+
Normality
+
+
+ The residuals of a linear model usually has a normal distribution. We can plot the residual's density to check for normality:
+
+
+
+
+
plt.figure()
+#ols.fit().model is a method to access to the residual.
+fama_model.resid.plot.density()
+plt.show()
+
+
+
+
+
+ As seen from the plot, the residual is normally distributed. By the way, the residual mean is always zero, up to machine precision:
+
+ This word is difficult to pronounce but not difficult to understand. It means that the residuals have the same variance for all values of X. Otherwise we say that 'heteroskedasticity' is detected.
+
+ As seen from the chart, the residuals' variance doesn't increase with X. The three outliers do not change our conclusion. Although we can plot the residuals for simple regression, we can't do this for multiple regression, so we use statsmodels to test for heteroskedasticity:
+
+
+
+
+
from statsmodels.stats import diagnostic as dia
+het = dia.het_breuschpagan(fama_model.resid,fama_df[['MKT','SMB','HML','RMW','CMA']][1:])
+print 'p-value: ', het[-1]
+[out]:p-value of Heteroskedasticity: 0.144075842844
+
+
+
+
+ No heteroskedasticity is detected at the 95% significance level.
+
diff --git a/05 Introduction to Financial Python[]/10 Multiple Linear Regression/05 Summary.html b/05 Introduction to Financial Python[]/10 Multiple Linear Regression/05 Summary.html
new file mode 100755
index 0000000..cff63c1
--- /dev/null
+++ b/05 Introduction to Financial Python[]/10 Multiple Linear Regression/05 Summary.html
@@ -0,0 +1,3 @@
+
+ In this chapter we have introduced multiple linear regression, F test and residual analysis, which are the fundamentals of linear models. In the next chapter we will introduce some linear algebra, which are used in modern portfolio theory and CAPM.
+
diff --git a/05 Introduction to Financial Python[]/10 Multiple Linear Regression/06 References.html b/05 Introduction to Financial Python[]/10 Multiple Linear Regression/06 References.html
new file mode 100644
index 0000000..7ac3bff
--- /dev/null
+++ b/05 Introduction to Financial Python[]/10 Multiple Linear Regression/06 References.html
@@ -0,0 +1,5 @@
+
+
+ Many papers in statistics and quantitative finance make heavy use of linear algebra, so you need to have a working knowledge of it in order to read and apply them to your trading.
+
diff --git a/05 Introduction to Financial Python[]/11 Linear Algebra/02 Vectors.html b/05 Introduction to Financial Python[]/11 Linear Algebra/02 Vectors.html
new file mode 100755
index 0000000..2d75a1e
--- /dev/null
+++ b/05 Introduction to Financial Python[]/11 Linear Algebra/02 Vectors.html
@@ -0,0 +1,15 @@
+
+ A vector can be thought of as an arrow pointing from the origin to a specific point. Any vector or point can be represented by its coordinates i.e. an array of numbers, such as \((x,y)\) for a 2-dimensional vector, or \((x,y,z)\) for a 3-dimensional one. We usually write a vector as a column:
+
+\[ \mathbf{v} = \begin{pmatrix}
+x \\ y \\ z
+\end{pmatrix} \]
+
+
+ The scalar product of two vectors \( \mathbf{x} \) and \( \mathbf{y} \) in 2-dimensional space is defined as:
+
+ This definition can be easily generalized to n dimensional space. Clearly, we cannot take the scalar product of two vectors with different dimensions.
+
diff --git a/05 Introduction to Financial Python[]/11 Linear Algebra/03 Matrices.html b/05 Introduction to Financial Python[]/11 Linear Algebra/03 Matrices.html
new file mode 100755
index 0000000..5d230de
--- /dev/null
+++ b/05 Introduction to Financial Python[]/11 Linear Algebra/03 Matrices.html
@@ -0,0 +1,64 @@
+
+ If we have a few vectors \( \mathbf{v}_1, \mathbf{v}_2, \dots, \mathbf{v}_n \) with the same dimension, then we can put them side-by-side to form a matrix. For example, the vectors
+
+ m is a 3 × 3 matrix. We typically describe the dimensions of a matrix as \(m \times n\) where m = number of rows and n = number of columns.
+
+
+
+ A square matrix is one with as many rows as columns.
+
+
+
+ Notation: \(x_{ij}\) refers to a specific value in row \(i\) and column \(j\) of a matrix \(X\). For example, \(x_{23}\) is the number in the second row and third column of \(X\).
+
+
+
Python Implementation
+
+
+ In Python, the NumPy package deals with linear algebra. The array we learned in the NumPy chapter can be deemed as a vector:
+
+ It is worth noticing that we used column_stack() here to ensure that the vectors are vertical and placed side-by-side to form a matrix. Without the column_stack() function, the vectors will be made horizontal and stacked on top of one another:
+
diff --git a/05 Introduction to Financial Python[]/11 Linear Algebra/04 Matrix Multiplication.html b/05 Introduction to Financial Python[]/11 Linear Algebra/04 Matrix Multiplication.html
new file mode 100755
index 0000000..65073a3
--- /dev/null
+++ b/05 Introduction to Financial Python[]/11 Linear Algebra/04 Matrix Multiplication.html
@@ -0,0 +1,58 @@
+
+ How are two matrices multiplied? Suppose \(X = AB\). Each entry \(x_{ij}\) of matrix \(X\) is the scalar product of row \(i\) from matrix \(A\) with column \(j\) from matrix \(B\). This is best illustrated with an example:
+
+ Since matrix multiplication is defined in terms of scalar products, the matrix product \(AB\) exists only if \(A\) has as many columns as \(B\) has rows. It's useful to remember this shorthand: (m × n) × (n × p) = (m × p) which means that an (m × n) matrix multiplied by an (n × p) matrix yields an (m × p) matrix.
+
+
+
+ Reversing the order of multiplication results in an error since B does not have as many columns as A has rows:
+
+
+
+
+
x = np.dot(B,A)
+
+
+
+
+ A natrual consequence of this fact is that matrix multiplication is not commutative. In other words, \(AB \neq BA\) in general.
+
diff --git a/05 Introduction to Financial Python[]/11 Linear Algebra/05 Inverse.html b/05 Introduction to Financial Python[]/11 Linear Algebra/05 Inverse.html
new file mode 100755
index 0000000..ddaa975
--- /dev/null
+++ b/05 Introduction to Financial Python[]/11 Linear Algebra/05 Inverse.html
@@ -0,0 +1,84 @@
+
+ An identity matrix is a square matrix with ones on the main diagonal and zeros elsewhere. Here is an \(n \times n\) identity matrix:
+
+ Multiplying any matrix by an identity matrix (of the correct shape) is like multiplying a number by 1. Concretely, if \(A\) is an \(m \times n\) matrix, then:
+
+\[ I_mA = AI_n = A \]
+\( A^{-1} \) is the inverse matrix of a square matrix \(A\) if:
+\[ AA^{-1} = I = A^{-1}A \]
+
+
+ Some caveats:
+
+
+
A rectangular matrix will not have an inverse, but it may have a pseudoinverse (not covered in this tutorial).
+
A square matrix may not have an inverse i.e. it may be "singular".
+
If a square matrix has an inverse, then its inverse is unique.
+
+
+
+ Inverse matrices are computed using the Gauss-Jordan method. In NumPy, we use the linalg.inv() function to do it:
+
diff --git a/05 Introduction to Financial Python[]/11 Linear Algebra/06 Linear Equations.html b/05 Introduction to Financial Python[]/11 Linear Algebra/06 Linear Equations.html
new file mode 100755
index 0000000..4b36d00
--- /dev/null
+++ b/05 Introduction to Financial Python[]/11 Linear Algebra/06 Linear Equations.html
@@ -0,0 +1,66 @@
+
+ A common problem in linear algebra is solving linear equations. Consider the following linear equations:
+
+
+\[ 2x + y - z = 8 \]
+\[ -3x - y + 2z = -11 \]
+\[ -2x + y + 2z = -3 \]
+
+
+ The solution is x = 2, y = 3, z = −1. However, computing the inverse matrix is not recommended, since it is numerically unstable i.e. small rounding errors can dramatically affect the result.
+
+ Of course, we get the same solution. We can check the correctness of the solution by substituting x, y and z into the linear equations.
+
diff --git a/05 Introduction to Financial Python[]/11 Linear Algebra/07 Summary.html b/05 Introduction to Financial Python[]/11 Linear Algebra/07 Summary.html
new file mode 100755
index 0000000..06f1c5e
--- /dev/null
+++ b/05 Introduction to Financial Python[]/11 Linear Algebra/07 Summary.html
@@ -0,0 +1,3 @@
+
+ In this chapter we have introduced vectors, matrices, inverse matrices and linear equations. Some applications in finance include: finding arbitrage opportunities by solving linear equations, computing portfolio variance, etc. In the next chapter, we will introduce modern portfolio theory and CAPM.
+
+ The Modern Portfolio Theory (MPT) suggests how investors should spread their wealth across various assets to minimize risk and maximize return.
+ This chapter is mathematically intense, so don't feel demoralized if you don't understand it on your first reading.
+
diff --git a/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/02 Risk Aversion.html b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/02 Risk Aversion.html
new file mode 100755
index 0000000..1fb2a12
--- /dev/null
+++ b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/02 Risk Aversion.html
@@ -0,0 +1,29 @@
+
+ In portfolio theory, the riskiness of an asset is often measured by the variance (or standard deviation) of its returns. Risk-averse investors do not want their wealth to fluctuate wildly.
+
+
+
+ Risk aversion can be illustrated with a simple example. Which of the following assets do you prefer?
+
+
+
+
Asset A pays $200 or $0 with 50% probability each.
+
Asset B pays $400 or −$200 (i.e. you lose $200) with 50% probability each.
+ If you are an risk seeker, you may choose asset B, because you can potentially get a higher payout. MPT assumes that investors prefer asset A since both assets have the same expected payout, but asset A has less risk.
+
diff --git a/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/03 Portfolio.html b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/03 Portfolio.html
new file mode 100755
index 0000000..493ae8b
--- /dev/null
+++ b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/03 Portfolio.html
@@ -0,0 +1,102 @@
+
+ Suppose we invest some fraction \(w_1, w_2, \dots, w_n\) of our wealth in n risky assets (labelled 1 to n), and the remainder \(w_0\) in a riskless asset such as cash in a bank account.
+
+
+
+ Clearly \(w_0 + w_1 + \dots + w_n = 1\) since our wealth comprises all those assets.
+
+
+
+ Let \(R_0, R_1, \dots, R_n\) be the respective asset returns, then our portfolio return is
+
+ Note that \( \mathbb{E}(R_0) = R_0 \) since the riskless return is known with certainty, by definition.
+
+
+
Correlation
+
+
+ Before computing portfolio risk, we need to first understand covariance and correlation. They measure the linear relationship between two random variables.
+
+
+
+ The covariance of two random variables X and Y is defined as
+
+ Recall that \( \text{Var}(X + c) = \text{Var}(X) \) if c is a known constant, so the term \( w_0 R_0 \) involving the riskless return can be omitted. It will be convenient to use sigma notation:
+
+ Portfolio risk can be reduced by choosing two assets that are negatively correlated. This is the benefit of diversification.
+
diff --git a/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/04 Mean-Variance Analysis.html b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/04 Mean-Variance Analysis.html
new file mode 100755
index 0000000..e60dcab
--- /dev/null
+++ b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/04 Mean-Variance Analysis.html
@@ -0,0 +1,65 @@
+
+ We now try to find a portfolio \( \mathbf{w} = (w_1, ..., w_n) \) that minimizes risk and maximizes return.
+
+
+
+ The chart below has risk (standard deviation of returns) on the horizontal axis and expected return on the vertical axis. The 10 black points represent individual stocks, while each green / blue point is a portfolio of stocks:
+
+
+
+
+ Notice that all points (i.e. stocks and portfolios) are enclosed by a hyperbola, known as the efficient frontier.
+ All portfolios on the efficient frontier have the maximum expected return for a given level of risk, if we only consider portfolios of risky stocks. Can we achieve higher returns by including a riskless asset? Yes.
+
+
+
Capital Market Line
+
+
+ The black line on the chart is the Capital Market Line (CML). It is tangent to the efficient frontier and cuts the vertical axis at the riskfree return. The point of tangency represents the so-called market portfolio.
+ Every point on the CML represents a portfolio comprising the market portfolio and riskless asset in some proportion. Why?
+ Suppose some fraction w of a CML portfolio is the market portfolio, and the remainder (1 − w) is the riskless asset. Then its expected return is
+
+ This proves that when \( \mathbb{E} (R_P) \) is plotted against \( \sigma_P \), we will obtain a straight line: the CML.
+
+
+
Portfolio Selection
+
+
+ Why is the CML significant? For any given level of risk, CML portfolios have a higher return than those on the efficient frontier, so investors should select any of them according to their risk tolerance.
+ Risk-averse investors may give the riskless asset a larger weight in their portfolio. Risk-seeking investors may borrow money (i.e. sell the riskless asset) to invest >100% of their wealth in the market portfolio.
+ Regardless of their risk tolerances, all investors should hold the same stocks in the same proportion in the market portfolio. In other words, they should not pick stocks according to their risk tolerance.
+
+
+
Diversification
+
+
+ What happens to the efficient frontier and hence the CML if we have only 3 stocks (IBM, GE, and PFE) instead of 10?
+
+
+
+
+
+ Since we have fewer stocks to choose from, it's not too surprising that our maximum expected return is lower for any level of risk. This demonstrates why diversification is often said to be a "free lunch" in investing.
+
diff --git a/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/05 Summary.html b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/05 Summary.html
new file mode 100755
index 0000000..569da12
--- /dev/null
+++ b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/05 Summary.html
@@ -0,0 +1,3 @@
+
+ In this chapter we have learnt about the modern portfolio theory. It recommends investors to spread their wealth across many asset classes to maximize returns while minimizing risk. In the next chapter, we will introduce the Capital Asset Pricing Model.
+
diff --git a/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/06 Algorithm.html b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/06 Algorithm.html
new file mode 100755
index 0000000..309e3c2
--- /dev/null
+++ b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/06 Algorithm.html
@@ -0,0 +1,9 @@
+
+ Mean-variance analysis is used to optimize portfolios with several strategies. Here we treat Dow 30 stocks as strategy and designed an algorithm to test mean-variance analysis:
+
+
+
+
+
+
+
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial12 Modern Portfolio Theory.ipynb b/05 Introduction to Financial Python[]/12 Modern Portfolio Theory/12 Modern Portfolio Theory.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Financial Python/Tutorial12 Modern Portfolio Theory.ipynb
rename to 05 Introduction to Financial Python[]/12 Modern Portfolio Theory/12 Modern Portfolio Theory.ipynb
diff --git a/05 Introduction to Financial Python[]/13 Market Risk/01 Introduction.html b/05 Introduction to Financial Python[]/13 Market Risk/01 Introduction.html
new file mode 100755
index 0000000..93c047e
--- /dev/null
+++ b/05 Introduction to Financial Python[]/13 Market Risk/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ In the financial literature, you may hear terms like the "beta" or "market risk" of an asset. This chapter will explain where these terms come from and how they can be useful.
+
diff --git a/05 Introduction to Financial Python[]/13 Market Risk/02 Capital Asset Pricing Model.html b/05 Introduction to Financial Python[]/13 Market Risk/02 Capital Asset Pricing Model.html
new file mode 100755
index 0000000..ad70283
--- /dev/null
+++ b/05 Introduction to Financial Python[]/13 Market Risk/02 Capital Asset Pricing Model.html
@@ -0,0 +1,36 @@
+
+ As we shall see later, the name "Asset Pricing" is a bit misleading because the CAPM tells us the expected return, rather than the price, of an asset. In the last chapter, we introduced the Capital Market Line (CML) shown in black:
+
+
+
+ All investors should hold a portfolio on the CML, which is constructed by investing some fraction w of our wealth in the market portfolio and the remainder (1 − w) in the riskless asset. So the return on a CML portfolio is
+
+\[ R = w R_{\text{market}} + (1-w) R_0 \]
+
+
+ If we let β = w, then the equation above becomes
+
+ Notice that β is a measure of how sensitive our CML portfolio return is to the market return. Taking expectation on both sides results in the CAPM:
+
\( \text{Cov} (X + c, Y) = \text{Cov} (X, Y) \) where \( c \) is constant
+
\( \text{Cov} (X, X) = \text{Var} (X) \)
+
+
+
+ Hence we obtain
+
+\[ \beta = \frac {\text{Cov} (R, R_{\text{market}})} {\text{Var} (R_{\text{market}})} \]
diff --git a/05 Introduction to Financial Python[]/13 Market Risk/03 Computing beta in Practice.html b/05 Introduction to Financial Python[]/13 Market Risk/03 Computing beta in Practice.html
new file mode 100755
index 0000000..3bfb5b9
--- /dev/null
+++ b/05 Introduction to Financial Python[]/13 Market Risk/03 Computing beta in Practice.html
@@ -0,0 +1,16 @@
+
+ While the Capital Asset Pricing Model is straightforward, applying it may not be. We first need to choose the timeframe for computing returns: should we use daily, weekly or monthly returns? Then we need to consider the number of data points available for linear regression. For example, if we compute beta using monthly returns in the past 1 year, then we only have 12 data points which is too few.
+ Furthermore, the β of an asset can change over time. The following plot is the daily rolling beta of GE stock with a 6-month rolling windows:
+
+
+
+
+
+ The β of GE ranged from 0.1 to 0.5 approximately. This is why you need to be careful when using β. It makes no sense to talk about β without a timeframe in mind.
+
+
+
+ The following graph is the rolling p-value of beta. The p-value stays close to zero most of the time. However, during some period it suddenly increased close to 0.1, which corresponds to a 90% confidence interval. This might be caused by some mispricing or market turmoil.
+
+
+
diff --git a/05 Introduction to Financial Python[]/13 Market Risk/04 Market-Neutral.html b/05 Introduction to Financial Python[]/13 Market Risk/04 Market-Neutral.html
new file mode 100755
index 0000000..286f056
--- /dev/null
+++ b/05 Introduction to Financial Python[]/13 Market Risk/04 Market-Neutral.html
@@ -0,0 +1,53 @@
+
+ A portfolio is market-neutral if its β is zero. In other words, the portfolio's returns are uncorrelated with market returns. We say that it has no "market risk". Some classical market-neutral strategies are pairs trading, beta-hedged equity portfolio and other derivatives strategies.
+ We have daily returns of Dow 30 stocks from March 2012 to Jan 2015. For each stock, its β on any given day is computed using the past 6 months' returns. As this 6-month window moves forward in time, β will of course change.
+ Once we know how each stock's β has changed over time, we can ask: which stocks' betas are correlated with each other? The table below shows the correlation between each stock's beta.
+
+
+
+
+ How can we construct a market-neutral portfolio? Consider two stocks A and B:
+
+ As mentioned earlier, \(\beta_A\) and \(\beta_B\) will change with time, so will \(w\) in a market-neutral portfolio. However we can achieve market neutrality with constant \(w\) so long as \(\beta_A\) and \(\beta_B\) have a linear relationship:
+
+\[ \beta_A = m\beta_B + c \]
+
+
+ Then eliminate \(\beta_A\) to get
+
+\[ w = \frac{\beta_B}{(1-m) \beta_B - c} \]
+
+
+ If c ≈ 0 then w is roughly constant:
+
+\[ w = \frac{1}{1-m} \]
+
+
+ Note: If c is signficant, then we need 3 stocks to get zero net beta. Usually 2 stocks are sufficient to cancel out most of the market risk.
+
+
+
Example
+
+
+ The 6-month rolling betas of PG and KO stocks have a correlation of 93%. The linear relationship between their betas is
+
+ We tested this portfolio both in-sample (March 2012 to Jan 2015) and out-of-sample. It achieved a beta of 0.01 and -0.004 respectively. See the backtest below.
+
diff --git a/05 Introduction to Financial Python[]/13 Market Risk/05 Summary.html b/05 Introduction to Financial Python[]/13 Market Risk/05 Summary.html
new file mode 100755
index 0000000..102ee5d
--- /dev/null
+++ b/05 Introduction to Financial Python[]/13 Market Risk/05 Summary.html
@@ -0,0 +1,3 @@
+
+ This chapter has explained what market risk means in the context of CAPM, and how market risk can be reduced. In the next chapter we will generalize CAPM to multi-factor models, such as the Fama-French models.
+
diff --git a/05 Introduction to Financial Python[]/13 Market Risk/06 Algorithm.html b/05 Introduction to Financial Python[]/13 Market Risk/06 Algorithm.html
new file mode 100755
index 0000000..64474c1
--- /dev/null
+++ b/05 Introduction to Financial Python[]/13 Market Risk/06 Algorithm.html
@@ -0,0 +1,13 @@
+
+ In previous chapters, we learnt that the Capital Asset Pricing Model (CAPM) treats the market return as the only factor affecting the return of any asset. This chapter will generalize CAPM to multi-factor models of the following form:
+
MKT is the excess return of the market. It's the value-weighted return of all CRSP firms incorporated in the US and listed on the NYSE, AMEX, or NASDAQ minus the 1-month Treasury Bill rate.
+
SMB (Small Minus Big) measures the excess return of stocks with small market cap over those with larger market cap.
+
HML (High Minus Low) measures the excess return of value stocks over growth stocks. Value stocks have a higher book to price ratio (B/P) than growth stocks.
+
+
+
+ Data on these factors can be downloaded from French's website.
+
diff --git a/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/03 Model Test.html b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/03 Model Test.html
new file mode 100755
index 0000000..29d8539
--- /dev/null
+++ b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/03 Model Test.html
@@ -0,0 +1,19 @@
+
+ To test the 3-factor model, we use it to predict returns on NASDAQ US Small Cap Index and NASDAQ US Large Cap Index. We estimate the model with daily returns in the past 6 years.
+
+
+
+ Results for US Small Cap returns:
+
+
+
+
+ The coefficient of SMB is positive, so when small caps outperform large caps, the Small Cap Index will have higher returns, which is not surprising. By comparing the t statistics of those factors, we know that MKT and SMB are more important factors driving the Small Cap Index.
+
+
+ Results for US Large Cap returns:
+
+
+
+ As expected, the coefficient of SMB is negative for the Large Cap Index. The coefficient of HML is quite low, which suggests that value and growth stocks take approximately the same weight in the Large Cap Index.
+
diff --git a/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/04 Factor Returns.html b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/04 Factor Returns.html
new file mode 100755
index 0000000..5da096f
--- /dev/null
+++ b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/04 Factor Returns.html
@@ -0,0 +1,13 @@
+
+ The Fama-French 5-Factor model comprises two more factors:
+
+
+
RMW (Robust Minus Weak) measures the excess returns of firms with high operating profit margins over those with lower profits.
+
CMA (Conservative Minus Aggressive) measures the excess returns of firms investing less over those investing more.
+
+
+
+ RMW was proposed by Novy-Marx (2013) who wrote that:
+ "Controlling for gross profitability explains most earnings related anomalies, and a wide range of seemingly unrelated profitable trading strategies." CMA was proposed by Fama and French (2014).
+ The article pointed out that: "A five-factor model directed at capturing the size, value, profitability, and investment patterns in average stock returns is rejected on the GRS test, but for applied purposes it provides an acceptable description of average returns." Finally, momentum is another commonly used factor. It captures excess returns of stocks with highest returns over those with lowest returns
+
diff --git a/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/05 Summary.html b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/05 Summary.html
new file mode 100644
index 0000000..d2b7e7a
--- /dev/null
+++ b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/05 Summary.html
@@ -0,0 +1,3 @@
+
+ In this chapter we expand Capital Asset Pricing Model (CAPM) into multi-factor models: the Fama-French factor models in particular. They are the most empirically successful multi-factor models by far, and are commonly used in practice.
+
diff --git a/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/06 Algorithm.html b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/06 Algorithm.html
new file mode 100644
index 0000000..3eb4334
--- /dev/null
+++ b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/06 Algorithm.html
@@ -0,0 +1,15 @@
+
+ Multi-factor strategies are stock picking strategies. Here we try to implement a 2013 paper published by AQR Capital Management.
+ The paper recommends picking stocks by their value, quality (profitability) and momentum.
+ The empirically successful measure of value is book-to-price ratio (B/P), but other measures can be used simultaneously to form a more robust and reliable view of a stock's value. The paper uses 5 measures: book-to-price, earnings-to-price ratio (EPS), forecasted EPS, cash flow-to-enterprise value and sales-to-enterprise value.
+ The paper suggested a few quality measures: total profit over assets, gross margin and free cash flow over assets. There are also various measures of momentum. 1-year momentum, fundamental momentum and returns around earnings announcement are good choices.
+
+
+ In our backtested strategy, we used operating profit margin to measure quality, book value per share to measure value, and 1-month momentum. The portfolio was rebalanced every month. You can build your own version by changing the factor, the weight of each factor, and the rebalance period based on the backtested strategy.
+
+
+
+
+
+
+
diff --git a/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/07 References.html b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/07 References.html
new file mode 100644
index 0000000..eb7216e
--- /dev/null
+++ b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/07 References.html
@@ -0,0 +1,20 @@
+
+
+ Robert Novy-Marx (2013). The Other Side of Value: The Gross Profitability Premium Journal of Financial Economics 108 (1), 1-28. Retrieved from rnm.simon.rochester.edu/research/OSoV.pdf
+
+ Robert Novy-Marx (2013). The Other Side of Value: The Gross Profitability Premium Journal of Financial Economics 108 (1), 1-28. Retrieved from rnm.simon.rochester.edu/research/OSoV.pdf
+
+
+ Fama, E. F. & French, K. R. (1993). Common risk factors in the returns on stocks and bonds. Journal of Financial Economics, 33, 3-56. doi: 10.1016/0304-405X(93)90023-5. Retrieved from rady.ucsd.edu.
+
+
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial14 Fama-French Multi-Factor Models.ipynb b/05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/14 Fama-French Multi-Factor Models.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Financial Python/Tutorial14 Fama-French Multi-Factor Models.ipynb
rename to 05 Introduction to Financial Python[]/14 Fama-French Multi-Factor Models/14 Fama-French Multi-Factor Models.ipynb
diff --git a/06 Introduction to Options[]/01 General Features of Options/01 Introduction.html b/06 Introduction to Options[]/01 General Features of Options/01 Introduction.html
new file mode 100755
index 0000000..c07ec6b
--- /dev/null
+++ b/06 Introduction to Options[]/01 General Features of Options/01 Introduction.html
@@ -0,0 +1,3 @@
+
+In this tutorial, we will discuss the basic features of options to help you gain insight on what the option is, how options market is organized and how these contracts are traded. Then we will discuss the settlement rules of option contracts and the moneyness of options.
+
diff --git a/06 Introduction to Options[]/01 General Features of Options/02 Definition.html b/06 Introduction to Options[]/01 General Features of Options/02 Definition.html
new file mode 100755
index 0000000..43a2e71
--- /dev/null
+++ b/06 Introduction to Options[]/01 General Features of Options/02 Definition.html
@@ -0,0 +1,45 @@
+
+ An option is a type of financial derivative. Derivatives are financial contracts and its value is dependent on or derived from underlying assets. The underlying assets could be stocks, indices, commodities, currencies, exchange rates, or the interest rate. When you trade options contracts, it can help you generate profits by betting on the future value or just the moving direction of the underlying assets. So, their value is derived from that of the underlying asset. This is why options are called derivatives.
+
+
+ Puts and calls are two basic classes of options. Call options give the buyer the right to buy the underlying asset at a certain price while put options endow the buyer the rights to sell them. For strict definition, a call/put option is a standardized contract that gives the buyer the right to buy/sell an agreed quantity n of underlying asset S, at a predetermined price K at maturity T. The seller of a call/put option is obliged to sell/buy the underlying assets if the buyer exercises the option.
+
+
+ First, we give the building blocks of an option contract and will discuss them further.
+
+
+
+
+
Style
+
American Option: the holder of an option has the right to exercise his option at any time before the expiration date
+European Option: an option which can only be exercised on its expiration date
+
+
+
Type
+
Call option, Put option
+
+
+
Underlying Asset
+
The security on which the option is bound. The underlying could be stocks(stock option), stock indices(index option), exchange rate(Foreign exchange option) or even futures(Futures Options).
+Note: The options in the tutorial refer to the stock options.
+
+
+
Premium
+
The price of the option. (Premiums are quoted on a per share basis).
+The option premium depends on the strike price, volatility of the underlying, as well as the time remaining to expiration.
+
+
+
Strike Price
+
The specified price at which the stock can be bought or sold when the option is exercised.
+
+
+
Expiration Date
+
The last day that an options contract is valid. All options expire after a certain period of time. The right to exercise the option will no longer exist once the stock option expires.
+
+
+
Participants
+
Holder: People who buy the options(have long positions)
+Writer: People who sell the options(have short positions)
+
+
+
diff --git a/06 Introduction to Options[]/01 General Features of Options/03 Options Contract.html b/06 Introduction to Options[]/01 General Features of Options/03 Options Contract.html
new file mode 100755
index 0000000..b23a213
--- /dev/null
+++ b/06 Introduction to Options[]/01 General Features of Options/03 Options Contract.html
@@ -0,0 +1,9 @@
+
+ Stock options are traded in units. Each contract entitles the option buyer/owner 100 shares of the underlying stock upon expiration. Thus, if you buy five call option contracts, you are acquiring the right to purchase 500 shares at expiration. For any given asset at any given time, an option can be bought or sold with multiple expiration dates and strikes. Suppose there are three expiration dates and four strike prices for options on a particular stock, there are a total of 24 different contracts if we consider both put and call options. Currently, all equity options traded on U.S. options exchanges are American-style. But many index options are European-style.
+
+
+ Let us use the example of Apple. You can buy and sell Apple shares (NASDAQ: AAPL), and you can also buy and sell Apple options. But not all stocks have options associated with them. This means that there may be no options available to buy or sell written on a certain stock. You can view the websites of the exchanges to find out which stocks do have options.
+
+
+ In this case, the stock AAPL is known as the underlying asset. The share price of AAPL is the underlying price. And a series of options contracts written on Apple are derivatives. Option contracts have their own symbols. For example, AAPL170728C00143000 is one of the option contracts, it is a call option and the strike price is $143. The contract expires on July 28th. The premium for this contract is $10. If you spend $10 cost on buying one contract, then you get the right to buy 100 shares of AAPL for $143 per share at any time before the expiration date.
+
diff --git a/06 Introduction to Options[]/01 General Features of Options/04 The Value of Options.html b/06 Introduction to Options[]/01 General Features of Options/04 The Value of Options.html
new file mode 100755
index 0000000..b392bbd
--- /dev/null
+++ b/06 Introduction to Options[]/01 General Features of Options/04 The Value of Options.html
@@ -0,0 +1,16 @@
+
+ The option's premium consists of two parts: the intrinsic value and the time value.
+
+ From the equations above, only in the money options have intrinsic value. After we know the intrinsic value, the time value is the difference between the options premium and the intrinsic value.
+
+
+\[Time Value= Premium-Intrinsic Value\]
+
+
+For example, an AAPL call option contract which expires after 10 days has strike $143 and premium $10. now the market price of AAPL is $150. The intrinsic value of this contract is 150-143=$7, the time value is 10-7=$3. Although the intrinsic value of OTM and ATM options is zero, they have time values if they still have a certain amount of time until the option expires so for OTM and ATM options, their premiums equal their time values.
+
diff --git a/06 Introduction to Options[]/01 General Features of Options/05 Options Moneyness.html b/06 Introduction to Options[]/01 General Features of Options/05 Options Moneyness.html
new file mode 100755
index 0000000..a089ece
--- /dev/null
+++ b/06 Introduction to Options[]/01 General Features of Options/05 Options Moneyness.html
@@ -0,0 +1,30 @@
+
+ Option moneyness describes the relationship between an option's strike price and the underlying asset's price. It has important implications for options trading.
+
+
+
+
+
At the Money(ATM)
+
The strike price is the same as the current price of the underlying asset
+
+
+
In the Money(ITM)
+
Call Option: the strike price is below the current trading price of the underlying
+Put option: the strike price is above the spot price of the underlying
+
+
+
Out of the Money(OTM)
+
Call Option: the strike price is above the current trading price of the underlying
+Put Option: the strike price is below the current trading price of the underlying
+
+
+
+
+ For example, if the price of Apple stock is at $140, then all calls with a strike price below $140 are in the money calls, all puts with a strike price above $140 are in the money puts. All calls with a strike price above $140 are out of the money calls, all puts with a strike price below $140 are out of the money puts.
+
+
+ But why are they in the money or out of the money? For a call option as an example, it is ITM because it already has an intrinsic value. If you buy the call option and own the right to buy AAPL at strike price $143 and the current market price is $150, then this call option is in the money 150-143=$7. If you need to exercise it, you can buy shares of AAPL at $143 and sell them immediately for $150 and secure $7 profit.
+
+
+ Likewise, for a call option, it is OTM because it doesn't have any intrinsic value. If you buy the call option and own the right to buy AAPL at strike price $143 and the current market price is $130, then this call option is out of the money 130-143=-$13. If you need to exercise it, you can buy shares of AAPL at $143 and sell them immediately for $130 and then you will lose $13. In this case, you would not do that. But why this kind of OTM options still traded in the market and you need to pay for them? That because they still have time values and have time to expiration. There is probability or there is the expectation from the OTM option holders that the apple price will go up and above the strike price before the expiration.
+
diff --git a/06 Introduction to Options[]/01 General Features of Options/06 Exercise and Assignment.html b/06 Introduction to Options[]/01 General Features of Options/06 Exercise and Assignment.html
new file mode 100755
index 0000000..933c12d
--- /dev/null
+++ b/06 Introduction to Options[]/01 General Features of Options/06 Exercise and Assignment.html
@@ -0,0 +1,18 @@
+
+ When you are the buyer of an option you have three ways to deal with your options.
+
+
+
You can close out the position at any given point prior to expiration (For buyers, write options and for sellers, buy options);
+
Wait until the expiration date and out-of-the-money options will become worthless;
+
Exercise the options which are in-the-money, resulting in a trade of the underlying stock (The seller will be assigned the obligation to sell or buy the underlying stocks)
+
+
+ For all of those methods, closing out an option in the market is the most frequently used method. At the expiration, you need to deal with the option exercise if you long the options. If you short put or call options, you have to think about the assignment.
+
+
+
Exercise: Exercising option means that the option holder executes the right to buy or sell the underlying assets at the strike price.
+
Assignment: When an option is exercised by the option holder, the option writer will be assigned the obligation to deliver the terms of the options contract. This is called the option assignment.
+
+
+ To be concrete, if you write a call option and the option holder decides to exercise, then you must sell the obligated quantity of the underlying security at the strike price to the option holder. Suppose you hold the underlying shares while writing the call option (covered call), those shares would be transferred from you to your counterpart. If you do not hold those shares in your account (naked call), you would then short those shares and deliver them to your counterpart. In another case, if you short a put and the holder decides to exercise, then you must buy those shares. You would now long shares in your account and don't hold options.
+
diff --git a/06 Introduction to Options[]/01 General Features of Options/07 Summary.html b/06 Introduction to Options[]/01 General Features of Options/07 Summary.html
new file mode 100755
index 0000000..4ec6d53
--- /dev/null
+++ b/06 Introduction to Options[]/01 General Features of Options/07 Summary.html
@@ -0,0 +1,3 @@
+
+ An option is a standardized contract between two parties to buy or sell an asset for a certain price. Options are pretty different from equity trading. Here we concerned primarily with the stock options. This chapter we present some introductory material on options market like the basic features of options contracts and the options trading mechanism. In addition, we explain how options markets are organized, how the contracts are traded. Next chapter we will take a close look at how to use QuantConnect API to start your options trading algorithm.
+
diff --git a/06 Introduction to Options[]/02 QuantConnect Options API/01 Introduction.html b/06 Introduction to Options[]/02 QuantConnect Options API/01 Introduction.html
new file mode 100755
index 0000000..fd8f150
--- /dev/null
+++ b/06 Introduction to Options[]/02 QuantConnect Options API/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ QuantConnect provides US options trade and quotes price data for approximately 4000 symbols, each of which has roughly 10 strikes on average. Data is available starting January 1st, 2008. In this tutorial, we will discuss how to use QuantConnect to start your options trading algorithm.
+
diff --git a/06 Introduction to Options[]/02 QuantConnect Options API/02 Add Options.html b/06 Introduction to Options[]/02 QuantConnect Options API/02 Add Options.html
new file mode 100755
index 0000000..44c5959
--- /dev/null
+++ b/06 Introduction to Options[]/02 QuantConnect Options API/02 Add Options.html
@@ -0,0 +1,35 @@
+
+ Before trading options, you need to add options for a given underlying equity and set the resolution in step Initialize with AddOption method. The commonly used parameters will be explained in the method table. Please refer to the link below for details of each method.
+
underlying(string): The underlying equity symbol
+resolution: Tick, Second, Minute, Hour, or Daily. Default is minute
+fillDataForward(bool): If true, returns the last available data even if none in that time slice. The default value is true.
+
+
+
+
+
+
def Initialize(self):
+ self.SetStartDate(2017, 1, 1) #Set Start Date
+ self.SetEndDate(2017, 6, 30) #Set End Date
+ self.SetCash(50000) #Set Strategy Cash
+ equity = self.AddEquity("GOOG", Resolution.Minute) # Add the underlying stock: Google
+ option = self.AddOption("GOOG", Resolution.Minute) # Add the option corresponding to underlying stock
+ self.symbol = option.Symbol
+
+
+
+ The return value of AddOption method is an option security object , please refer to the link for detailed properties and methods of option class.
+
diff --git a/06 Introduction to Options[]/02 QuantConnect Options API/03 Filter Contracts.html b/06 Introduction to Options[]/02 QuantConnect Options API/03 Filter Contracts.html
new file mode 100755
index 0000000..be1a2be
--- /dev/null
+++ b/06 Introduction to Options[]/02 QuantConnect Options API/03 Filter Contracts.html
@@ -0,0 +1,43 @@
+
+ After adding the options for specific underlying stock, you can set the filter criteria with SetFilter method to pull contracts using the specified min and max strike and expiration range values you need for a given symbol.
+
min Strike, max Strike: The min and max strike rank relative to market price
+min Expiry, max Expiry: The range of time to expiration to include, for example, TimeSpan.FromDays(10) would exclude contracts expiring in less than 10 days
+
+
+
+
+ Here parameters min Strike and max Strike are the relative multipliers with respect to the market price. We use Google(NASDAQ: GOOG) as an example to describe the filter criteria. If today is 01/03/2017, the market price of underlying stock is $776, the strike prices of GOOG options are spaced $2.5. Then SetFilter(-1, +2, timedelta(0), timedelta(90)) will fist look up at the money contracts with strike being K=$777.5 (Here K is 777.5 the next closest multiple to the underlying price of 775 since rarely will an option be ATM exactly). Then SetFilter will look for options with strikes between and including ( 777.5 - 2.5*1, 777.5 + 2.5*2). The time to expiration of these options are restricted within 90 days from now on.
+
+
+ For the strike, the exchange normally chooses the strike prices at which options can be written so that they are spaced $2.50, $5, or $10 apart. Typically the spacing is $2.50 when the stock price is between $5 and $25, $5 when the stock price is between $25 and $200, and $10 for stock prices above $200. So you should carefully choose the parameters of min strike and max Strike in case there are no contracts that satisfy the filter criteria if the range is too small, less than the minimum units of strike prices change.
+
+
+ For the expiry, there are many expiration dates that apply to the different series of options. An option cycle is the pattern of months in which options contracts expire. There are three kinds of common option cycles. The options on the January cycle have contracts available in the first month of each quarter (January, April, July and October). Options assigned to the February cycle use the middle month of each quarter (February, May, August and November). And options in the March cycle have options available during the last month of each quarter (March, June, September and December). In addition, individual stock options typically expire in the current month and the subsequent month.
+
+
+
+
+
# filter the contracts with strikes between (market price - 10, market price + 10)
+option.SetFilter(-10,10)
+# filter the contracts which expires more than 30 days but no longer than 60 days
+option.SetFilter(TimeSpan.FromDays(30),TimeSpan.FromDays(60))
+# filter the contracts with strikes between(ATM Strike - 10 * strike space value, market price + 10 * strike space value) and with expiration days less than 180 days
+option.SetFilter(-10, +10, timedelta(0), timedelta(180))
+
+
diff --git a/06 Introduction to Options[]/02 QuantConnect Options API/04 Select Contracts.html b/06 Introduction to Options[]/02 QuantConnect Options API/04 Select Contracts.html
new file mode 100755
index 0000000..07ea589
--- /dev/null
+++ b/06 Introduction to Options[]/02 QuantConnect Options API/04 Select Contracts.html
@@ -0,0 +1,189 @@
+
+ For QuantConnect API, Slice class provides a data structure for all of an algorithm's data at a single time step. So you need use property Slice.OptionChains to request options data for this slice.
+
+OptionChains is a collection of OptionChain keyed by the option's underlying symbol. The elements in Slice.OptionChains have properties Key(the underlying symbol object) Value(the option chain).
+
+OptionChain represents an entire chain of option contracts for a single underlying security. In other words, It is a list of option contracts.
+
+OptionContract defines a single option contract at a specific expiration and strike price. For any contract x in option chain, you can use the following statements to check different options properties.
+
+
+
+
+
+
Properties of Option Contract x
+
+
+
+
+
x.Symbol.Value
+
Get the string of option contract's symbol
+
+
+
x.AskPrice, x.BidPrice
+
Get the ask price, Get the bid price
+
+
+
x.Expiry
+
Get the expiration date
+
+
+
x.Strike
+
Get the strike price
+
+
+
x.ImpliedVolatility
+
Get the implied volatility
+
+
+
x.Greeks
+
Get the Greeks letter
+
+
+
x.Right
+
Get the right being purchased
+x.Right ＝ 0 call option[right to buy]
+x.Right ＝ 1 put option[right to sell]
+
+
+
x.UnderlyingLastPrice
+
Get the last price the underlying security traded at
+
+
+
x.UnderlyingSymbol
+
Gets the underlying security's symbol
+
+
+
+
+
+ We can print out the details of the contract after filtering with Python data frame to show these properties. Assume today is 01/03/2017. The stock price at 01/03/2017 09:31:00 is $776.01 per share. Here we use SetFilter(-1, +1, timedelta(0), timedelta(60)) to filter the contracts.
+
+
+
+
+
def OnData(self,slice):
+ for i in slice.OptionChains:
+ if i.Key != self.symbol: continue
+ optionchain = i.Value
+ self.Log("underlying price:" + str(optionchain.Underlying.Price))
+ df = pd.DataFrame([[x.Right,float(x.Strike),x.Expiry,float(x.BidPrice),float(x.AskPrice)] for x in optionchain],
+ index=[x.Symbol.Value for x in optionchain],
+ columns=['type(call 0, put 1)', 'strike', 'expiry', 'ask price', 'bid price'])
+ self.Log(str(df))
+
+
+
+
+
+
Symbol
+
type(call 0, put 1)
+
Strike
+
Expiry
+
Ask Price
+
Bid Price
+
+
+
+
+
GOOG 170217C00780000
+
0
+
780.0
+
2017-02-17
+
26.4
+
27.9
+
+
+
GOOG 170120P00782500
+
1
+
782.5
+
2017-01-20
+
14.7
+
16.3
+
+
+
GOOG 170120C00782500
+
0
+
782.5
+
2017-01-20
+
9.4
+
10.2
+
+
+
GOOG 170120P00780000
+
1
+
780.0
+
2017-01-20
+
13.4
+
15.0
+
+
+
GOOG 170120C00780000
+
0
+
780.0
+
2017-01-20
+
10.6
+
11.5
+
+
+
GOOG 170217P00780000
+
1
+
780.0
+
2017-02-17
+
28.9
+
30.8
+
+
+
GOOG 170120P00777500
+
1
+
777.5
+
2017-01-20
+
12.2
+
13.7
+
+
+
GOOG 170120C00777500
+
0
+
777.5
+
2017-01-20
+
11.8
+
12.9
+
+
+
+
+
+ Here we give an example of how to find ATM, ITM OTM contracts for trading. First, we need to extract the OptionChain from OptionChains according to symbols we added in Initialize step. Secondly, we extract ATM, ITM and OTM contracts by using UnderlyingLastPrice and Strike properties. Note here the strikes of ATM options are not exactly the same as the market price of underlying stocks, thus here we first sort the contracts by the absolute values of the difference between the UnderlyingLastPrice and the Strike. Then we choose the contract with the minimum absolute value as the ATM contract.
+
+
+
+
+
for i in slice.OptionChains:
+ if i.Key != self.symbol: continue
+ optionchain = i.Value
+ # differentiate the call and put options
+ call = [x for x in optionchain if x.Right == 0]
+ put = [x for x in optionchain if x.Right == 1]
+ # choose ITM call contracts
+ contracts = [x for x in call if x.UnderlyingLastPrice - x.Strike > 0]
+ # or choose ATM contracts
+ contracts = sorted(optionchain, key = lambda x: abs(x.UnderlyingLastPrice - x.Strike))[0]
+ # or choose OTM call contracts
+ contracts = [x for x in call if x.UnderlyingLastPrice - x.Strike < 0]
+ # sort the contracts by their expiration dates
+ contracts = sorted(contracts, key = lambda x: x.Expiry, reverse = True)
+
+
+
+ Finally, we trade the options by using the contract's symbol.
+
+
+
+
+
if len(contracts) == 0: continue
+# trade the contracts with the farthest expiration
+symbol = contracts[0].Symbol
+self.MarketOrder(symbol, 1)
+self.MarketOnCloseOrder(symbol, -1)
+
+
diff --git a/06 Introduction to Options[]/02 QuantConnect Options API/05 Algorithm.html b/06 Introduction to Options[]/02 QuantConnect Options API/05 Algorithm.html
new file mode 100755
index 0000000..e485feb
--- /dev/null
+++ b/06 Introduction to Options[]/02 QuantConnect Options API/05 Algorithm.html
@@ -0,0 +1,9 @@
+
+ This simple example demonstrates how you can inspect the option chain to pick a specific option contract to trade.
+
+
+
+
+
+
+
diff --git a/06 Introduction to Options[]/02 QuantConnect Options API/06 Summary.html b/06 Introduction to Options[]/02 QuantConnect Options API/06 Summary.html
new file mode 100755
index 0000000..10bbff9
--- /dev/null
+++ b/06 Introduction to Options[]/02 QuantConnect Options API/06 Summary.html
@@ -0,0 +1,4 @@
+
+ After mastering the basic knowledge of options market, this tutorial we take a close at how to use Quantconnect to customize your own options trading. For example, how you can access an option chain, how to view the details of the contract as a Python data frame, and the most important how to trade the specific option contract.
+ Next chapter we will examine some important topics of options like the payoff, Put-Call parity, and the synthetic positions. By learning all those concepts, we will start some brief hedging strategies involving options.
+
diff --git a/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/01 Introduction.html b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/01 Introduction.html
new file mode 100755
index 0000000..6684954
--- /dev/null
+++ b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ In this chapter, we will discuss the option's payoff if you long or short the options. Then we discuss the put-call parity which is a relationship between the price of a European call option, the price of a European put option, and the underlying stock price. In addition, an application of put-call parity in arbitrage trading strategies was demonstrated.
+
diff --git a/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/02 Option Payoff.html b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/02 Option Payoff.html
new file mode 100755
index 0000000..7f3f36a
--- /dev/null
+++ b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/02 Option Payoff.html
@@ -0,0 +1,75 @@
+
+ Consider Google(NASDAQ: GOOG) is trading at $910 now and you are bullish on this stock and expect it to rise over the next three months. The minimum capital requirement to buy 100 shares of GOOG is $90000 but you only have limited capital for stock investors. You could buy 1 call option contract written on GOOG which expires after three months with a $900 strike price. If GOOG rises to $950 in three months, you can get ($950 - $900) *100 = $5000 by paying just a small amount of premium instead of a full cost of shares. Even if the share price of GOOG falls below $900, you lose only the premium. This is one of the biggest benefits of trading options and is also called the financial leverage. Without borrowing the capital, you can control a larger number of shares by investing in options other than purchasing the shares themselves.
+
+
+ From the above example, the investor will buy a European call if he has a bullish view on the market and believes the underlying stock price will be above the strike price at the expiry date. He will make money when the underlying price goes up and lose when it goes down. The payoff of a call option at T is
+
+\[Call_{payoff}=max[0,S_T-K]\]
+
+ On the other hand, an investor will buy a European put if he is bearish about the market and believes that the underlying stock price will be below the strike at the expiry date. He will make money when the underlying price goes down and lose when it goes up. The European put payoff at T is
+
+\[Put_{payoff}=max[0,K-S_T]\]
+
+Where \(S_T\) is the price of underlying assets at maturity. K is the strike price.
+
+
+ We use the GOOG option contract to show the call and put option payoff. The current share price of GOOG is $945 at 07/12/2017.
+
+
+
+
+
Contract Name
+
Type
+
Expire Date
+
Strike
+
Premium
+
+
+
+
+
GOOG170714C00940000
+
Call
+
07/14/2017
+
$940
+
$7.5
+
+
+
GOOG170714P00960000
+
Put
+
07/14/2017
+
$960
+
$19.5
+
+
+
+If you long these two options, the payoff at expiration date would be as follows
+
+
+
import matplotlib.pyplot as plt
+%pylab inline
+price = np.arange(900,1000,1)
+strike = 940
+premium = 7.5
+payoff = [max(-premium, i - strike-premium) for i in price]
+plt.plot(price, payoff)
+plt.xlabel('Price at T S_T ($)')
+plt.ylabel('payoff')
+plt.title('Call option Payoff at Expiry')
+plt.grid(True)
+price = np.arange(900,1000,1)
+strike = 960
+premium = 19.5
+payoff = [max(-premium, strike - i -premium) for i in price]
+plt.plot(price, payoff)
+plt.xlabel('Price at T S_T ($)')
+plt.ylabel('payoff')
+plt.title('Put option Payoff at Expiry')
+plt.grid(True)
+
+
+
+
+
+
+ The above payoff diagrams illustrate the cash payoff on an option at the expiration date. For a call option, the net payoff is negative if the price of the underlying asset is less than the strike price(The negative payoff comes from the premium). If the underlying price exceeds the strike price, the gross payoff is the price of the underlying asset minus the strike price and the premium. For a put option, the net payoff is positive if the underlying price is less than the strike price. If the price of the underlying asset exceeds the strike price, the gross payoff is negative because you pay the premium for purchasing the contracts.
+
diff --git a/Tutorial Series/Introduction to Options/Tutorial03 Put-Call Parity and Arbitrage Strategies.ipynb b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/02 Put-Call Parity and Arbitrage Strategies.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Options/Tutorial03 Put-Call Parity and Arbitrage Strategies.ipynb
rename to 06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/02 Put-Call Parity and Arbitrage Strategies.ipynb
diff --git a/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/03 Put-Call Parity.html b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/03 Put-Call Parity.html
new file mode 100755
index 0000000..2f936a2
--- /dev/null
+++ b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/03 Put-Call Parity.html
@@ -0,0 +1,37 @@
+
+ Put-Call parity describes the relationship between the price of a European put and a call options with the identical strike price K, expiry T and their underlying stock's price. Next, we will demonstrate how to derive the put-call parity according to John Hull's book.
+
+
We consider two portfolios as follows,
+
+ Portfolio A: buy one European call option (underlying non-dividend-paying stock S, strike K, expiring at T) plus a zero-coupon bond which pays K at T
+
+
+ Portfolio B: sell one European put option (underlying non-dividend-paying stock S, strike K, expiring at T) plus one share of underlying stock S
+
+
+
+
+
Payoff
+
\(S_t > K\)
+
\(S_t < K\)
+
+
+
Portfolio A
+
\(S_t - K+K=S_t\)
+
\(0+K=K\)
+
+
+
Portfolio B
+
\(0+S_t =S_t\)
+
\(K-S_t+S_t=K\)
+
+
+
+
+ From the above table we can see that in all states, Portfolio A has the same payoff at the options' expiration date as Portfolio B. Thus the present value of two portfolios must be the same. Otherwise, an investor can make risk-free profits by purchasing the undervalued portfolio and selling the overvalued portfolio and holding the position to maturity. Then we have the price equality(suppose the present price of stock S is \(S_0\) )
+
+\[Price_{call}+Ke^{-rT}=Price_{put}+S_0\]
+
+ If the dividend is paid during the option holding period, the shareholder of the stock would receive that additional amount, but the option owner would not. For a dividend-paying stock, the put-call parity relationship is(D is the present value of dividends):
+
+\[Price_{call}+D+Ke^{-rT}=Price_{put}+S_0\]
diff --git a/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/04 Synthetic Positions.html b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/04 Synthetic Positions.html
new file mode 100755
index 0000000..85ce65c
--- /dev/null
+++ b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/04 Synthetic Positions.html
@@ -0,0 +1,31 @@
+
+
+
+
+ Through the put-call parity, we can find that there is a synthetic equivalent for all of the basic positions in underlying assets and its corresponding options. In other words, the risk profile(the possible profit or loss) of any position can be exactly duplicated with a complex combination of the other basic positions. These equivalents are synthetic underlying and synthetic options.
+
+The rule for creating synthetics is that the strike price and expiration date, of the calls and puts, must be identical. For creating synthetics, with both the underlying stock and its options, the number of shares of stock must equal the number of shares represented by the options.
+
+ There are many arbitrage strategies based on the idea of the synthetic position. Here we demonstrate two of the most common strategies: the conversion and the reversal.
+
+
+
+
+
Strategy
+
Content
+
+
+
Conversion
+
Synthetic Short Position: short call + long put
+The actual stock position: long the underlying stocks
+
+
+
Reversal
+
Synthetic Long Position: long call + short put
+The actual stock position: short the underlying stocks
+
+
+
+
+ Traders use conversions when options are overpriced relative to the underlying stock and use reversals when options are relatively underpriced.
+
diff --git a/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/05 Algorithm.html b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/05 Algorithm.html
new file mode 100755
index 0000000..b196a80
--- /dev/null
+++ b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/05 Algorithm.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/06 Summary.html b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/06 Summary.html
new file mode 100755
index 0000000..4be79e7
--- /dev/null
+++ b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/06 Summary.html
@@ -0,0 +1,6 @@
+
+ In this chapter, we derived an important relationship between the prices of European put and call options that have the same strike price and time to maturity by constructing two portfolios. Then we described the synthetic positions, a common concept which is always used in arbitrage trading strategies. Finally two simple arbitrage strategies conversion and reversal are demonstrated on QC platform to help you get a better understanding of how to implement algorithms with simple option mechanism.
+
+
+ Next chapter we will dig into the famous option pricing model-Black Sholes Merton Model and discuss how to apply BSM in European options pricing.
+
diff --git a/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/07 References.html b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/07 References.html
new file mode 100644
index 0000000..76391e6
--- /dev/null
+++ b/06 Introduction to Options[]/03 Put-Call Parity and Arbitrage Strategies/07 References.html
@@ -0,0 +1,9 @@
+
+
+ Bouzoubaa M, Osseiran A. Exotic options and hybrids: A guide to structuring, pricing and trading[M]. John Wiley & Sons, 2010.
+
+
+ Put-Call Parity and Arbitrage Opportunity, Jim Graham, February 6, 2017, Online Copy
+
+
+
diff --git a/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/01 Introduction.html b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/01 Introduction.html
new file mode 100755
index 0000000..ae313cc
--- /dev/null
+++ b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ Last few chapters we introduced the basic principles and mechanism of options trading. We already knew what an option contract is and the basic relationship between call and put options' price. But how do these contracts traded in the exchange are being priced and where does the option premium come from? In the next few chapters, we will discuss the pricing of options.
+
diff --git a/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/02 Brownian motion.html b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/02 Brownian motion.html
new file mode 100755
index 0000000..f0cf290
--- /dev/null
+++ b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/02 Brownian motion.html
@@ -0,0 +1,65 @@
+
+ In order to value the derivatives like options, the most significant part is to find a model to represent the underlying stock price so that we can price the options based on the underlying price. We usually use the stochastic process to model the security price.
+
+
+ First, you need to know what the stochastic process is. We say any variable that changes over time in an uncertain way follows a stochastic process. The price of a certain stock at a future time t is unknown at the present so it is a random variable \(S_t\). Then we can think of the movement path of the stock price is a stochastic process since\(S_t\) is a random variable at each time t in the future.
+
+
+ Markov process is a special case of the stochastic process. It means that only the current value of a random variable is relevant for future prediction. In general, we usually assume that the stock price follows a Markov stochastic process, which means only the current stock price is relevant for predicting the future price, it is not correlated with the past price.
+
+
+ Brownian motion is a particular type of Markov stochastic process or we can think of it as a family of random variables \(\left\{W_t\mid t\geq0\right\}\) indexed by time t. The one-dimensional Brownian motion is called the Wiener Process. (Brownian motion is n-dimensional Wiener processes which mean each dimension is just a standard Wiener process). It has the following properties:
+
+
+
\(W_0=0\)
+
For \(t\geq0\) and \(\Delta t\geq0\), the increment \(W_{t+\Delta t}-W_t\) is normally distributed with mean 0 and standard deviation \(\sqrt{\Delta t}\) .
+
For any partitions \(0\leq t_1<t_2<\cdot\cdot\cdot <t_n\), the increments \(W_{t_1}- W_{t_0},W_{t_2}-W_{t_1},\cdot\cdot\cdot, W_{t_n}-W_{t_{n-1}}\) are independent random variables.
+
With probability 1, the function W(t) is continuous at t.
+
+
+ Intuitively understanding of the definition, Wiener process has independent and normally distributed increments and has continuous sample path.
+
+
+ Next, we simulate the Wiener process and plot the paths attempting to gain an intuitive understanding of a stochastic process. Each path is an independent Wiener process.
+
+
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+%pylab inline
+def wiener_process(T, N):
+ """
+ T: total time
+ N: The total number of steps
+ """
+ W0 = [0]
+ dt = T/float(N)
+ # simulate the increments by normal random variable generator
+ increments = np.random.normal(0, 1*np.sqrt(dt), N)
+ W = W0 + list(np.cumsum(increments))
+ return W
+
+N = 1000
+T = 10
+dt = T / float(N)
+t = np.linspace(0.0, N*dt, N+1)
+plt.figure(figsize=(15,10))
+for i in range(5):
+ W = wiener_process(T, N)
+ plt.plot(t, W)
+ plt.xlabel('time')
+ plt.ylabel('W')
+ plt.grid(True)
+
+
+
+
+
+
+ In ordinary calculus,\(\text{d}x=a\ \text{d}t\) is used to indicate that\(\Delta x=a\Delta t\) as \( \Delta t\rightarrow0\). We use the similar notation here. The mean change per unit time for a stochastic process is known as the drift rate and the variance per unit time is known as the variance rate. We can write the derivative of Wiener process over time t in this form: \(dW_t\).A standard Wiener process has a drift rate (i.e. average change per unit time) of 0 and a variance rate of 1 per unit time. If we extend the concept of Wiener process to a generalized Wiener process in the form: \(\text d\ x_t=a\ \text d t+b\ \text dW_t\). The drift rate and the variance rate can be set equal to any chosen constant. If we write it as approximate discrete form as
+
+ Where ε follows the standard normal distribution N(0,1). Thus \(\Delta x\) has normal distribution with the mean being \(a\Delta t\), variance being \(b^2\Delta t\). And because \(\Delta t\) is independent, from time 0 to time T, the change in the value of x is just the sum of \(\Delta x\) in each small time interval. It means that the change in the value of x follows the normal distribution \(N(aT,b^2T)\).
+
diff --git a/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/03 Modeling Stock Price as a Stochastic Process.html b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/03 Modeling Stock Price as a Stochastic Process.html
new file mode 100755
index 0000000..8cec45a
--- /dev/null
+++ b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/03 Modeling Stock Price as a Stochastic Process.html
@@ -0,0 +1,47 @@
+
+ Then we go back to the stock price. If we use the generalized Wiener process to model the stock price, for example, the share price of a stock is $30 now, then the percentage change in price from now to say the end of this year is normally distributed with constant mean and variance. But there is a problem that for normal distribution assumption of return, there is the possibility that the stock price will be negative this is unrealistic for stock prices. For example, this percentage change could be -1.1, which means the stock price at the end of the year is -$3.
+
+
+ On the other hand, if the spot price is small for a stock, then it tends to have small increments in price over a given time interval, on the contrary, stocks with high prices tend to have much larger increments in price on the same interval. But Wiener process has a variance which depends on just the time interval but not on the price itself. Thus it is not appropriate to assume that a stock price follows a generalized Wiener process with constant drift rate and variance rate.
+
+
+ In order to characterize the dynamics of a stock price process and fix this problem, we model the proportional increase in the stock price by using the stochastic differential equation (SDE):
+
+ Where \(dS_t\) is the change in the stock price over a short time period from \(t\) to \(t+\Delta t\). \(μ\) is the drift term and can be deemed as the annual expected level of the stock return, \(σ\) is the annual volatility of the stock. Here \(dS_t\) at different time \(t\) are independent, which means today's price change is independent with tomorrows change. \(W_t\) is a standard Wiener process (1) we discussed above.
+
+
+
+ Now in the above equation, the drift and variance rate of stock price \(S\) is not only correlated with time \(t\) but also a function of both \(S\) itself and time \(t\).
+
+ Here \(ln(S_t)\) follows a generalized Wiener process as which has constant drift rate and variance rate. That means the change in \(ln(S_t)\) during time interval \(\Delta t\) is normally distributed. This is the lognormal property of stock prices.
+
+ According to the above equation, we know the stock price at time \(T\) should always be greater than 0 and the problem of having a negative price is fixed. Thus we say the stock price \(S\) is a Geometric Brownian motion because the logarithm of \(S\) follows a Brownian motion.
+
diff --git a/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/04 Monte Carlo Simulation of Stock Price.html b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/04 Monte Carlo Simulation of Stock Price.html
new file mode 100755
index 0000000..184bb1f
--- /dev/null
+++ b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/04 Monte Carlo Simulation of Stock Price.html
@@ -0,0 +1,32 @@
+
+ We apply this technique to model stock prices in order to look at the potential evolution of stock prices over time and then demonstrate how to price European options. Here we use Google as an example. Suppose today is 07/31/2017 and that the share price of GOOG is $930.5. We use the historical close price from 01/2015 to 07/2017 to compute the historical annual return and volatility as the \(\mu\) and \(sigma\) parameters. (Note, we do not need to concern with the detailed determinants of \(\mu\) because the value of options written on a stock is, in general, is independent of \(\mu\). In contrast, the stock price volatility \(\sigma\) is of crucial importance to the determination of the value of options). Consider GOOG that pays no-dividends, has an expected return 39.64% per annum with continuous compounding and a volatility of 23.44% per annum. Observe today’s price $903.5 per share and with \(∆t\) = 0.001 yr. Then we apply Monte Carlo to simulate 500 price paths in the next three months.
+
+
diff --git a/Tutorial Series/Introduction to Options/Tutorial04 Stochastic Processes and Monte Carlo Method.ipynb b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/04 Stochastic Processes and Monte Carlo Method.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Options/Tutorial04 Stochastic Processes and Monte Carlo Method.ipynb
rename to 06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/04 Stochastic Processes and Monte Carlo Method.ipynb
diff --git a/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/05 Monte Carlo Simulation of European Options.html b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/05 Monte Carlo Simulation of European Options.html
new file mode 100755
index 0000000..5a438a9
--- /dev/null
+++ b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/05 Monte Carlo Simulation of European Options.html
@@ -0,0 +1,37 @@
+
+ Monte Carlo simulation is a commonly used method for derivatives pricing where the payoff depends on the history price of the underlying asset.
+
+
+ The essence of using Monte Carlo method to price the option is to simulate the possible paths for stock prices then we can get all the possible value of stock price at expiration.
+
+
+
First, we need to divide the maturity T of options into N small time intervals, the length of each time interval is \(\Delta t\), N is the number of steps
+
Sample the possible random paths for the stock price according to equation (3) and get the stock price \(S_T\)at maturity T.
+
Calculate the payoff of options according to the \(S_T\)
+
Discount the payoff at the risk-free rate to get one estimate of options' price
+
Repeat the step 1 to 4 for a reasonable number of times and get many estimates of options price and then the average of these price estimates is the final options price.
+
+
+ In option pricing, Monte Carlo simulations use the risk-neutral valuation result. More specifically, sample the paths to obtain the expected payoff in a risk-neutral world (The expected annual return rate and the risk-free annual rate should be the same in order to get the correct estimation of the option) and then discount this payoff at the risk-neutral rate.
+
+ Suppose the risk-free rate is 1%. A European call option with strike price being $785 and expires in 100 days, the spot price is $927, the premium by using Monte Carlo method is $149.
+
diff --git a/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/06 Summary.html b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/06 Summary.html
new file mode 100755
index 0000000..f9ac402
--- /dev/null
+++ b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/06 Summary.html
@@ -0,0 +1,6 @@
+
+ In this chapter, we modeled stock price with the stochastic process. The stochastic process usually assumed for a stock price is geometric Brownian motion.The Black–Scholes–Merton model, which we cover in the next chapter, is based on the geometric Brownian motion assumption. Under this process, the logarithm of stock return in a small period of time is normally distributed and the returns in two nonoverlapping periods are independent.
+
+
+ In the second part of the tutorial, we applied Monte Carlo method to simulate the stock price in order to gain an intuitive understanding of the stochastic process followed by stock price. Then we discussed how to use Monte Carlo method to price the options based on the underlying prices paths.
+
diff --git a/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/07 References.html b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/07 References.html
new file mode 100644
index 0000000..55387f6
--- /dev/null
+++ b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/07 References.html
@@ -0,0 +1,5 @@
+
+
+ Hull J C. Options, futures, and other derivatives[M]. Pearson Education India, 2006.
+
+
diff --git a/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/01 Introduction.html b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/01 Introduction.html
new file mode 100755
index 0000000..61306f2
--- /dev/null
+++ b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ In the last chapter, we modeled the stock price with the Geometric Brownian motion. The logarithm of return \(\text{ln}(S_T/S_0)\) follows the normal distribution \(N\left[(\mu-\sigma^2/2)T,\sigma^2T\right]\). It means the logarithm of stock price\(\text{ln}(S_T)\)follows the normal distribution \(N\left[\text lnS_0+(\mu-\sigma^2/2)T,\sigma^2T\right]\). Based on this basic assumption, in this chapter, we will talk about a famous option pricing model: Black Scholes Merton Model.
+
diff --git a/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/02 Determinants of Option Price.html b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/02 Determinants of Option Price.html
new file mode 100755
index 0000000..5152d68
--- /dev/null
+++ b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/02 Determinants of Option Price.html
@@ -0,0 +1,11 @@
+
+ In different kinds of asset pricing model like bond pricing, enterprise valuation, the most commonly used valuation method is to calculate the present value of the expected cash flows of that asset. But options have some characteristics that are different from the common asset. For example, the options value depends on its underlying asset. In addition, the cash flow on options are not constant over periods but depends on the occurrence of specific events which are not predictable. In fact, the value of the option is determined by lots of variables.
+
+
+
the underlying price: Change in the value of the underlying asset is the most important factor which affects the options price. For the call option, holders can earn profit from the price rising and put option holders earn profits from the price decline. Therefore, call options become more valuable as the underlying prices increase while the put options will become less valuable.
+
The volatility of the underlying asset: Volatility is a measure of the degree of fluctuation of the underlying stock price. It is a forward volatility, which means it is a prediction of how much the stock price of the underlying will move in the future over a certain period of time. The higher the predicted volatility is, the higher the probability that the underlying price will move a lot. Thus the greater will the value of the option is both for calls and puts. We will further discuss different types of volatilities in the subsequent tutorials.
+
The strike price of the option: Call options gain profit when stock prices greater than the strike, it is easy to understand that the higher the strike price is for the call option, the fewer profits the holder can get, the less valuable of the call option. Thus for the put options, options with higher strike price are more valuable.
+
Time to expiration: If the current date is t, the expiration date of the option contract is T. Then the time to expiration is T-t. For v=both call and put options, the longer time to expiration means there are more changes for the function of stocks prices, and higher probability for the option holders to gain profits from price movement.
+
The risk-free interest rate: As interest rates increase, the expected return required by investors from the stock tends to increase. On the other hand, the present value of discounted cash flow will decrease. Thus the increase in interest rate will increase the call option price and will decrease the put option price.
+
The dividend yield: After the dividends paid, the share price of the stock will decrease. During the options holding period, the decline in underlying price is unfavorable for call options holder. Therefore, the increase in dividend yield will decrease the price of call options and increase the price of put options.
+
diff --git a/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/03 Factors in BSM model.html b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/03 Factors in BSM model.html
new file mode 100755
index 0000000..3e90225
--- /dev/null
+++ b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/03 Factors in BSM model.html
@@ -0,0 +1,51 @@
+
+ After we get an intuition about affecting factors of the options price, we will introduce the BSM option pricing model. The Black-Scholes model for pricing stock options was developed by Fischer Black, Myron Scholes and Robert Merton in the early 1970’s.
+
+
+ First, we introduce the factors in the model. For all the factors listed below, only volatility is not known. There are many types of volatilities. Then which volatility should be used is a critical question in option pricing model. We will further discuss this part in the next few chapters.
+
+ There are some details we need to pay attention to about the input of BSM model. Firstly, the model works in continuous time, rather than discrete time. Therefore the risk-free rate r has to be modified to the continuous form. Secondly, the time to expiration should be converted to year. The volatility is the annual volatlity.
+
diff --git a/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/04 Model Assumptions.html b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/04 Model Assumptions.html
new file mode 100755
index 0000000..ba6786f
--- /dev/null
+++ b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/04 Model Assumptions.html
@@ -0,0 +1,12 @@
+
+ The market assumptions behind the Black–Scholes formula for pricing European options are as follows:
+
+
+
The volatility of the underlying assets is constant over time
+
The underlying asset price follows the lognormal distribution, this means that the log-returns of stock prices are normally distributed
+
The underlying asset can be traded continuously
+
The underlying stock does not pay dividends during the option's life. But the basic Black-Scholes model was later adjusted for dividends, here we demonstrate the later version with dividend yields.
+
There are no transaction costs or taxes
+
All securities are perfectly divisible, meaning that it is possible to buy any fraction of a share
+
The risk-free rate of interest, r, is constant and the same for all maturities
+
diff --git a/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/05 Model Equations.html b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/05 Model Equations.html
new file mode 100755
index 0000000..d389eac
--- /dev/null
+++ b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/05 Model Equations.html
@@ -0,0 +1,66 @@
+
+ The derivation of the Black-Scholes model is beyond the scope of this research, we only show the formula here. The basic principle is based on the idea of creating a portfolio of the underlying asset and the riskless asset with the same cash flows and hence the same cost as the option being valued. Then we get the Black–Scholes–Merton differential equation. The solutions to the differential equation are the Black-Scholes-Merton formulas for the price of European call and put options
+
+ N(x) is the cumulative probability distribution function for a variable with a standard normal distribution. It can be calculated by the integral of the probability density function of standard normal distribution from 0 to x. In Python, you can use the norm.pdf(x) in spicy.stats library. For the following chart, we plot the probability density curve of the standard normal distribution. For example, N(-1) is the area of the left hand of the red line under the curve.
+
+
+
+
import scipy.stats as sp
+mu = 0
+variance = 1
+x = np.linspace(mu-3*variance,mu+3*variance, 100)
+y = [sp.norm.pdf(i) for i in x]
+plt.plot(x,y)
+d = [-1]
+plt.plot(d*100,np.linspace(0,sp.norm.pdf(d), 100))
+
+
+
+
+ Then in our BSM model class, we will calculate the European call and put option prices by using BSM formula.
+
+
+
+
def n(self, d):
+ # cumulative probability distribution function of standard normal distribution
+ return norm.cdf(d)
+
+def dn(self, d):
+ # the first order derivative of n(d)
+ return norm.pdf(d)
+
+def d1(self):
+ d1 = (log(self.s / self.k) + (self.r - self.q + self.sigma ** 2 * 0.5) * self.T) / (self.sigma * sqrt(self.T))
+ return d1
+
+def d2(self):
+ d2 = (log(self.s / self.k) + (self.r - self.q - self.sigma ** 2 * 0.5) * self.T) / (self.sigma * sqrt(self.T))
+ return d2
+
+def bsm_price(self):
+ d1 = self.d1()
+ d2 = d1 - self.sigma * sqrt(self.T)
+ if self.type == 'c':
+ price = exp(-self.r*self.T) * (self.s * exp((self.r - self.q)*self.T) * self.n(d1) - self.k * self.n(d2))
+ return price
+ elif self.type == 'p':
+ price = exp(-self.r*self.T) * (self.k * self.n(-d2) - (self.s * exp((self.r - self.q)*self.T) * self.n(-d1)))
+ return price
+ else:
+ print "option type can only be c or p"
+
+a = BsmModel('c', 42, 35, 0.1, 90.0/365, 0.2)
+a.bsm_price()
+
+
+
+ For a call option which expires in 90 days and no dividends paid, the underlying price is $42, the strike is $35, the risk-free rate is 0.1, the volatility is 0.2. The price of this option is $6.157.
+
diff --git a/Tutorial Series/Introduction to Options/Tutorial05 Option Pricing Black Scholes Merton Model.ipynb b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/05 Option Pricing Black Scholes Merton Model.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Options/Tutorial05 Option Pricing Black Scholes Merton Model.ipynb
rename to 06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/05 Option Pricing Black Scholes Merton Model.ipynb
diff --git a/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/06 Summary.html b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/06 Summary.html
new file mode 100755
index 0000000..3c9ac3c
--- /dev/null
+++ b/06 Introduction to Options[]/05 Options Pricing Black Scholes Merton Model/06 Summary.html
@@ -0,0 +1,3 @@
+
+ This tutorial discussed factors affecting the options price and introduced a famous option pricing model including input parameters, assumptions and the formula.
+
diff --git a/06 Introduction to Options[]/06 The Greek Letters/01 Introduction.html b/06 Introduction to Options[]/06 The Greek Letters/01 Introduction.html
new file mode 100755
index 0000000..d8fd050
--- /dev/null
+++ b/06 Introduction to Options[]/06 The Greek Letters/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ Option Greeks measure the exposure of option price or option delta to movement of different factors such as the underlying price, time and volatility. In this tutorial we will discuss various Greeks, their meanings and their implications on the pricing and how to use them to hedge risks.
+
diff --git a/06 Introduction to Options[]/06 The Greek Letters/02 Delta.html b/06 Introduction to Options[]/06 The Greek Letters/02 Delta.html
new file mode 100755
index 0000000..dce03fa
--- /dev/null
+++ b/06 Introduction to Options[]/06 The Greek Letters/02 Delta.html
@@ -0,0 +1,81 @@
+
Definition
+
+ Delta is the rate of change of the option price with respect to the price of the underlying asset. It measures the first-order sensitivity of the price to a movement in stock price S. The option delta is 0.4 means that if the underlying moves by for example 1%, then the value of the option will move by 0.4 × 1%. For European options on an asset that provides a yield at rate q:
+
''' Greek letters for European options on an asset that provides a yield at rate q '''
+def delta(self):
+ d1 = self.d1()
+ if self.type == "c":
+ return exp(-self.q * self.T) * self.n(d1)
+ elif self.type == "p":
+ return exp(-self.q * self.T) * (self.n(d1)-1)
+
+
+
Impact Factors
+
+ Stock price, days remaining to expiration and implied volatility will impact the Delta.
+
+
+
Stock Price: Call option has a positive Delta range from 0 to 1. The Delta is positively correlated to underlying stock price change. While put option has a negative Delta ranges from -1 to 0, its Delta is negatively correlated with the underlying stock price change. At-the-money call options usually have a Delta near .50. At-the-money put options have a Delta near -.50.
+
Implied Volatility: Low implied volatility stocks will tend to have higher Delta for the in-the-money options and lower Delta for out-of-the-money options.
+
Days remaining to expiration: As expiration nears, in-the-money call Deltas increase toward 1.00, at-the-money call Deltas remain at around 0.5 and out-of-the-money call Deltas fall to 0 provided other inputs remain constant.
+
+
+ As a general rule, in-the-money options will move more than out-of-the-money options, and short-term options will react more than longer-term options to the same price change in the stock.
+
+
+ In order to demonstrate how those Greeks values change with the time to expiration and the underlying price, we choose 60*23 call options contracts with the stock price ranging from 10 to 70, time to expiration ranging from 0 to 1 year. The strikes of all the contracts are 40, the interest rates are 0.1, the volatilities are all 0.5. We construct the contracts data as a 23*60 matrix.
+
+
+
+
s = np.array([range(10,70,1) for i in range(23)])
+I = np.ones((shape(s)))
+time = arange(1,12.5,0.5)/12
+T = np.array([ele for ele in time for i in range(shape(s)[1])]).reshape(shape(s))
+
+contracts = []
+for i in range(shape(s)[0]):
+ for j in range(shape(s)[1]):
+ contracts.append(BsmModel('c',s[i,j],40*I[i,j],0.1*I[i,j], T[i,j],0.5*I[i,j]))
+delta = [x.theta() for x in contracts]
+gamma = [x.gamma() for x in contracts]
+delta = [x.delta() for x in contracts]
+vega = [x.vega() for x in contracts]
+rho = [x.rho() for x in contracts]
+
+gamma = np.array(gamma).reshape(shape(s))
+delta = np.array(delta).reshape(shape(s))
+theta = np.array(theta).reshape(shape(s))
+vega = np.array(vega).reshape(shape(s))
+rho = np.array(rho).reshape(shape(s))
+
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+from matplotlib import cm
+from matplotlib import animation
+
+z = delta
+fig = plt.figure(figsize=(20,11))
+ax = fig.add_subplot(111, projection='3d')
+ax.view_init(40,290)
+ax.plot_wireframe(s, T, z, rstride=1, cstride=1)
+ax.plot_surface(s, T, z, facecolors=cm.jet(delta),linewidth=0.001, rstride=1, cstride=1, alpha = 0.75)
+ax.set_zlim3d(0, z.max())
+ax.set_xlabel('stock price')
+ax.set_ylabel('Time to Expiration')
+ax.set_zlabel('delta')
+m = cm.ScalarMappable(cmap=cm.jet)
+m.set_array(z)
+cbar = plt.colorbar(m)
+
+
+
+
+
+ The color of the graph above represents delta value.
+
diff --git a/06 Introduction to Options[]/06 The Greek Letters/03 gamma.html b/06 Introduction to Options[]/06 The Greek Letters/03 gamma.html
new file mode 100755
index 0000000..5a71535
--- /dev/null
+++ b/06 Introduction to Options[]/06 The Greek Letters/03 gamma.html
@@ -0,0 +1,37 @@
+
+ Gamma is the rate of change of the portfolio's delta with respect to the underlying asset's price. It represents the second-order sensitivity of the option to a movement in the underlying asset’s price.
+
+
+ Long options, either calls or puts, always yield positive Gamma. Gamma is higher for options that are at-the-money and closer to expiration because the Delta of the near term options move toward either 0 or 1.00 is imminent. Deeper-in-the-money or farther-out-of-the-money options have lower Gamma as their Deltas already approached 0 or 1.00 (or 0 or -1.00 for puts) and will not change as quickly with movement in the underlying. For European options:
+
+ The color of the graph above represents delta value.
+
diff --git a/06 Introduction to Options[]/06 The Greek Letters/04 vega.html b/06 Introduction to Options[]/06 The Greek Letters/04 vega.html
new file mode 100755
index 0000000..c7d3dc7
--- /dev/null
+++ b/06 Introduction to Options[]/06 The Greek Letters/04 vega.html
@@ -0,0 +1,39 @@
+
+ The Vega is the rate of change in the value of the option with respect to the volatility of the underlying asset.
+
+
+ Vega is always positive for long positions and is the same value for both puts and calls. Hence the option price always increases as the volatility increases. Vega for the European options:
+
diff --git a/06 Introduction to Options[]/06 The Greek Letters/05 Theta.html b/06 Introduction to Options[]/06 The Greek Letters/05 Theta.html
new file mode 100755
index 0000000..ecc937f
--- /dev/null
+++ b/06 Introduction to Options[]/06 The Greek Letters/05 Theta.html
@@ -0,0 +1,49 @@
+
+ Theta is the rate of change of the value of the option with respect to the passage of time. It is also referred to as the time decay of the portfolio.
+
+
+ The theta of holding long position of a call or a put option is usually negative. An option that loses 0.1% per day is said to have a Theta of −0.1%. For example, if we buy an OTM call option, the value of this call option decreases as time passes since the option has less time to expiry. If time passes with the price of the underlying asset and its volatility remaining the same, the passing of time will lower the value of the option. Theta for European Options
+
z = theta
+# facecolors aren't normalizing as might be expected
+# we need to normalize it to avoid all dark color for value under 0
+norm = matplotlib.colors.Normalize()
+fig = plt.figure(figsize=(20,11))
+ax = fig.add_subplot(111, projection='3d')
+ax.view_init(35,300)
+ax.plot_wireframe(s, T, z, rstride=1, cstride=1)
+ax.plot_surface(s, T, z, facecolors=cm.jet(norm(z)),linewidth=0.001, rstride=1, cstride=1, alpha = 0.9)
+ax.set_zlim3d(z.min(), z.max())
+ax.set_xlabel('stock price')
+ax.set_ylabel('Time to Expiration')
+ax.set_zlabel('rho')
+m = cm.ScalarMappable(cmap=cm.jet)
+m.set_array(z)
+cbar = plt.colorbar(m)
+
+
+
+
diff --git a/06 Introduction to Options[]/06 The Greek Letters/06 Rho.html b/06 Introduction to Options[]/06 The Greek Letters/06 Rho.html
new file mode 100755
index 0000000..85c4d45
--- /dev/null
+++ b/06 Introduction to Options[]/06 The Greek Letters/06 Rho.html
@@ -0,0 +1,37 @@
+
+ Rho is the rate of change of the value of a derivative with respect to the interest rate. It is usually small and not a big issue in practice unless the option is deep in-the-money and has a long horizon. The interest rate would matter because we need to discount a larger cash flow over a longer horizon. Rho for the European options:
+
+
+
diff --git a/Tutorial Series/Introduction to Options/Tutorial06 The Greek Letters.ipynb b/06 Introduction to Options[]/06 The Greek Letters/06 The Greek Letters.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Options/Tutorial06 The Greek Letters.ipynb
rename to 06 Introduction to Options[]/06 The Greek Letters/06 The Greek Letters.ipynb
diff --git a/06 Introduction to Options[]/06 The Greek Letters/07 Delta, Gamma and Vega Hedging.html b/06 Introduction to Options[]/06 The Greek Letters/07 Delta, Gamma and Vega Hedging.html
new file mode 100644
index 0000000..d087dfa
--- /dev/null
+++ b/06 Introduction to Options[]/06 The Greek Letters/07 Delta, Gamma and Vega Hedging.html
@@ -0,0 +1,6 @@
+
+ The delta of the underlying asset is always 1.0, the trader can hedge his positions by buying or selling the number of shares of the underlying asset indicated by the total delta. However, underlying asset positions have Gamma 0 because their Delta is always 1.00 (long) or -1.00 (short) and will not change. In addition, Vega of the underlying asset is also zero because the underlying asset's payoff doesn't vary depending on how its price moves (payoff is not contingent). Therefore, its price is not affected by price volatility.
+
+
+ In order to adjust Gamma and Vega, it is necessary to take a position in an option or other derivatives. However, if only one other derivative is added, either the Gamma risk or the Vega risk will be canceled out, but not both at the same time. Here we need to use 2 derivatives to make the portfolio delta, gamma, and vega neutral all at once. Note, Vega and Gamma for a portfolio is the sum of the vegas and Gammas of its constituents.
+
diff --git a/06 Introduction to Options[]/06 The Greek Letters/08 Summary.html b/06 Introduction to Options[]/06 The Greek Letters/08 Summary.html
new file mode 100755
index 0000000..928b210
--- /dev/null
+++ b/06 Introduction to Options[]/06 The Greek Letters/08 Summary.html
@@ -0,0 +1,3 @@
+
+ In this chapter we discussed various Greeks, their meanings and their implications on the pricing and hedging of derivatives. We also presented some useful formulas for calculating the Greeks value of European options and generated the plots to show how they changed with strikes and time to expirations. The Greeks letter is the sensitivity measure of options price to the market variables. Next chapter we will discuss another major risk measures: volatility.
+
diff --git a/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/01 Introduction.html b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/01 Introduction.html
new file mode 100755
index 0000000..c61ff28
--- /dev/null
+++ b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ The change of volatility can have a significant impact on the performance of options trading. In addition to the Vega we explained in Greeks letter chapter, this part of the volatility tutorial will discuss the concept of volatility, specifically, we discuss realized and implied volatility, their meanings, measurements, uses, and limitations.
+
diff --git a/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/02 Historical Volatility.html b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/02 Historical Volatility.html
new file mode 100755
index 0000000..2646bcc
--- /dev/null
+++ b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/02 Historical Volatility.html
@@ -0,0 +1,42 @@
+
1. Definition
+
+ It is a measurement of how much the price of the asset has changed on average during the certain period of time. In common, volatility is said to be the standard deviation of the return of assets price.
+
+
2. Calculation
+
+ Next we discuss how to estimate the historical volatility of the option empirically.
+
+ If we assume there are n trading days per year. Then the estimate of historical volatility per annum is
+
+\[std\times\sqrt{n}\]
+
+
+
+import pandas as pd
+from numpy import sqrt,mean,log,diff
+import quandl
+quandl.ApiConfig.api_key = 'NxTUTAQswbKs5ybBbwfK'
+goog_table = quandl.get('WIKI/GOOG')
+# use the daily data of Google(NASDAQ: GOOG) from 01/2016 to 08/2016
+close = goog_table['2016-01':'2016-08']['Adj. Close']
+r = diff(log(close))
+r_mean = mean(r)
+diff_square = [(r[i]-r_mean)**2 for i in range(0,len(r))]
+std = sqrt(sum(diff_square)*(1.0/(len(r)-1)))
+vol = std*sqrt(252)
+
+
+ An asset has a historical volatility based on its past performance as described above, investors can gain insight on the fluctuations of the underlying price during the past period of time. But it does not tell us anything about the volatility in the market now and in the future. So here we introduce the implied volatility.
+
diff --git a/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/03 Implied Volatility.html b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/03 Implied Volatility.html
new file mode 100755
index 0000000..55fe947
--- /dev/null
+++ b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/03 Implied Volatility.html
@@ -0,0 +1,71 @@
+
+ In contrast to historical volatility, the implied volatility looks ahead. It is often interpreted as the market’s expectation for the future volatility of a stock and is implied by the price of the stock’s options. Here implied volatility means it is not observable in the market but can be derived from the price of an option.
+
+
1. Definition
+
+ We use volatility as an input parameter in option pricing model. If we take a look at the BSM pricing, the theoretical price or the fair value of an option is P, where P is a function of historical volatility σ, stock price S, strike price K, risk-free rate r and the time to expiration T. That is \(P=f(\sigma,S,K,r,T)\). But the market price of options is not always the same with the theoretical price. Now in contrast, if we are given the market’s prices of calls and puts written on some asset and also the value of S, K, r, T. For each asset we can solve a new volatility that corresponds to the price of each option – the implied volatility. Then the implied volatility is \(\IV=f^{-1}(P,S,K,r,T)\).
+
+
+
2. Calculation
+
+ Here we use the bisection method to solve the BSM pricing equation and find the root which is the implied volatility. We use Yahoo Finance Python API to get the real time option data.
+
+ From the result above, the implied volatility of European call option (with premium c=0.3, S=3, K=3, r=0.032, T =30 days, d=0.01) is 0.87.
+
+
3. Factors Affecting Implied Volatility
+
+ According to the time value description in the first tutorial, in general, the more time to expiration, the greater the time value of the option. Investors are willing to pay extra money for zero intrinsic value options which have more time to expiration because more time increases the likelihood of price movement and fluctuations, it is the options will become profitable. Implied volatility tends to be an increasing function of maturity. A short-dated option often has a low implied volatility, whereas a long-dated option tends to have a high implied volatility.
+
diff --git a/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/04 Volatility Skew.html b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/04 Volatility Skew.html
new file mode 100755
index 0000000..fba17fd
--- /dev/null
+++ b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/04 Volatility Skew.html
@@ -0,0 +1,99 @@
+
+ For European options of the same maturity and the same underlying assets, the implied volatilities vary with the strikes. For a series of put options or call options, if we plot these implied volatilities for a series of options which have the same expiration date and the same underlying with the x-axis being the different strikes, we would get a convex curve. The shape of this curve is like people's smiling, it is being called the volatility. The shape of volatility smile depends on the assets and the market conditions.
+
+
+ Here we give an example how to plot the volatility smile by using the real time options data of SPDR S&P 500 ETF(NYSEARCA: SPY).
+
+
+
+
# download option data for all expiry months from Yahoo Finance
+# provide a formatted DataFrame with a hierarchical index
+opt = Options('spy', 'yahoo')
+opt.expiry_dates # list all the available expiration dates
+def IV_plot(opt,option_type,expiry_index):
+ expiry = opt.expiry_dates[expiry_index]
+ if option_type == 'c':
+ data = opt.get_call_data(expiry=expiry)
+ elif option_type == 'p':
+ data = opt.get_put_data(expiry=expiry)
+ r = 0.01 # risk free rate
+ d = 0.01 # continuous devidend yield
+ s = opt.underlying_price # data_call['Underlying_Price'] undelying price
+ expiry = data.index.get_level_values('Expiry')[0] # get the expiry
+ current_date = opt.quote_time # current_date = datetime.datetime.now() # get the current date
+ time_to_expire = float((expiry - current_date).days)/365 # compute time to expiration
+ premium = (data['Ask'] + data['Bid'])/2 # option premium
+ strike = list(data.index.get_level_values('Strike')) # get the strike price
+ IV = []
+ for i in range(len(data)):
+ IV.append(implied_vol(option_type, premium.values[i], s, strike[i], r, time_to_expire, d))
+
+ plt.figure(figsize=(16, 7))
+ a = plt.scatter(strike,IV, c='r', label="IV by solving BSM")
+ b = plt.scatter(strike,data['IV'],c = 'b', label="IV from Yahoo Finance")
+ plt.grid()
+ plt.xlabel('strike')
+ if option_type == 'c':
+ plt.ylabel('Implied Volatility for call option')
+ plt.legend((a,b), ("IV(call) by solving BSM", "IV(call) from Yahoo Finance"))
+ elif option_type == 'p':
+ plt.ylabel('Implied Volatility for put options')
+ plt.legend((a,b), ("IV(put) by solving BSM", "IV(put) from Yahoo Finance"))
+
+ return strike,IV
+k_call, IV_call = IV_plot(opt,'c',23)
+k_put, IV_put = IV_plot(opt,'p',23)
+plt.figure(figsize=(16, 7))
+e = plt.scatter(k_call,IV_call, c ='red', label="IV(call options)")
+f = plt.scatter(k_put,IV_put, c = 'black', label="IV(put options)")
+plt.xlabel('strike')
+plt.ylabel('Implied Volatility')
+plt.legend((e,f), ("IV (call options)", "IV (put options)"))
+
+
+
+ The current date is 08/14/2017. We plot the implied volatilities for SPY options which expire on 12/21/2018.
+
+
+
+
+ Plotting these implied volatilities across strikes gives us the implied volatility skew. For the shape of volatility smile, it should be a symmetry convex curve. But from the above chart, the implied volatility curve slopes downward to the right. This is referred to the skew, which means that options with low strikes have higher implied volatilities than those with higher strikes. The smile is not symmetry. The skew of a distribution is a measure of its asymmetry. Although the volatility skew is dynamic, in equity markets it is almost always a decreasing function of the strike. Other asset classes such as FX and commodities have differently shaped skews.
+
+
+ If we plot the call and put options implied volatility smile in the same chart for the same expiration date:
+
+
+
+ From the above chart, we can see the implied volatility for put options is higher than call options. Usually, put options trade for a higher price than call options, because traders place more risk in the short put positions, which raises the amount of reward they require to sell the position. Higher option prices signify an increase in risk and are represented by higher implied volatility levels derived from the option pricing model. Then we scattered all the implied volatilities of contracts across all the strikes.
+
+
+
+
+
opt = Options('spy', 'yahoo')
+r = 0.01 # risk free rate
+d = 0.01 # continuous devidend yield
+expiry_dates = [i for i in opt.expiry_dates if i > opt.quote_time.date()]
+current_date = opt.quote_time.date() ## get the current date
+s = opt.underlying_price # undelying price
+num_expiry = len(expiry_dates)
+IV = [] # (num_expiry * 3)-dimension list with each row being [time_to_expire, strike, implied_vol]
+
+for expiry_index in range(num_expiry):
+ data = opt.get_put_data(expiry=expiry_dates[expiry_index])
+ expiry = expiry_dates[expiry_index] # get the expiry
+ time_to_expire = float((expiry - current_date).days)/365 # compute time to expiration
+ premium = (data['Ask'] + data['Bid'])/2.0 # option premium
+ strike = data.index.get_level_values('Strike') # get the strike price
+ num_strike = len(data)
+ for j in range(num_strike):
+ IV.append([time_to_expire, strike[j], implied_vol('c', premium.values[j], s, strike[j], r, time_to_expire, d)])
+x= [IV[i][0] for i in range(len(IV))]
+y= [IV[i][1] for i in range(len(IV))]
+z= [IV[i][2] for i in range(len(IV))]
+fig = plt.figure(figsize=(20,11))
+ax = fig.add_subplot(111, projection='3d')
+ax.view_init(20,10)
+ax.scatter(x,y,z)
+
+
+
diff --git a/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/05 Volatility Surface.html b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/05 Volatility Surface.html
new file mode 100755
index 0000000..057ec70
--- /dev/null
+++ b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/05 Volatility Surface.html
@@ -0,0 +1,8 @@
+
+ By fixing the maturity and looking at the implied volatilities of European options on the same underlying but different strikes, we obtain the implied volatility skew or smile. The volatility surface is the three-dimensional surface when we plots the market implied volatilities of European options with different strikes and different maturities.
+
+
+ Through the interpolation method, we can generate the implied volatility surface of SPY options for both put and call options as follows:
+
+
+
diff --git a/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/06 The Reason for Volatility Skew.html b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/06 The Reason for Volatility Skew.html
new file mode 100755
index 0000000..3312b4b
--- /dev/null
+++ b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/06 The Reason for Volatility Skew.html
@@ -0,0 +1,5 @@
+
+ The volatility skew reveals that for put options, implied volatility is higher for deep OTM options and is decreasing as it moves toward ITM options. For call options, the implied volatility is higher for deep ITM options and is decreasing as it moves toward OTM options. From the demand and supply degree, the skew reflects that investors are more willing to buy deep OTM puts and ITM calls. Why there is volatility skew in the market?
+ First, the majority of the equity positions are long. Investors usually have two ways to hedge those long positions risks: Buying downside puts or selling upside calls. The increase in demand create increases in the price of downside puts and decreases in the price of upside calls. The volatility is a reflection of options price. Therefore the volatility of in-the-money put is higher and the volatility of in-the-money call is lower.
+ The second reason for volatility skew is that the market moves down faster than it moves up. The downside market move is riskier than the upside move. Thus the price of OTM puts is higher than OTM calls.
+
diff --git a/Tutorial Series/Introduction to Options/Tutorial07 Historical Volatility and Implied Volatility.ipynb b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/07 Historical Volatility and Implied Volatility.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Options/Tutorial07 Historical Volatility and Implied Volatility.ipynb
rename to 06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/07 Historical Volatility and Implied Volatility.ipynb
diff --git a/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/07 Summary.html b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/07 Summary.html
new file mode 100755
index 0000000..e8ac4a6
--- /dev/null
+++ b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/07 Summary.html
@@ -0,0 +1,4 @@
+
+ In this chapter, we discussed the historical volatility and the implied volatility. The historical volatility of an asset is the statistical measure we know as the standard deviation of the stock return series. The implied volatility of the same asset, on the other hand, is the volatility parameter that we can infer from the prices of traded options written on this asset. In contrast to historical volatility, which looks at fluctuations of asset prices in the past, implied volatility looks ahead. The two volatilities do not necessarily coincide, and although they may be close, they are typically not equal.
+ Now we know the constant volatility assumption in Black-Sholes-Merton model is not applicable in the real market because there is volatility skew for most options. In next chapter, we will introduce some volatility models to capture the volatility skew in options pricing.
+
diff --git a/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/08 References.html b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/08 References.html
new file mode 100644
index 0000000..34ceca1
--- /dev/null
+++ b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/08 References.html
@@ -0,0 +1,5 @@
+
+
+ Options Pricing: Intrinsic Value And Time Value, Jean Folger, Online Copy
+
+
diff --git a/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/01 Introduction.html b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/01 Introduction.html
new file mode 100755
index 0000000..b9beab6
--- /dev/null
+++ b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/01 Introduction.html
@@ -0,0 +1,3 @@
+
+ In the last chapter, we discussed two types of volatility: historical volatility and implied volatility. This chapter, we will further extend the concept of volatility and introduce the local volatility and the stochastic volatility.
+
diff --git a/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/02 Motivation.html b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/02 Motivation.html
new file mode 100755
index 0000000..6546510
--- /dev/null
+++ b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/02 Motivation.html
@@ -0,0 +1,13 @@
+
+ We already knew that volatility is a measure of the fluctuation degree of the underlying assets price series. As we discussed in the last chapter, historical volatility is the standard deviation of the price series during a certain period. It is a constant and represents the price movement in the past. However, the implied volatility is not based on the historical pricing data of stocks. It is the value of volatility parameter derived from the market quote of options in BSM pricing model. In contrast to historical volatility, implied volatility is forward-looking and varies with different options contracts.
+
+
+ In the Black–Scholes model, the asset’s price is modeled as a log-normal random variable, which means that the asset’s log-returns are normally distributed. One of the most significant assumptions in BSM model is that the volatility is a constant term over time.
+
+\[\sigma=\sigma_{implied}\]
+
+ But in the real world, it could be constant in a small time period but never constant in the long term. There is volatility skew for most options, which means the volatility is not constant across strikes.
+
+
+ One way to capture the volatility skew is to assume that the volatility itself is a random variable, this is the stochastic volatility model we will discuss next. On the other hand, the introduction of additional sources of randomness will increase the complexity of the model. Another way to capture the volatility skew but without introducing the additional source of randomness is the local volatility.
+
diff --git a/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/03 Local Volatility.html b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/03 Local Volatility.html
new file mode 100755
index 0000000..64f161e
--- /dev/null
+++ b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/03 Local Volatility.html
@@ -0,0 +1,35 @@
+
1. Definition
+
+ The constant volatility assumption in BSM model is not reasonable in most of the options pricing. The volatility skew tells us that the stock’s log-returns are actually not normally distributed. There exist some other kinds of distributions of stock price so that if we use this distribution to price the options, it would give the accurate options' price as we see in the market. The local volatility is implied in this non-normal distribution. Let's look at the definition of local volatility.
+
+
+ The local volatility of the underlying assets is a deterministic function of assets price and the time t.
+
+\[\sigma=\sigma(S_t,t)\]
+
+Therefore with the local volatility model, the stochastic process followed by the stock price is
+
+\[\text d S_t=\mu S_t\ \text d t+\sigma(S_t,t)\text d W_t\]
+
+If \(\sigma(S_t,t)=\sigma S_t\), then this is the case of BSM model with constant volatility\(\sigma\). Here we are not assuming the volatility is constant but a function of the asset price so the stock’s log-returns are not normally distributed anymore. There is only one source of randomness from the stock price: \(W_t\).
+
+
2. Model Calibration
+
+ How to obtain the function \(\sigma(S_t,t)\)? Finding the function \(\sigma(S_t,t)\) is known as the calibration of local volatility model. This is answered by the following Dupire's formula.
+
+ If we assume that we know all the observed market price of European call options C(T, K) for every strike K and every maturity T. Local volatility model calculates volatilities for a set of options with different combinations of strike prices and expiration dates. For a given date, time(t) and the underlying stock price(St), a local volatility is derived from the equation that options price calculated with the local volatility equals to the market options price.
+
+
+ Usually, we can only get a limited number of contracts with a few strikes and maturities, we can follow steps below to get the local volatility estimation:
+
+
First, use the available quoted price to calculate the implied volatilities.
+
Appy interpolation method to produce a smooth implied volatility surface.
+
Plug implied volatilities into BSM model to get all the market prices of European calls.
+
Calculate the local volatility according to Dupire formula. To avoid taking derivatives, we could use finite differences to approximate the derivative.
+
+\[\frac{\partial C}{\partial T}\approx\frac{C(K,T+\Delta T)-C(K,T-\Delta T)}{2\Delta t}\]
+
+\[\frac{\partial^2 C}{\partial K^2}\approx\frac{C(K-\Delta K,T)-2C(K,T)+C(K+\Delta K,T)}{(\Delta K)^2}\]
diff --git a/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/04 Stochastic Volatility.html b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/04 Stochastic Volatility.html
new file mode 100755
index 0000000..ba298ef
--- /dev/null
+++ b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/04 Stochastic Volatility.html
@@ -0,0 +1,159 @@
+
1. Definition
+
+
+ In stochastic volatility models, the asset price and its volatility are both assumed to be random processes and can change over time. There are many stochastic volatility models. Here we will present the most well-known and popular one: the Heston Model. In Heston model, the stock price is log-normal distributed, the volatility process is a positive increasing function of a mean-reversion process. That is
+
+ Where the instantaneous variance of the stock price \(v_t\) itself is a stochastic process.
+
+\(\lambda\) is the speed of reversion of \(v_t\) to its long-term mean \(\overline{v})\). We can think of\(\lambda\) as the rate at which the stock price variance reverts back to its long-term average value.
+
+\(\eta\) is the volatility of the variance process \(v_t\) (often called the volatility of volatility)
+
+\(W_{1,t}\) and \(W_{2,t}\) are two dependent Wiener processes with correlation coefficient \(\rho\).
+
2. Simulation of the Heston Process
+
+ We already discuss how to simulate the stock price process with Monte Carlo method in the introduction to stochastic process tutorial. In order to simulate the variance process, we need to write it into discrete form. The derivation can be found in paper Rouah F D. Euler and Milstein discretization.
+
+ Then, we take following steps to simulate Heston process: Given the value of \(v_t\) at time t, we first update to \(v_{t+\Delta t}\) using the formula above (Here note that in options pricing, Monte Carlo method uses risk-neutral result, so here the expected return \(\mu\) should equal the risk free rate r):
+
+
+
Given the value of \(v_t\) at time t, we first update to \(v_{t+\Delta t}\) using the formula above
+
We obtain \(S_{t+\Delta t}\) using\[S_{t+\Delta t}=S_t\ \text {exp}\left[(r-\frac{1}{2}v_t)\Delta t+\sqrt{v_t\Delta t}W_2\right]\]
+
To generate \(W_1\) and \(W_2\) with correlation \(\rho\), we first generate two independent standard normal variables \(Z_1\) and \(Z_2\), set \(W_1=Z_1\), then \[W_2=\rho Z_1+\sqrt{1-\rho^2}Z_2\]
+
+
+
+
+from numpy import sqrt, exp
+import numpy as np
+
+def mc_heston(option_type,S0,K,T,initial_var,long_term_var,rate_reversion,vol_of_vol,corr,r,num_reps,steps):
+ """
+ option_type: 'p' put option 'c' call option
+ S0: the spot price of underlying stock
+ K: the strike price
+ T: the maturity of options
+ initial_var: the initial value of variance
+ long_term_var: the long term average of price variance
+ rate_reversion: the mean reversion rate for the variance
+ vol_of_vol: the volatility of volatility(the variance of the variance of stock price)
+ corr: the correlation between the standard normal random variables W1 and W2
+ r: the risk free rate
+ reps: the number of repeat for monte carlo simulation
+ steps: the number of steps in each simulation
+ """
+ delta_t = T/float(steps)
+ payoff = 0
+ for i in range(num_reps):
+ vt = initial_var
+ st = S0
+ for j in range(steps):
+ w1 = np.random.normal(0, 1)
+ w2 = corr*w1+sqrt(1-corr**2)*np.random.normal(0, 1)
+ vt = (sqrt(vt) + 0.5 * vol_of_vol * sqrt(delta_t) * w1)**2 \
+ - rate_reversion * (vt - long_term_var) * delta_t \
+ - 0.25 * vol_of_vol**2 * delta_t
+ st = st * exp((r - 0.5*vt)*delta_t + sqrt(vt*delta_t) * w2)
+ if option_type == 'c':
+ payoff += max(st - K, 0)
+ elif option_type == 'p':
+ payoff += max(K - st, 0)
+
+ return (payoff/float(num_reps)) * (exp(-r*T))
+
+
+
3. Calibration of Model Parameters
+
+ The calibration of a model is the process of seeking the model parameters for which the model result best matches the market option data. This data usually consists of market quoted prices for European plain vanilla call options or of Black-Scholes implied volatilities derived from prices. Calibrating the Heston model is equivalent to solving the non-linear constrained optimization problem: Minimize the error between the market quotes of options and the options price estimated by Heston model. The object function could be the absolute value of the error or the absolute squared error. You can refer to this paper Parameters recovery via calibration in the Heston model for details of different error measure.
+
+
+ There are five parameters to be estimated in Heston model:
+
+
+
\(v_t\) : the initial value of the variance (Bounds of 0 and 1)
+
\(\overline{v}\) : the long term average variance of stock price (Bounds of 0 and 1)
+
\(\lambda\) : the speed of reversion (non-negativity)
+
\(\eta\) : the volatility of the volatility (non-negativity)
+
\(\rho\) : the correlation coefficient between two Wiener process (Bounds of -1 and 1)
+
+
+ Here we use QuantLib Python library to calibrate the parameters.
+
+
+ Let's look at how we can calibrate the Heston model to some market quotes. For example, let's say we are interested in trading SPDR S&P 500 ETF (SPY) options with 4-months maturity. Here we choose all the options contracts written on SPY expire in 4 months. We need the strikes and the market prices of those contracts and the underlying price as the input of our objective function to minimize.
+
+ When you get the parameter estimation, you can plug the parameter values into the Heston Monte Carlo options pricing model and get the price estimation with stochastic volatility. But as we already discussed for Heston model, the introduction of randomness of volatility increases the complexity of the estimation. No matter which error measure is chosen, the objective function is highly non-linear and far from being convex and we have 5 parameters in the model. All these drawbacks of Heston models will make the estimated parameter values quite sensitive the initial guess of parameters. Therefore options prices generated by the Heston model are also parameter sensitive. From the above, we can get a sense of how computationally expensive it can be to get accurate values of options in a stochastic volatility model.
+
diff --git a/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/05 Summary.html b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/05 Summary.html
new file mode 100755
index 0000000..6f28de7
--- /dev/null
+++ b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/05 Summary.html
@@ -0,0 +1,6 @@
+
+ In Black–Scholes, that volatility is assumed to be constant, it is not reasonable especially for some exotic options in which the option's payoff is based on the changing volatility. Therefore we introduced the two volatility models to capture the volatility skew. The first approach, local volatility, assumes that the volatility is a deterministic function of time and the underlying asset price. This function must be chosen as to match the observed market option prices. In another stochastic volatility models, the asset price and its volatility are both assumed to be random processes.
+
+
+ The calibration needs the market price of the Vanilla options. When we get the model estimation we can use these models to price exotic options.
+
diff --git a/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/06 References.html b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/06 References.html
new file mode 100644
index 0000000..750b8af
--- /dev/null
+++ b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/06 References.html
@@ -0,0 +1,17 @@
+
+
+ Bouzoubaa M, Osseiran A. Exotic options and hybrids: A guide to structuring, pricing and trading[M]. John Wiley & Sons, 2010.[/ref]
+
+
+ Gatheral J. The volatility surface: a practitioner's guide[M]. John Wiley & Sons, 2011
+
+
+ Rouah F D. Euler and Milstein discretization[J]. Documento de Trabajo, Sapient Global Markets, Estados Unidos, 2011. Online Copy
+
+
+ Escobar, Marcos, and Christoph Gschnaidtner. "Parameters recovery via calibration in the Heston model: A comprehensive review." Wilmott 2016.86 (2016): 60-81.
+
+
+ Modeling Volatility Smile and Heston Model Calibration Using QuantLib Python, Goutham Balaraman, online copy
+
+
diff --git a/Tutorial Series/Introduction to Options/Tutorial08 Local Volatility and Stochastic Volatility.ipynb b/06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/08 Local Volatility and Stochastic Volatility.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Options/Tutorial08 Local Volatility and Stochastic Volatility.ipynb
rename to 06 Introduction to Options[]/08 Local Volatility and Stochastic Volatility/08 Local Volatility and Stochastic Volatility.ipynb
diff --git a/07 Applied Options[]/01 Covered Call/01 Definition.html b/07 Applied Options[]/01 Covered Call/01 Definition.html
new file mode 100755
index 0000000..3c3a6a3
--- /dev/null
+++ b/07 Applied Options[]/01 Covered Call/01 Definition.html
@@ -0,0 +1,33 @@
+
+A Covered Call is an options strategy that involves both the underlying stock and an options contract. The trader buys (or already owns) a stock, then sells call options for the same amount of stock. The aim of the Covered Call is to profits from the option premium by selling calls written on the stock you already owned. At any time for US options or at expiration for European options, if the stock moves below the strike price, you can keep the premium and still maintain the stock position. If the price moves above the strike, the options contract will be exercised and you will have to sell the stock at the strike price but you will still keep the premium. The risk of a Covered Call also comes from the long stock position whose price could drop.
+
+
+The payoff is as follows:
+
+
+
+
+ import numpy as np
+ import matplotlib.pyplot as plt
+ %pylab inline
+ price = np.arange(110,230,1) # the stock price at expiration date
+ strike = 160 # the strike price
+ premium = 7.5 # the option premium
+ # the payoff of short call position
+ payoff_short_call = [min(premium, -(i - strike-premium)) for i in price]
+ # the payoff of long stock postion
+ payoff_long_stock = [i-strike for i in price]
+ # the payoff of covered call
+ payoff_covered_call = np.sum([payoff_short_call, payoff_long_stock], axis=0)
+ plt.figure(figsize=(20,11))
+ plt.plot(price, payoff_short_call, label = 'short call')
+ plt.plot(price, payoff_long_stock, label = 'underlying stock')
+ plt.plot(price, payoff_covered_call, label = 'covered call')
+ plt.legend(fontsize = 20)
+ plt.xlabel('Stock Price at Expiry',fontsize = 15)
+ plt.ylabel('payoff',fontsize = 15)
+ plt.title('Covered Call Strategy Payoff at Expiration',fontsize = 20)
+ plt.grid(True)
+
+Step 1: Initialize the Algorithm： At the beginning of your algorithm, you need to set the start date, the end date and the cash required for the algorithm. For options algorithm, you need to add the equity and the options written on this equity.
+
+
+
+
def Initialize(self):
+ self.SetStartDate(2016, 1, 1)
+ self.SetEndDate(2016, 3, 1)
+ self.SetCash(100000)
+ equity = self.AddEquity("IBM", Resolution.Minute)
+ option = self.AddOption("IBM", Resolution.Minute)
+ self.symbol = option.Symbol
+ # set our strike/expiry filter for this option chain
+ option.SetFilter(-3, +3, timedelta(0), timedelta(30))
+ # use the underlying equity as the benchmark
+ self.SetBenchmark(equity.Symbol)
+ self.call = "IBM" # Initialize the call contract
+
+
+
+ In the initialization process, you need to add a coarse selection for the options contracts. Here we use option.SetFilter(-3, +3, timedelta(0), timedelta(60)) to implement the coarse selection process. If today's market price of underlying stock is $159, the strike prices of IBM options are spaced $5. Then SetFilter will look up the most at the money contract with the strike being K=$160 (Here K might not be $159 since rarely will option be ATM exactly). The filter will look for options with strikes between and including (160-5*3, 160+5*3). The time to expiration of these options is restricted within 60 days from now on.
+
+
+ Step 2: Choose the Call Options Contract: Purchasing the underlying stock for 100 shares or an integer multiple of 100 shares. For options contract, one contract represents 100 shares of stock.
+
+
+ Step 3: Filter out the call options from candidate contracts.
+
+
+
+
+
call = [x for x in chain if x.Right == OptionRight.Call]
+
+
+
+ Step 4: Select the most ATM contract with the furthest expiration date from call options contracts. Sell this call contract for each 100 shares of stock you own. Here you can also choose ITM or OTM contract based on your expected level of profit and the level of risk you can take.
+
+
+
+
def TradeOptions(self,slice):
+ if slice.OptionChains.Count == 0: return
+ for i in slice.OptionChains:
+ if i.Key != self.symbol: continue
+ chain = i.Value
+ call = [x for x in chain if x.Right == 0] # filter the call options contracts
+ # sorted the contracts according to their expiration dates and choose the ATM options
+ contracts = sorted(sorted(call, key = lambda x: abs(chain.Underlying.Price - x.Strike)),
+ key = lambda x: x.Expiry, reverse=True)
+ if len(contracts) == 0: return
+ contract = contracts[0]
+ self.call = contract.Symbol
+ self.Sell(self.call, 1) # short the call options
+ if self.Portfolio["IBM"].Quantity == 0:
+ self.Buy("IBM",100) # buy 100 the underlying stock
+ self.Log("The stock price at time 0 S(0): {}".format(self.Securities["IBM"].Price))
+
+From the above strategy we can see that the share price of IBM had been increasing during the backtesting period from January 2016 to June 2016. The drawdown is small -- the Covered Call strategy performs better than a simple buy-and-hold strategy of underlying stock in a bearish market. The benefit of Covered Call is that you keep the premium, any gains from the underlying price increase up to the strike price, and accrued dividends during the stock holding period. In a bullish market, however, you miss out on any gains if the underlying stock price breaches the strike price.
+
+ Bull Call Spread is an options strategy involving two call option contracts with the same expiration but different strikes. The strategy buys one call option with a lower strike and sells another call option with a higher strike price.
+
+
+ This strategy creates a ceiling and floor for the profit. By purchasing a call and selling a call with higher strike simultaneously, traders can reduce the cost of just one long call option with the premium of a short call option. But the premium of ITM call is more expensive than the OTM call. The strategy limits the loss resulting from a drop in the price of the underlying stock but still creates a ceiling to the profit while the underlying price is increasing.
+
+
+ Take GOOG as an example. If the share price of GOOG is $950 at time 0, the premium of ITM call option is 50 with strike 900 and the premium of OTM call option is 2 with strike 1000. If we ignore the commission, dividends and other transaction fees, the payoff of Bull Call Spread strategy is as follows:
+
+
+
+
price = np.arange(800,1100,1)
+k_low = 900 # lower strike price for call
+k_high = 1000 # higher strike price for call
+premium_low = 20 # premium of call option with lower strike
+premium_high = 2 # premium of call option with higher strike
+# long call with lower strike
+payoff_long_call = [max(-premium, i-k_low-premium_low ) for i in price]
+# short call with higher strike
+payoff_short_call = [min(premium, -(i-k_high-premium_high)) for i in price]
+payoff = np.sum([payoff_long_call, payoff_short_call], axis=0)
+plt.figure(figsize=(20,11))
+plt.plot(price, payoff_long_call, label = 'long call')
+plt.plot(price, payoff_short_call, label = 'short call')
+plt.plot(price, payoff, label = 'Bull Call Spread')
+plt.legend(fontsize = 20)
+plt.xlabel('Stock Price at Expiry',fontsize = 15)
+plt.ylabel('payoff',fontsize = 15)
+plt.title('Bull Call Spread Payoff at Expiration',fontsize = 20)
+plt.grid(True)
+
+
+
+
+ From the payoff plot we can see, the maximum payoff of the strategy is the difference between the option strike prices minus the difference between the premiums.
+
+ Step 1: First, you need to initialize the algorithm including set the start date, end date and the cash required. Then use option.SetFilter(-6, 6, timedelta(30), timedelta(60)) to filter the candidate contracts which expire in 30 days to 60 days from now on. The strike price range involves both ITM and OTM options. Then we get the option chains of GOOG.
+
+
+
+
def Initialize(self):
+ self.SetStartDate(2016, 5, 1)
+ self.SetEndDate(2016, 10, 1)
+ self.SetCash(200000)
+ equity = self.AddEquity("GOOG", Resolution.Minute)
+ option = self.AddOption("GOOG", Resolution.Minute)
+ self.symbol = option.Symbol
+ # set our strike/expiry filter for this option chain
+ option.SetFilter(-6, 6, timedelta(30), timedelta(60))
+ # use the underlying equity GOOG as the benchmark
+ self.SetBenchmark(equity.Symbol)
+
+
+
+ Step 2: Choose the contracts with the same expiration date. For demonstration purpose here we sorted the contracts by their expiration dates and choose the options with the furthest expiration date in the option chain.
+
+
+
+
def TradeOptions(self,optionchain):
+ for i in optionchain:
+ if i.Key != self.symbol: continue
+ chain = i.Value
+ # sorted the optionchain by expiration date and choose the furthest date
+ expiry = sorted(chain,key = lambda x: x.Expiry, reverse=True)[0].Expiry
+
+
+
+ Step 3: Filter the call options from the contracts which expire on the furthest expiration date in the option chain.
+
+
+
+
call = [i for i in chain if i.Expiry == expiry and i.Right == OptionRight.Call]
+
+
+
+ Step 4: Sort the call options with the same expiration date according to their strike price. Then buy the call option with the lowest strike price and sell the call with the highest strike price.
+
+ Note here you need to add the following rules in OnData(self,slice) method because you only need to trade options once and wait until the contracts expire. If you already had securities invested in the portfolio, then you do not need to trade new options.
+
+
+
+
if not self.Portfolio.Invested:
+ self.TradeOptions(optionchain)
+
+This strategy can be implemented when you have a moderate outlook on the stock because the payoff reaches its maximum when the price is between the strike price range of two traded options. The strategy protects the downside move of the stock price. But when the price is above the higher strike, the profit is capped.
+
diff --git a/07 Applied Options[]/03 Long Straddle/01 Definition.html b/07 Applied Options[]/03 Long Straddle/01 Definition.html
new file mode 100755
index 0000000..8604edc
--- /dev/null
+++ b/07 Applied Options[]/03 Long Straddle/01 Definition.html
@@ -0,0 +1,29 @@
+
+ Long Straddle is an options trading strategy involving the going long in both a call and a put option, where both options have the same underlying asset, strike price and expiration date. This strategy aims to profit from volatile movements in the underlying stock, either positive or negative.
+
+
+
+
price = np.arange(750,1000,1)
+strike = 900 # strike price for both call and put
+premium_call = 20 # premium of call option
+premium_put = 10 # premium of put option
+# payoff for the long call
+payoff_long_call = [max(-premium_call, i-strike-premium_call) for i in price]
+# payoff for the long put
+payoff_long_put = [max(-premium_put, strike-i-premium_put) for i in price]
+payoff = np.sum([payoff_long_call, payoff_long_put], axis=0)
+plt.figure(figsize=(20,15))
+plt.plot(price, payoff_long_call, label = 'Long Call')
+plt.plot(price, payoff_long_put, label = 'long put')
+plt.plot(price, payoff, label = 'Long Straddle')
+plt.legend(fontsize = 20)
+plt.xlabel('Stock Price at Expiry',fontsize = 15)
+plt.ylabel('payoff',fontsize = 15)
+plt.title('Long Straddle Payoff',fontsize = 20)
+plt.grid(True)
+
+
+
+
+ Given this plot, if the stock price moves significantly away from the strike price in either direction, the Long Straddle will profit. The potential profit is unlimited on the upside because the stock price can rise indefinitely. On the downside, the potential profit is substantial but limited since the stock price can't fall below zero. The potential loss is limited to the premium of both call and put options. The maximum loss will be realized if the stock price is exactly equal to the strike price at expiration, and both options will expire worthless.
+
diff --git a/07 Applied Options[]/03 Long Straddle/02 Implementation.html b/07 Applied Options[]/03 Long Straddle/02 Implementation.html
new file mode 100755
index 0000000..63d0380
--- /dev/null
+++ b/07 Applied Options[]/03 Long Straddle/02 Implementation.html
@@ -0,0 +1,48 @@
+
+ Step 1: Initialize your algorithm and filter the contract. Here we choose the time to expiration to be between 30 to 60 days.
+
+
+
+
def Initialize(self):
+ self.SetStartDate(2017, 4, 01)
+ self.SetEndDate(2017, 6, 30)
+ self.SetCash(100000)
+ equity = self.AddEquity("GOOG", Resolution.Minute)
+ option = self.AddOption("GOOG", Resolution.Minute)
+ self.symbol = option.Symbol
+ # set our strike/expiry filter for this option chain
+ option.SetFilter(-5, 5, timedelta(30), timedelta(60))
+ # use the underlying equity GOOG as the benchmark
+ self.SetBenchmark(equity.Symbol)
+
+
+
+ Step 2: Sort the option chain by expiration and choose the furthest date to filter the call contract. Then sort those call contracts by their strike price and choose the call contracts with the highest strike price to trade.
+
+
+
+
for i in optionchain:
+ if i.Key != self.symbol: continue
+ chain = i.Value
+ # sort the optionchain by expiration date and choose the furthest date
+ expiry = sorted(chain,key = lambda x: x.Expiry, reverse=True)[0].Expiry
+ # filter the call options from the contracts expires on that date
+ call = [i for i in chain if i.Expiry == expiry and i.Right == 0]
+ # sort the contracts according to their strike prices
+ call_contracts = sorted(call,key = lambda x: x.Strike)
+ if len(call_contracts) == 0: continue
+ self.call = call_contracts[0]
+
+
+
+ Step 3: According to the call option contract, choose the put option with the same strike price and the same expiration date. Then buy the call option and the put option at the same time and wait until expiration.
+
+
+
+
for i in chain:
+ if i.Expiry == expiry and i.Right == 1 and i.Strike ==call_contracts[0].Strike:
+ self.put = i
+self.Buy(self.call.Symbol ,1)
+self.Buy(self.put.Symbol ,1)
+
+
diff --git a/07 Applied Options[]/03 Long Straddle/03 Summary.html b/07 Applied Options[]/03 Long Straddle/03 Summary.html
new file mode 100755
index 0000000..95cadda
--- /dev/null
+++ b/07 Applied Options[]/03 Long Straddle/03 Summary.html
@@ -0,0 +1,3 @@
+
+ There are three possible outcomes at expiration for the Long Straddle strategy. If the stock price is at the strike price at expiration, then both the call and the put become worthless and no stock position is created. If the stock price is above the strike price at expiration, the put option expires worthless, the long call is exercised, the stock is purchased at the strike price and a long stock position for is created. If the stock price is below the strike price at expiration, the call expires worthless, the long put is exercised, the stock is sold at the strike price and a short stock position is created. In this algorithm, the undelying asset is GOOG stock. We purchase both the $820 put and the $820 call at time 0. At the expiration, the share price of GOOG rises to 930 then the call option is exercised and the put options become worthless. After expiration, we hold long position for 100 shares of GOOG stock.
+
diff --git a/07 Applied Options[]/03 Long Straddle/04 Algorithm.html b/07 Applied Options[]/03 Long Straddle/04 Algorithm.html
new file mode 100755
index 0000000..89e3d28
--- /dev/null
+++ b/07 Applied Options[]/03 Long Straddle/04 Algorithm.html
@@ -0,0 +1,18 @@
+
+ Backtest (Using SetFilter)
+
+
+
+
+
+
+
+
+Backtest (Using OptionChainProvider)
+
+
+
+
+
+
+
diff --git a/07 Applied Options[]/04 Long Strangle/01 Definition.html b/07 Applied Options[]/04 Long Strangle/01 Definition.html
new file mode 100755
index 0000000..4e3c5d7
--- /dev/null
+++ b/07 Applied Options[]/04 Long Strangle/01 Definition.html
@@ -0,0 +1,31 @@
+
+ A Long Strangle is an options trading strategy that involves the simultaneous buying of an out-of-the-money put and an out-of-the-money call with the same underlying stock and expiration date. Similar to a Long Straddle, the Long Strangle has unlimited profit and limited risk, and can be applied if traders think the underlying asset will become volatile and move significantly in either direction. It differs from Long Straddle, however, in that the call strike is above the put strike.
+
+
+
+
price = np.arange(700,1000,1)
+# Suppose the undelying price at time 0 is 830
+k_call = 870 # The strike price of OTM call
+k_put = 795 # The strike price of OTM put
+premium_call = 8 # premium of call option
+premium_put = 10 # premium of put option
+# payoff for the long call
+payoff_long_call = [max(-premium_call, i-k_call-premium_call) for i in price]
+# payoff for the long put
+payoff_long_put = [max(-premium_put, k_put-i-premium_put) for i in price]
+payoff = np.sum([payoff_long_call, payoff_long_put], axis=0)
+plt.figure(figsize=(20,15))
+plt.plot(price, payoff_long_call, label = 'Long Call')
+plt.plot(price, payoff_long_put, label = 'long put')
+plt.plot(price, payoff, label = 'Long Strangle')
+plt.legend(fontsize = 20)
+plt.xlabel('Stock Price at Expiry',fontsize = 15)
+plt.ylabel('payoff',fontsize = 15)
+plt.title('Long Strangle Payoff',fontsize = 20)
+plt.grid(True)
+
+
+
+
+ From the payoff plot, the most that you can lose in a Long Strangle is the total premium you pay for holding the long position of both options. The maximum loss occurs when the stock price falls between the strike price of two options, in which case both options are worthless at expiration. The maximum gain of Long Strangle is unlimited for upside move because a stock's price has no maximum threshold.
+
diff --git a/07 Applied Options[]/04 Long Strangle/02 Implementation.html b/07 Applied Options[]/04 Long Strangle/02 Implementation.html
new file mode 100755
index 0000000..71cc2bf
--- /dev/null
+++ b/07 Applied Options[]/04 Long Strangle/02 Implementation.html
@@ -0,0 +1,62 @@
+
+ Step 1: Initialize your algorithm including setting the start and end date, setting the cash and filtering the options contracts. Note here in SetFilter, the strike price should range from negative to positive because we need to choose out-of-the-money put and call options from candidate contracts. The strike price of OTM call should be greater than ATM options and the strike price of OTM put should be lower than ATM options.
+
+
+
+
def Initialize(self):
+ self.SetStartDate(2017, 4, 1)
+ self.SetEndDate(2017, 5, 30)
+ self.SetCash(100000)
+ equity = self.AddEquity("GOOG", Resolution.Minute)
+ option = self.AddOption("GOOG", Resolution.Minute)
+ self.symbol = option.Symbol
+ # set our strike/expiry filter for this option chain
+ option.SetFilter(-15, 15, timedelta(30), timedelta(60))
+ # use the underlying equity GOOG as the benchmark
+ self.SetBenchmark(equity.Symbol)
+
+
+
+ Step 2: Sort the option chain by expiration date and choose an expiration date you want to trade. For demonstration purpose, here we choose options with the furthest expiration date in candidate contracts. Then filter out the call options which expire on that date.
+
+
+
+
for i in optionchain:
+ if i.Key != self.symbol: continue
+ chain = i.Value
+ # sorted the option chain by expiration date and choose the furthest date
+ expiry = sorted(chain,key = lambda x: x.Expiry, reverse=True)[0].Expiry
+ # filter the call options from the contracts expires on that date
+ call = [i for i in chain if i.Expiry == expiry and i.Right == 0]
+
+
+
+ Step 3: Sort the call options by their expiration date and choose the deep OTM contract which has the largest strike price.
+
+ Step 4: Select the put options which have the same expiration date with the call option and sort the put options by strike price. Then choose the deep out-of-the-money put which has the minimum strike price among all the available put options.
+
+
+
+
put_contracts = sorted([i for i in chain if i.Expiry == expiry and i.Right == 1], key = lambda x: x.Strike)
+# choose the deep OTM put option
+self.put = put_contracts[0]
+
+
+
+ Step 5: Buy the call and the put options at the same time and wait until expiration.
+
diff --git a/07 Applied Options[]/04 Long Strangle/03 Summary.html b/07 Applied Options[]/04 Long Strangle/03 Summary.html
new file mode 100755
index 0000000..f567b6c
--- /dev/null
+++ b/07 Applied Options[]/04 Long Strangle/03 Summary.html
@@ -0,0 +1,6 @@
+
+ In this algorithm, at time 0, we buy OTM call with strike price 870 and OTM put with strike price 795. The share price of GOOG at time 0 is $832.8. At the expiry, the share price of GOOG is $930.16, and so the call option is exercised and we get 100 shares of GOOG while the put option expires worthless.
+
+
+ You can enter into a Long Strangle if you have no clear idea of market direction but forecast that there will be a great movement in the underlying asset. As the options you buy are all out of the money, the premium cost of entering this position is low. However, because the call and the put options are all out of the money, the stock will need to move even more significantly than in a long straddle in order to profit from this strategy.
+
diff --git a/07 Applied Options[]/04 Long Strangle/04 Algorithm.html b/07 Applied Options[]/04 Long Strangle/04 Algorithm.html
new file mode 100755
index 0000000..09a8a85
--- /dev/null
+++ b/07 Applied Options[]/04 Long Strangle/04 Algorithm.html
@@ -0,0 +1,19 @@
+
+ A Butterfly Spread strategy involves trading four option contracts with the same expiration but three different strike prices. There are four kinds of Butterfly Spread:
+
+
+
+
+
Name
+
Strategy
+
+
+
+
+
Long butterfly spread with calls
+
Buy 1 ITM call, sell 2 ATM call, buy 1 OTM call
+
+
+
Long butterfly spread with puts
+
Buy 1 ITM put, sell 2 ATM put, buy 1 OTM put
+
+
+
Short butterfly spread with calls
+
Sell 1 ITM call, buy 2 ATM call, sell 1 OTM call
+
+
+
Short butterfly spread with puts
+
Buy 1 ITM put, sell 2 ATM put, buy 1 OTM put
+
+
+
+
+ A Butterfly Spread consists of three legs with a total of four options. In this tutorial, we use the Long Butterfly Spread as an example: long one ITM call, short two ATM calls and long one OTM call. All the calls have the same expiration. On the other hand, the middle strike is halfway between the lower and the higher strikes.
+
+
+ The aim of a Butterfly Spread strategy is for a trader to profit from marginal price changes in the underlying stock in either direction.
+
+
+
+
price = np.arange(800,1100,1)
+# Suppose the undelying price at time 0 is 935
+k_itm = 915 # the strike price of ITM call
+k_otm = 955 # the strike price of OTM call
+k_atm = 935 # the strike price of ATM call
+premium_itm = 45 # the premium of ITM call
+premium_otm = 15 # the premium of OTM call
+premium_atm = 25 # the premium of ATM call
+# payoff for the long ITM call position
+payoff_itm_long = [max(-premium_itm, i-k_itm-premium_itm) for i in price]
+# payoff for the long OTM call position
+payoff_otm_long = [max(-premium_otm, i-k_otm-premium_otm) for i in price]
+# payoff for the 2 short ATM call position
+payoff_atm_short = [min(2*premium_atm, -2*(i-k_atm-premium_atm)) for i in price]
+# payoff for Butterfly Spread Strategy
+payoff = np.sum([payoff_itm_long,payoff_otm_long,payoff_atm_short], axis=0)
+plt.figure(figsize=(20,15))
+plt.plot(price, payoff_itm_long, label = 'Long ITM Call')
+plt.plot(price, payoff_otm_long, label = 'Long OTM Call')
+plt.plot(price, payoff_atm_short, label = 'Short 2 ATM Call')
+plt.plot(price, payoff, label = 'Long Call Butterfly Spread')
+plt.legend(fontsize = 20)
+plt.xlabel('Stock Price at Expiry',fontsize = 15)
+plt.ylabel('payoff',fontsize = 15)
+plt.title('Long Call Butterfly Spread Payoff',fontsize = 20)
+plt.grid(True)
+
+ Step 1: Initialize your algorithm including setting the start date and the end date, setting the cash and implement a coarse selection of option contract. SetFilter(-9, 9, timedelta(30), timedelta(60)) helps us choose the contracts which expire in 30 to 60 days. For the strike parameter, the first parameter is the minimum strike rank relative to market price, the second parameter is the maximum strike rank relative to market price. The rank of ATM contract is 0. Here we need to choose 2 numbers which are symmetrical with 0 to get strike prices for both ITM and OTM contracts.
+
+ Step 2: Second we need to choose an expiration date for all the contracts, then filter out all the call options that expire on that date.
+
+
+
+
for i in optionchain:
+ if i.Key != self.symbol: continue
+ chain = i.Value
+ # sorted the optionchain by expiration date and choose the furthest date
+ expiry = sorted(chain,key = lambda x: x.Expiry, reverse=True)[0].Expiry
+ # filter the call options from the contracts expires on that date
+ call = [i for i in chain if i.Expiry == expiry and i.Right == 0]
+
+
+
+ Step 3: Sort the call options by their strike price in ascending order. Then choose the ATM option to be the one with the smallest absolute difference between the strike price and the underlying asset price. The OTM option is the last one in the call options list with the highest strike price. The corresponding ITM option is the first one in the list with the lowest strike price.
+
+ From the following algorithm, at time 0, the GOOG share price is $832.8. We purchase 1 OTM call option with strike price $855, 1 ITM call option with strike price $810 and sell 2 ATM options with strike prices at 835. At the expiry 05/19/2017, the share price is $930 and so the long positions of the ITM option and the OTM option are exercised: we buy 100 GOOG shares at $810 and buy another 100 shares at $855. At the same time, the 2 short positions of the ATM option are also exercised: we sell 200 GOOG shares to the option holder at $835. After the expiration date, we don't hold any shares of the underlying. Since the stock price had a sharp increase during the life of options, we fail to profit from a Long Call Butterfly Spread.
+
diff --git a/07 Applied Options[]/06 Iron Condor/01 Definition.html b/07 Applied Options[]/06 Iron Condor/01 Definition.html
new file mode 100755
index 0000000..5301009
--- /dev/null
+++ b/07 Applied Options[]/06 Iron Condor/01 Definition.html
@@ -0,0 +1,70 @@
+
+ An Iron Condor is an option strategy which involves four option contracts. All options have the same expiration date but different strike prices, where generally the spread in the put strike prices is the same as the spread in the calls. The order of strike for four contracts is A > B > C > D.
+
+
+
+
+
Position
+
Strike
+
+
+
+
+
long 1 OTM put
+
A
+
+
+
short 1 OTM put
+
B
+
+
+
short 1 OTM call
+
C
+
+
+
long 1 OTM call
+
D
+
+
+
+
+ The Iron Condor is the combination of a bear put spread and a bull call spread in which the strike price of the long put is lower than the strike price of the long call. If the stock price is between the two short strike prices when the options expire, the strategy will be profitable.
+
+
+
+
price = np.arange(700,920,1)
+k_call_higher = 850 # the strike price of OTM call(Higher k)
+k_call_lower = 820 # the strike price of OTM call(Lower k)
+k_put_higher = 780 # the strike price of OTM put(Higher k)
+k_put_lower = 750 # the strike price of OTM put(Lower k)
+premium_call_higher = 2 # the premium of OTM call(Higher k)
+premium_call_lower = 10 # the premium of OTM call(Lower k)
+premium_put_higher = 10 # the premium of oTM put(Higher k)
+premium_put_lower = 2 # the premium of OTM put(Lower k)
+# payoff for the long put position
+payoff_long_put = [max(-premium_put_lower, k_put_lower-i-premium_put_lower) for i in price]
+# payoff for the short put position
+payoff_short_put = [min(premium_put_higher, -(k_put_higher-i-premium_put_higher)) for i in price]
+# payoff for the short call position
+payoff_short_call = [min(premium_call_lower, -(i-k_call_lower-premium_call_lower)) for i in price]
+# payoff for the long call position
+payoff_long_call = [max(-premium_call_higher, i-k_call_higher-premium_call_higher) for i in price]
+# payoff for Long Iron Condor Strategy
+payoff = np.sum([payoff_long_put,payoff_short_put,payoff_short_call,payoff_long_call], axis=0)
+plt.figure(figsize=(20,15))
+plt.plot(price, payoff_long_put, label = 'Long Put',linestyle='--')
+plt.plot(price, payoff_short_put, label = 'Short Put',linestyle='--')
+plt.plot(price, payoff_short_call, label = 'Short Call',linestyle='--')
+plt.plot(price, payoff_long_call, label = 'Long Call',linestyle='--')
+plt.plot(price, payoff, label = 'Long Iron Condor',c='black')
+plt.legend(fontsize = 20)
+plt.xlabel('Stock Price at Expiry',fontsize = 15)
+plt.ylabel('payoff',fontsize = 15)
+plt.title('Long Iron Condor Strategy Payoff',fontsize = 20)
+plt.grid(True)
+
+
+
+
+ Here the strike price is A (750), B (780), C (820) and D (850). As seen in the payoff plot, the maximum profit comes from the options premium because the deeper OTM options are cheaper than the shallower ones. It is reached when the stock price is between the higher put strike and lower call strike (the two short positions) and the options all expire worthless. The maximum loss of Iron Condor is reached when the stock price is lower than the lowest strike A, then the two call options become worthless, the two puts are in the money. For the other condition, the stock price is higher than the highest strike D. Consequently, the two call options are in the money but the two puts expire worthless.
+
diff --git a/07 Applied Options[]/06 Iron Condor/02 Implementation.html b/07 Applied Options[]/06 Iron Condor/02 Implementation.html
new file mode 100755
index 0000000..f9c8e34
--- /dev/null
+++ b/07 Applied Options[]/06 Iron Condor/02 Implementation.html
@@ -0,0 +1,63 @@
+
+ Step 1: Initialize your algorithm by setting the start date, the end date and the cash for your algorithm. Then, implement the coarse selection of option contracts.
+
+ Step 2: Break the candidate options into two parts: calls and puts.
+
+
+
+
for i in optionchain:
+ if i.Key != self.symbol: continue
+ chain = i.Value
+ # filter the call and put options on the contracts
+ call = [i for i in chain if i.Right == 0]
+ put = [i for i in chain if i.Right == 1]
+
+
+
+ Step 3: Sort the call and put options by their strike prices.
+
+ Step 4: Choose the corresponding options and trade them. In this algorithm, according to criteria, SetFilter(-20, 20, timedelta(0), timedelta(40)) for put option list, there are 41 contracts in total: 1 ATM put, 20 OTM puts and 20 ITM puts. We choose the first in the put option list as the OTM put with the lower strike and the 15th contract as the OTM put with the higher strike.
+
diff --git a/07 Applied Options[]/06 Iron Condor/03 Summary.html b/07 Applied Options[]/06 Iron Condor/03 Summary.html
new file mode 100755
index 0000000..8766e51
--- /dev/null
+++ b/07 Applied Options[]/06 Iron Condor/03 Summary.html
@@ -0,0 +1,3 @@
+
+ The iron condor is an option strategy that earns money as long as the underlying asset price does move out of a predetermined price range. In this algorithm, that range is $775 to $827.5. At 02/01/2017, we long $750 put at $1.25 and short $775 put at $3.5. At the same time, we short $827.5 call at$2.3 and long $850 call at $0.75. At this moment, the GOOG share price is $799.55 all the options are out the money. At expiration date 02/17/2017, the share price of GOOG is $828.07. The long put, short put and long call expire worthless. The short call is exercised. Thus we wind up going short 100 shares of GOOG.
+
diff --git a/07 Applied Options[]/06 Iron Condor/04 Algorithm.html b/07 Applied Options[]/06 Iron Condor/04 Algorithm.html
new file mode 100755
index 0000000..7a08824
--- /dev/null
+++ b/07 Applied Options[]/06 Iron Condor/04 Algorithm.html
@@ -0,0 +1,19 @@
+
+ Backtesing using SetFilter
+
+
+
+
+
+
+
+
+ Backtest using OptionChainProvider
+
+
+
+
+
+
+
+
diff --git a/07 Applied Options[]/07 Iron Butterfly/01 Definition.html b/07 Applied Options[]/07 Iron Butterfly/01 Definition.html
new file mode 100755
index 0000000..59eeb97
--- /dev/null
+++ b/07 Applied Options[]/07 Iron Butterfly/01 Definition.html
@@ -0,0 +1,72 @@
+
+ The Iron Butterfly is an option strategy which involves four option contracts, all of which have the same expiration date. The order of strike prices for the four contracts is A > B > C.
+
+
+
+
+
Position
+
Strike
+
+
+
+
+
Buy 1 OTM put
+
A
+
+
+
Sell 1 ATM put
+
B
+
+
+
Sell 1 ATM call
+
B
+
+
+
Buy 1 OTM call
+
C
+
+
+
+
+ Similar to the Iron Condor, the Iron Butterfly is a limited risk, limited profit trading strategy. It profits from lower volatility, meaning that traders profit if the stock price has marginal movement within a small range. The Iron Butterfly has a more narrow range for the price to move up or down compared with the Iron Condor.
+
+
+
+
price = np.arange(700,950,1)
+k_atm = 830 # the strike price of ATM call & put
+k_otm_put = 800 # the strike price of OTM put
+k_otm_call = 860 # the strike price of OTM call
+premium_otm_put = 2 # the premium of OTM put
+premium_atm_put = 7 # the premium of ATM put
+premium_atm_call = 8 # the premium of ATM call
+premium_otm_call = 1 # the premium of OTM call
+# payoff for the long put position
+payoff_long_put = [max(-premium_otm_put, k_otm_put-i-premium_otm_put) for i in price]
+# payoff for the short put position
+payoff_short_put = [min(premium_atm_put, -(k_atm-i-premium_atm_put)) for i in price]
+# payoff for the short call position
+payoff_short_call = [min(premium_atm_call, -(i-k_atm-premium_atm_call)) for i in price]
+# payoff for the long call position
+payoff_long_call = [max(-premium_otm_call, i-k_otm_call-premium_otm_call) for i in price]
+# payoff for Iron Butterfly Strategy
+payoff = np.sum([payoff_long_put,payoff_short_put,payoff_short_call,payoff_long_call], axis=0)
+plt.figure(figsize=(20,15))
+plt.plot(price, payoff_long_put, label = 'Long Put',linestyle='--')
+plt.plot(price, payoff_short_put, label = 'Short Put',linestyle='--')
+plt.plot(price, payoff_short_call, label = 'Short Call',linestyle='--')
+plt.plot(price, payoff_long_call, label = 'Long Call',linestyle='--')
+plt.plot(price, payoff, label = 'Iron Butterfly',c='black')
+plt.legend(fontsize = 20)
+plt.xlabel('Stock Price at Expiry',fontsize = 15)
+plt.ylabel('payoff',fontsize = 15)
+plt.title('Iron Butterfly Strategy Payoff',fontsize = 20)
+plt.grid(True)
+
+
+
+
+ From the payoff plot, the maximum gain is simply the net credit you received when you buy and sell 4 options. This occurs if the stock price is exactly the same as the strike price of the ATM options. In this situation, all options expire worthless and you keep all premiums received. Although the Iron Butterfly has a narrower structure than the Iron Condor, the profit can be higher than with the Iron Condor as you receive a higher premium by selling ATM options than OTM options.
+
+
+ The maximum loss occurs if the underlying price is either below the OTM put strike or above the OTM call strike. In these two situations, two puts or two calls are exercised and the other two options expire worthless.
+
diff --git a/07 Applied Options[]/07 Iron Butterfly/02 Implementation.html b/07 Applied Options[]/07 Iron Butterfly/02 Implementation.html
new file mode 100755
index 0000000..c0092a5
--- /dev/null
+++ b/07 Applied Options[]/07 Iron Butterfly/02 Implementation.html
@@ -0,0 +1,60 @@
+
+ Step 1: Initialize your algorithm by setting the start date, end date and the cash. Then, implement the coarse selection of the options contracts.
+
+ Step 2: Break the candidate contracts into the call and put options.
+
+
+
+
def TradeOptions(self,optionchain):
+ for i in optionchain:
+ if i.Key != self.symbol: continue
+ chain = i.Value
+ # filter the call and put options from the contracts
+ call = [i for i in chain if i.Right == 0]
+ put = [i for i in chain if i.Right == 1]
+
+
+
+ Step 3: Sort the call and put options according to their strike prices. option.SetFilter(-10, 10, timedelta(0), timedelta(30)) helps us choose 21 call options and 21 put options which expire within 30 days from now. Then for the call options, the first 10 contracts are in the money and the last 10 contracts are out of the money. The middle one is an at the money option. For the put options, the first 10 contracts are out of the money and the last 10 contracts are in the money.
+
+ Step 4: Find the specific contracts to trade. At the money options have the minimum absolute difference between the underlying price and the strike price.
+
diff --git a/07 Applied Options[]/07 Iron Butterfly/03 Summary.html b/07 Applied Options[]/07 Iron Butterfly/03 Summary.html
new file mode 100755
index 0000000..61dcef0
--- /dev/null
+++ b/07 Applied Options[]/07 Iron Butterfly/03 Summary.html
@@ -0,0 +1,3 @@
+
+ In this algorithm, on 04/03/2017, the share price of Google is $832.8. We buy OTM put(strike = $805) at $2, OTM call(strike = $860) and sell an ATM call and an ATM put. At the expiry 04/21/2017, the share price is $841.53. The ATM call is exercised and the other 3 options expire worthless. As we hold the short position of the ATM call, after expiration we will be short 100 shares of GOOG.
+
diff --git a/07 Applied Options[]/07 Iron Butterfly/04 Algorithm.html b/07 Applied Options[]/07 Iron Butterfly/04 Algorithm.html
new file mode 100755
index 0000000..05d0e03
--- /dev/null
+++ b/07 Applied Options[]/07 Iron Butterfly/04 Algorithm.html
@@ -0,0 +1,19 @@
+
+ A Protective Collar is an option strategy that involves both the underlying stock and two option contracts. The trader buys (or already owns) a stock, then buys an out-the-money put option and sells an out-the-money call option. It is similar to the covered call strategy but with the purchase of an additional put option. This strategy is employed if the trader is writing covered calls but wishes to protect himself from an unexpected drop in the price of the underlying security. As a tradeoff for loss-protection, the profit is limited compared with the Covered Call strategy.
+
+
+
+
# Protective Collar
+price = np.arange(700,950,1)
+# assume at time 0, the price of the undelying stock is 830
+k_otm_put = 800 # the strike price of OTM put
+k_otm_call = 860 # the strike price of OTM call
+premium_otm_put = 6 # the premium of OTM put
+premium_otm_call = 2 # the premium of OTM call
+# payoff for the long put position
+payoff_long_put = [max(-premium_otm_put, k_otm_put-i-premium_otm_put) for i in price]
+# payoff for the short call position
+payoff_short_call = [min(premium_otm_call, -(i-k_otm_call-premium_otm_call)) for i in price]
+# payoff for the underlying stock
+payoff_stock = price - 830
+# payoff for the Protective Collar Strategy
+payoff = np.sum([payoff_long_put,payoff_short_call,payoff_stock], axis=0)
+plt.figure(figsize=(20,15))
+plt.plot(price, payoff_long_put, label = 'Long Put',linestyle='--')
+plt.plot(price, payoff_short_call, label = 'Short Call',linestyle='--')
+plt.plot(price, payoff_stock, label = 'Underlying Stock',linestyle='--')
+plt.plot(price, payoff, label = 'Protective Collar',c='black')
+plt.legend(fontsize = 20)
+plt.xlabel('Stock Price at Expiry',fontsize = 15)
+plt.ylabel('payoff',fontsize = 15)
+plt.title('Protective Collar Strategy - Payoff',fontsize = 20)
+plt.grid(True)
+
+
+
+
+ According to the payoff plot, the maximum profit is the strike price of short call minus the purchase price of the underlying asset plus the net credit from the premium. It occurs when the underlying price is beyond the strike price of the short call option. The maximum loss is the purchase price of the underlying asset minus the strike price of the long put minus the net credit from the premium. It occurs when the stock price is below the strike price of the long put. It is a strategy with both limited risk and limited profit.
+
+ Step 1: Initialize your algorithm by setting the start date, end date and cash. Then implement the coarse selection of options contracts.
+
+
+
+
def Initialize(self):
+ self.SetStartDate(2017, 4, 1)
+ self.SetEndDate(2017, 5, 30)
+ self.SetCash(1000000)
+ equity = self.AddEquity("GOOG", Resolution.Minute)
+ option = self.AddOption("GOOG", Resolution.Minute)
+ self.symbol = option.Symbol
+ # set our strike/expiry filter for this option chain
+ option.SetFilter(-10, +10, timedelta(0), timedelta(30))
+ # use the underlying equity as the benchmark
+ self.SetBenchmark(equity.Symbol)
+
+
+
+ Step 2: Choose the expiration date for your options traded and break the options into the call and put contracts. The choice of expiration date depends on the holding period of stocks in your portfolio.
+
+
+
+
def TradeOptions(self,optionchain):
+ for i in optionchain:
+ if i.Key != self.symbol: continue
+ chain = i.Value
+ # choose the furthest expiration date within 30 days from now on
+ expiry = sorted(chain, key = lambda x: x.Expiry)[-1]
+ # filter the call options contracts
+ call = [x for x in chain if x.Right == 0 and x.Expiry == expiry]
+ # filter the put options contracts
+ put = [x for x in chain if x.Right == 1 and x.Expiry == expiry]
+
+
+
+ Step 3: Choose the deep in-the-money call and put options in the list and then sell the call options and buy the put options.
+
+
+
+
self.otm_call = sorted(call, key = lambda x: x.Strike)[-1]
+self.otm_put = sorted(put, key = lambda x: x.Strike)[0]
+if (self.otm_call is None) or (self.otm_put is None): continue
+self.Sell(self.otm_call.Symbol, 1) # sell the OTM call
+self.Buy(self.otm_put.Symbol, 1) # buy the OTM put
+
+
+
+ Step 4: In OnData, if there are no assets in our portfolio, we buy the undelying stock. After that, we trade the options written on the same number of shares of underlying asset (one option contracts equals 100 undelying shares).
+
+
+
+
def OnData(self,slice):
+ optionchain = slice.OptionChains
+ for i in slice.OptionChains:
+ if i.Key != self.symbol: continue
+ chains = i.Value
+ contract_list = [x for x in chains]
+ if (slice.OptionChains.Count == 0) or (len(contract_list) == 0): return
+ # if you don't hold options and stocks, buy the stocks and trade the options
+ if not self.Portfolio.Invested:
+ self.Buy("GOOG",100) # buy 100 shares of the underlying stock
+ self.TradeOptions(optionchain) # sell OTM call and buy OTM put
+
+ In this algorithm, at the beginning 01/04/2016, we purchased 100 GOOG shares. At the same time, we purchased a $715 put at $6 and sells a $772.5 call at $2.45. The share price of GOOG is $739.32, which is between the strike prices of two out-the-money options. At the expiry 01/15/2016, the share price of GOOG drops to $714.32. The call option expire worthless but the put option is exercised. Then we sell 100 GOOG shares at $715. Then we hold neither option positions and stock positions.
+
+BootCamp is an interactive, education system for teaching the community the QuantConnect API, and the structure for building an algorithm. In January 2019, QuantConnect opened up the BootCamp technology to allow contributions of tutorials from the community! This guide seeks to show you how to create a BootCamp tutorial.
+
+
+
+Education and access to the information required to compete is a the cornerstone of QuantConnect's mission for radical openness, and the democratization of finance. With your help we can train the community on how to make the best algorithms possible.
+
+Ensuring high-quality writing in BootCamp lessons is important to maintain the interest and motivation of the community. The skills required to build a BootCamp lesson cover several areas of expertise:
+
+
+
QuantConnect API: Contributors must have knowledge of the QuantConnect API along with the correct way to implement the desired behavior.
+
Programming Polygot: BootCamp algorithms are provided in both C# and Python. The text documentation is written in HTML, and the task validation code is performed in JavaScript. You should be able to code neatly in all four languages.
+
Principles of Algorithmic Trading: Domain expertise in finance is important to be able to build thoughtful and educational content.
+
+
+The combination of all these talents is fairly rare so we're reaching out to the community to help us create this content. If you can cover all three of these categories let us know and we'll enable BootCamp editing permissions on your account. In exchange for a completed BootCamp lesson we're offering compensation which we'll cover in the section below.
+
+QuantConnect is offering contributing authors compensation for their BootCamp Lesson submissions. Depending on the complexity and topics covered a lesson ranges from $2,000 to $4,000USD.
+
+
+
+
+
+
+ Difficulty
+
+
+ Compensation
+
+
+ Estimated Effort
+
+
+
+
+
+
Beginner
+
$2,000USD
+
3-5 days fulltime work
+
+
+
Intermediate
+
$3,000USD
+
4-6 days fulltime work
+
+
+
Advanced
+
$4,000USD
+
5-8 days fulltime work
+
+
+
+
+Before starting a lesson reach out to the QuantConnect team for approval on the lesson concept. We are seeking to provide diverse and complementing content for the community. If you're interested in creating BootCamp lessons but don't have a topic in mind get in touch with us!
+
\ No newline at end of file
diff --git a/08 Meta/01 Creating BootCamp Tutorials/04 Content Structure.html b/08 Meta/01 Creating BootCamp Tutorials/04 Content Structure.html
new file mode 100644
index 0000000..dc4c918
--- /dev/null
+++ b/08 Meta/01 Creating BootCamp Tutorials/04 Content Structure.html
@@ -0,0 +1,31 @@
+
+BootCamp is divided into Lessons, and Tasks. A Lesson focuses on the implementation of a single algorithm. A Task breaks up the algorithm implementation into tiny steps which can each be easily coded, with the aim of guiding the user through each layer of the algorithm design.
+
+
+
+
Core Principle
+
The central guiding principle of BootCamp lessons is they are focused on the implementation of a single algorithmic trading strategy. At each level of the system, the titles should be directly related to the implementation of the strategy, not the concepts it is covering. This is actually quite difficult, but one way to help to get into this mindset is to focus on teaching how to implement the strategy.
+
+
+
+
Lesson: Buy and Hold Algorithm
+
Task: Initializing Your Algorithm -> Set Cash
+
+
+
+
+
+
Lessons
+
+A Lesson is a collection of tasks aiming to implement a single algorithmic strategy step by step. A lesson should be comprised of about 6-12 tasks, where each task builds upon the lessons learned from the previous task. We have built a system for the community to design and submit Boot Camp lessons and tasks.
+
+
+
Tasks
+
+A Task is the atomic unit of the Boot Camp system. It is a single step required to be completed in the pathway to an algorithm. Tasks are grouped with a subheading according to algorithm implementation concept. A task should aim to implement just few lines of code so that each task can be easily achieved.
+
\ No newline at end of file
diff --git a/08 Meta/01 Creating BootCamp Tutorials/05 Planning Your Lesson.html b/08 Meta/01 Creating BootCamp Tutorials/05 Planning Your Lesson.html
new file mode 100644
index 0000000..67986a8
--- /dev/null
+++ b/08 Meta/01 Creating BootCamp Tutorials/05 Planning Your Lesson.html
@@ -0,0 +1,193 @@
+
+Carefully planning and structuring your lesson is critical to ensuring its success. In the next section, we'll create this plan step by step. Boot Camp lessons typically fall into one of the following algorithm types: Macro Economics, Technical Indicators, Scaling, Market Making, Market Microstructure, Sentimental, or Value-Fundamental Investing.
+
+
+
1. Strategy Selection
+
+Every BootCamp lesson is focused on an algorithmic strategy's implementation. The first step to planning a lesson is choosing a strategy which does not overlap with any of the existing BootCamp topics. This can be incrementally more difficult but should introduce new concepts.
+
+
+
2. Strategy Implementation
+
+After selecting your strategy you need to fully implement the algorithm, writing the code in C# and Python as simply as possible. Users new to coding have a hard time deciphering large blocks of code so strategies should be kept very simple.
+
+
+
In writing the strategy remain aware of the conceptual layers you put into the algorithm's codebase. These layers of concepts are where you can separate out the lesson tasks. For example: in writing a lesson "Buy and Hold, with Trailing Stop" you might start by coding up the buy and hold logic, followed by placing a "trailing stop" (Stop Market Order), then finally you can make the stop move by updating its trigger price. These conceptual layers form the basis for how tasks are grouped together.
+
+
+QuantConnect has worked with the community to create a list of lessons to be created which would be eligible for compensation. The table below describes these strategies and their associated difficulty level.
+
+
+
+
+
+
+
+
Beginner BootCamp Lessons
+
Status
+
+
+
+
+
+
Buy and Hold (Equities/Forex) Strategy purchasing assets and holding them for the duration of the algorithm. Seeking to demonstrate how to initialize an algorithm and access price data.
+Accessing DataInitializing Algorithms
+
+
Completed
+
+
+
+
Buy and Hold with Trailing Stop Placing and updating a stop-market order combined with basic charting to visualize the stop price movement.
+Order ManagementBasic Charting
+
Completed
+
+
+
+
Momentum-Based Tactical Allocation Using a momentum indicator to shift investment between the S&P500 to a Bond ETF. Introducing multiple asset portfolios and the use of an indicator.
Open Range Breakout Uses consolidators to aggregate the first 20 minutes of a day and trades when the price moves beyond that range. Introduces custom period consolidated price bars.
+Consolidators
+Equities
+
+
Completed
+
+
+
+
Liquid Universe Selection Using a universe selection filter, invest in the top 10 stocks which are liquid and cost more than $10 per share. Introduces universe selection features.
+Universes
+Price Volume Filtering
+Equities
+
+
Completed
+
+
+
+
200-50 EMA Momentum Universe Select assets where the 50-EMA is greater than the 200 EMA. Seeking to introduce creating structures to contain symbol specific data, and using the history API to warm them up.
+Universes
+SymbolData Pattern
+History
+Equities
+
Completed
+
+
+
+
Fading The Gap Using scheduled events to monitor for overnight price gaps in the market and shorting abnormal activity. Introduces scheduled events, and elimination of a parameter with STD indicator.
The Algorithm Framework A simple strategy to buy SPY each morning on market open using the algorithm framework - a scaffolding for powerful strategy design.
+Algorithm Framework
+Execution Model
+Portfolio Model
+Universe Selection Model
+
+
Assigned
+
+
+
+
Pairs Trading with SMA Simple pairs trading strategy monitoring for divergence in correlation of two hand picked assets. Invests in a market neutral manner, using position sizing to calculate the right holding of each asset.
Pairs Trading with Cointegration Test Scanning a basket of assets monthly for potential cointegration and making a pairs trade when detect a divergent pair. Using scheduled events for the cointegration test.
+Pairs Trading
+Cointegration Test
+Scheduled Events
+Equities
+
+
Assigned
+
+
+
+
Liquid Value Stocks Selecting a universe of the 100 most liquid assets and rank by their PE-Ratio to get the best value stocks. Each month buy the 10 best value stocks, and short the worst value stocks.
Hedging FX Books with Interest Rate Harnessing an alternative data source (Trading Economics) to invest proportionately with interest rate changes in the underlying economies.
+Trading Economics
+Alternative Data
+Global Macro
+Forex
+
Sentiment Analysis on Stocks Harness Psychsignal data to rank the sentiment of a basket of US Equity stocks and invest in those with the most positive sentiment.
+Psychsignal
+NLP
+Alternative Data
+Sentiment Analysis
+Equities
+
diff --git a/08 Meta/01 Creating BootCamp Tutorials/06 Writing a Lesson.html b/08 Meta/01 Creating BootCamp Tutorials/06 Writing a Lesson.html
new file mode 100644
index 0000000..56fadfc
--- /dev/null
+++ b/08 Meta/01 Creating BootCamp Tutorials/06 Writing a Lesson.html
@@ -0,0 +1,119 @@
+
+Writing a BootCamp lesson starts by carefully writing out the complete code for the strategy, breaking it into tasks, and write small text summaries for each task with the documentation required to teach the reader how to complete the task. Finally, JavaScript is used to read the exhaust output of the algorithm to validate it achieved the required objective.
+
+
+
+
+
Lesson Algorithm
+
Task Guides
+
Validators
+
Hints, Solutions
+
Submit
+
+
+
1. Write Lesson Algorithm
+
+Writing a BootCamp lesson starts by carefully writing out the complete code for the strategy. This should be drafted as simply as possible to ensure each task the student needs to complete will only be 2-5 lines of code.
+
+Readability is critical and the code should be well commented with descriptive variable names. Depending on the complexity of the algorithm sometimes its more readable to use string tickers instead of class variables.
+
+
+Carefully write code in a way which neatly separates the algorithm concepts as much as possible. Keep in mind the algorithm will be implemented in separate tasks by the student.
+
+
+ Action:
+
Write highly readable, concise C# and Python versions of the algorithm and request review by QuantConnect Education team. Plan ahead for divisions of the code into tasks.
+
+
+
+2. Write Task Guides
+
+
+Each task has a short write-up to explain the features needed to complete the next task of BootCamp. This write-up should assume the student has no prior knowledge and include representative code snippets demonstrating the key API code needed.
+
+
+
+
Style
Example Code Tag
+
+
+
+
Headings
+
<h4>Initializaing Algorithms</h4>
+
+
+
Paragraphs
+
<p>Setting cash is done with <span class="python">self.SetCash().</span></p>
+For a fluent experience between lessons, all content should follow the same structure as the sections laid out below.
+
+
+
+
+Tasks start their contents divided by subtitle using the h4 tag. Use a short title about the specific API or content you're trying to summarize.
+
+After each heading, write a short paragraph concisely summarizing the content in as few words as possible. Use inline <code> blocks to highlight API syntax, and links to new tabs referencing any documentation required.
+
+Any content which is specific to one programming language should be wrapped in a span tag with the language set in the class, for example: <span class="python">.
+
+Each section should include a code snippet of documentation using a <pre class="prettyprint"> code block.
+
+Finally, each task should define 2-4 objectives to achieve in the task. These tasks should guide the user on the required steps to implement the strategy step. At the end of the task, there should be a measurable output that the system can use to judge if the task is a success. This can be a state change of the algorithm, a debug/log statement, or a trade. This will be covered in the next section, Code Validators.
+
+
diff --git a/08 Meta/01 Creating BootCamp Tutorials/07 Building Code Validators.html b/08 Meta/01 Creating BootCamp Tutorials/07 Building Code Validators.html
new file mode 100644
index 0000000..97a2953
--- /dev/null
+++ b/08 Meta/01 Creating BootCamp Tutorials/07 Building Code Validators.html
@@ -0,0 +1,7 @@
+
+Validators
+ Partial Class
+ Validating algorithm output
+
+ Examples of validation
+
+H4 titles, verbs describing strategy step
+Brief Short sentences,
+Aim for no more than 3 todo's per task
+Hint should give enough information to complete the task.
+technical grammar, present tense.
+
diff --git a/08 Meta/01 Creating BootCamp Tutorials/09 Submitting Lesson for Review.html b/08 Meta/01 Creating BootCamp Tutorials/09 Submitting Lesson for Review.html
new file mode 100644
index 0000000..b514e77
--- /dev/null
+++ b/08 Meta/01 Creating BootCamp Tutorials/09 Submitting Lesson for Review.html
@@ -0,0 +1,3 @@
+
diff --git a/API Tutorials/Tutorial00 Introduction to QuantConnect API.html b/API Tutorials/Tutorial00 Introduction to QuantConnect API.html
deleted file mode 100644
index 9d1e092..0000000
--- a/API Tutorials/Tutorial00 Introduction to QuantConnect API.html
+++ /dev/null
@@ -1,81 +0,0 @@
-
About
-
In this tutorial series we introduce the core concepts of the QuantConnect/LEAN API with the aim of answering the commonly asked questions about using QuantConnect.
-
-
The core of the documentation can be found on the documentation page, but these videos should give you an even deeper understanding. The QuantConnect underlying technology (LEAN) is written in C#, and most of these videos are in C# -- however the API is virtually the same in Python and F#. If you're a Python user just click the "Python" code snippet button on the documentation page to view the python examples.
-
-
-
-
6 Tutorials
-
-
-
6 Backtests
-
-
-
25 Code Snippets
-
-
-
-
What Will I learn ?
-
-
Consolidating Data
-
Desktop Charting
-
Using API File Provider
-
Scheduling Events
-
Order Management
-
Using Options
-
-
Tutorials
-
-
-
-
1
-
-
Consolidating Data to Build Bars
-Create any bar size by combining data together with Consolidators.
- Read Tutorial
-
-
-
-
-
2
-
-
Desktop Charting with LEAN
-Setting up desktop charting with the open source algorithmic trading engine LEAN.
- Read Tutorial
-
-
-
-
3
-
-
Downloading Data with the API File Provider
-Guide to downloading and interacting with your QuantConnect data repository.
- Read Tutorial
-
-
-
-
4
-
-
Using Scheduled Events
-Scheduling events to trigger code at specific times of day.
- Read Tutorial
-
-
-
-
5
-
-
Tracking and Managing Orders
-Simple guide to the basics of tracking and managing orders in QuantConnect.
- Read Tutorial
-
-
-
-
6
-
-
Using Options in QuantConnect
-The key API methods for requesting option data financial and focusing in on specific contracts.
- Read Tutorial
-
-
-
-
-
\ No newline at end of file
diff --git a/API Tutorials/Tutorial02 Desktop Charting with LEAN.html b/API Tutorials/Tutorial02 Desktop Charting with LEAN.html
deleted file mode 100644
index ff69fd4..0000000
--- a/API Tutorials/Tutorial02 Desktop Charting with LEAN.html
+++ /dev/null
@@ -1,22 +0,0 @@
-With a few configuration changes you can get desktop charting in LEAN with a HTML5 interface very similar to the one you see in QuantConnect.com. This gives you better visual feedback on your strategy and allows you to improve faster. This tutorial guides you through configuring a desktop charting environment with LEAN.
-
-Local charting (and all local backtesting) requires you to have your own source of data. We provide a way to download FX and CFD data through our API. To get started make sure you have your data in your data folder. By default this is the /Data/ directory relative to your LEAN installation.
-
-Two configuration changes are required for desktop charting to work:
-
-
Change the "environment" field to use "backtesting-desktop". This instructs LEAN to use the configuration settings block at the bottom of the config file.
-
"environment": "backtesting-desktop",
-
-
Insert your API token and user id into configuration file. This is required for chart streaming.
-
// To get your api access token go to quantconnect.com/account
- "job-user-id": "....",
- "api-access-token": "...........",
-
-
-With those changes in place you can simply run the project and your backtesting chart will appear in a few seconds. For live trading; use the"live-desktop" configuration environment.
-
-If you get the run-time exception "The port configured in config.json is either being used or blocked by a firewall"- This normally means you've left the user interface open (you should close it between each run). It can also be because another program is sharing that port. You can fix this by changing the port LEAN transmits the data with the "desktop-http-port" setting.
-
-In the tutorial video below we demonstrate this feature on LEAN:
-
-https://www.youtube.com/watch?v=m6llfznP4d4
\ No newline at end of file
diff --git a/API Tutorials/Tutorial03 How do I use the API File Provider.html b/API Tutorials/Tutorial03 How do I use the API File Provider.html
deleted file mode 100644
index fbaf5a9..0000000
--- a/API Tutorials/Tutorial03 How do I use the API File Provider.html
+++ /dev/null
@@ -1,16 +0,0 @@
-Ensuring a high data quality is one of the hardest parts of setting reliable backtesting. There are many challenges to ensuring your data is in the right format, free of errors or omissions and historically accurate. We've tried to address this for you by opening the LEAN Data Library and letting you download our data. LEAN data is organized into millions of tiny files which can be difficult to put into place manually; but using the API File Provider we provide a way for you to automatically install this into your LEAN project.
-
-Currently we provide forex and cfd data for each of the major vendors we support in tick, second, minute, hour and daily resolution. To request data; go to your data library and specify what you'd like to download.
-
-
-
-Each data file has a unique URL to download the data for the day which will get a LEAN formatted CSV zip. By using the API File Downloader we check if you have the file in your data-folder; and if not we attempt to download it from the API. This assumes you have already added the data to your repository through the web interface.
-
-This requires 2 key changes to the config.json file in the QuantConnect.Lean.Launcher Project:
-
-
Insert your job-user-id and api-access-token into the relevant config fields. You can find these on your Account page.
-
Update the data-provider configuration to refer to the APIDataProvider class. This is called QuantConnect.Lean.Engine.DataFeeds.ApiDataProvider.
-
-Check out the video below where we guide you step by step through how to use the API Data Provider.
-
-https://www.youtube.com/watch?v=uyHp_jyeSpA
\ No newline at end of file
diff --git a/API Tutorials/Tutorial05 Tracking and Managing Orders.html b/API Tutorials/Tutorial05 Tracking and Managing Orders.html
deleted file mode 100644
index bd19104..0000000
--- a/API Tutorials/Tutorial05 Tracking and Managing Orders.html
+++ /dev/null
@@ -1,138 +0,0 @@
-
Overview
-Tracking and managing orders is an important part of an algorithmic trading strategy. Intelligent order management encourages discipline and a deep understanding of your algorithm. Through the QuantConnect API you can get order fields, update their values and cancel pending orders. This can be useful for lowering trading costs and improving order fills.
-
-When you place a trade you receive an OrderTicket for you to access the order. This allows you to safely (asynchronously) update and cancel the order while in live trading. In live trading you cannot assume order updates are processed successfully as the brokerage may have already filled the trade.
-
-You can place several types of orders including:
-
-
-
-
Supported Order Types
-
-
-
-
-
Market Order
-
MarketOrder("SPY", 100);
-
-
-
Limit Order
-
var ticket = LimitOrder("SPY", 100, 100.10m);
-
-
-
Stop Market Order
-
var ticket = StopMarketOrder("SPY", 100, 100.10m);
-
-
-
Stop Limit Order
-
var ticket = StopLimitOrder("SPY", 100, 100.12m, 99.5m);
-
-
-
Market On Open Order
-
var ticket = MarketOnOpen("SPY", 100);
-
-
-
Market On Close Order
-
var ticket = MarketOnClose("SPY", 100);
-
-
-
-
Updating Orders
-Once you have an order ticket you can use it to get order fields. In C# it looks like:
-
var currentStopPrice = _ticket.Get(OrderField.StopPrice);
-Or update the order fields (LimitPrice, StopPrice, Tag or Quantity):
-
# Retrive the 'StopPrice' for an order from the ticket
-currentStopPrice = _ticket.Get(OrderField.StopPrice)
-# update the order fields (LimitPrice, StopPrice, Tag or Quantity)
-updateOrderFields = UpdateOrderFields()
-updateOrderFields.LimitPrice = newLongLimit
-updateOrderFields.Tag = "Update #{0}".format(len(_ticket.UpdateRequests) + 1)
-_ticket.Update(updateOrderFields)
-# cancel your order if required
-_ticket.Cancel()
-
-In the video below we demonstrate putting it all together to create a moving take-profit order which gradually decreases its profit target as time passes.
-https://www.youtube.com/watch?v=HykXfstdNW0
-
-
Full Python Example
-This is a complete port from C# to Python of this Quick Start Lesson.
-
-```Lesson 6 - Tracking and Managing Orders:
-Immediately place 4 orders. Plot end of day price of each order in 'Order Tickets' plot. Debug log filled orders.
-```
-import numpy as np
-from decimal import Decimal
-
-class BasicTemplateAlgorithm(QCAlgorithm):
-
- def Initialize(self):
- self._limitTicket = None
- self._stopMarketTicket = None
- self._stopLimitTicket = None
- self.SetCash(25000)
- self.SetStartDate(2009,1,1)
- self.SetEndDate(2009,6,1)
- self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol
-
- def OnData(self, slice):
- if self._limitTicket is None:
-
- self.MarketOrder(self.spy, 100)
-
- self._limitTicket = self.LimitOrder(
- self.spy,
- 100,
- slice["SPY"].Close * Decimal(0.9),
- "limit order")
-
- self._stopMarketTicket = self.StopMarketOrder(
- self.spy,
- -100,
- slice["SPY"].Close * Decimal(0.95),
- "stop market")
-
- self._stopLimitTicket = self.StopLimitOrder(
- self.spy,
- -100,
- slice["SPY"].Close * Decimal(0.9),
- slice["SPY"].Close * Decimal(0.8),
- "stop market")
-
-
- def OnEndOfDay(self):
- ```End of each day, plot our asset & order prices```
- if self._limitTicket is None:
- return
-
- self.Plot("Order Tickets", "SPY", self.Portfolio['SPY'].Price)
-
- if self._stopMarketTicket.Status != OrderStatus.Filled:
- self.Plot("Order Tickets", "Stop Price",
- self._stopMarketTicket.Get(OrderField.StopPrice))
-
- if self._stopLimitTicket.Status != OrderStatus.Filled:
- self.Plot("Order Tickets", "Limit Price",
- self._stopLimitTicket.Get(OrderField.LimitPrice))
-
- def OnOrderEvent(self, OrderEvent):
- ```Event when the order is filled. Debug log the order fill. :OrderEvent:```
-
- if OrderEvent.FillQuantity == 0:
- return
-
- fetched = self.Transactions.GetOrderById(OrderEvent.OrderId)
-
- self.Debug("{} was filled. Symbol: {}. Quantity: {}. Direction: {}"
- .format(str(fetched.Type),
- str(OrderEvent.Symbol),
- str(OrderEvent.FillQuantity),
- str(OrderEvent.Direction)))
-
diff --git a/API Tutorials/Tutorial06 Using Options in QuantConnect.html b/API Tutorials/Tutorial06 Using Options in QuantConnect.html
deleted file mode 100644
index 93086b9..0000000
--- a/API Tutorials/Tutorial06 Using Options in QuantConnect.html
+++ /dev/null
@@ -1,246 +0,0 @@
-QuantConnect provides US options trade and quotes price data for approximately 4000 symbols, each of which has roughly 10 strikes on average. Data is available starting January 1st, 2010. In this tutorial, we will discuss how to use QuantConnect to start your options trading algorithm.
-
Step 1: Add Options
-Before trading options, you need to add options for a given underlying equity and set the resolution in step Initialize with AddOption method. The commonly used parameters will be explained in the method table. Please refer to the link below for details of each method.
-
underlying(string): The underlying equity symbol
-resolution: Tick, Second, Minute, Hour, or Daily. Default is minute
-fillDataForward(bool): If true, returns the last available data even if none in that time slice. The default value is true.
-
-
-
-
def Initialize(self):
- self.SetStartDate(2017, 01, 01) #Set Start Date
- self.SetEndDate(2017, 06, 30) #Set End Date
- self.SetCash(50000) #Set Strategy Cash
- equity = self.AddEquity("GOOG", Resolution.Daily) # Add the underlying stock: Google
- option = self.AddOption("GOOG", Resolution.Daily) # Add the option corresponding to underlying stock
- self.symbol = option.Symbol
-
-The return value of AddOption method is an option security object , please refer to the link for detailed properties and methods of option class.
-
Step 2: Filter Contracts - Coarse Selection
-After adding the options for specific underlying stock, you can set the filter criteria with SetFilter method to pull contracts using the specified min and max strike and expiration range values you need for a given symbol.
-
min Strike, max Strike: The min and max strike rank relative to market price
-min Expiry, max Expiry: The range of time to expiration to include, for example, TimeSpan.FromDays(10) would exclude contracts expiring in less than 10 days
-
-
-
-Here parameters min Strike and max Strike are the relative values with respect to the market price. We use Google(NASDAQ: GOOG) as an example to describe the filter criteria. If today is 01/03/2017, the market price of underlying stock is $776, the strike prices of GOOG options are spaced $2.5. Then SetFilter(-1, +2, timedelta(0), timedelta(90)) will fist look up at the money contracts with strike being K=$777.5 (Here K might not being $100 since rarely will option be ATM exactly). Then filter will looks for options with strikes between and including (777.5 + 2.5*2, 777.5 - 2.5*1). The time to expiration of these options are restricted within 90 days from now on.
-
-For the strike, the exchange normally chooses the strike prices at which options can be written so that they are spaced $2.50, $5, or $10 apart. Typically the spacing is $2.50 when the stock price is between $5 and $25, $5 when the stock price is between $25 and $200, and $10 for stock prices above $200. So you should carefully choose the parameters of min strike and max Strike in case there is no contracts satisfy the filter criteria if the range is too small, less than the minimum units of strike prices change.
-
-For the expiry, there are many expiration dates that apply to the different series of options. An option cycle is the pattern of months in which options contracts expire. There are three kinds of common option cycles. The options on the January cycle have contracts available in the first month of each quarter (January, April, July and October). Options assigned to the February cycle use the middle month of each quarter (February, May, August and November). And options in the March cycle have options available during the last month of each quarter (March, June, September and December). In addition, individual stock options typically expire in the current month and the subsequent month.
-
# filter the contracts with strikes between (market price - 10, market price + 10)
-option.SetFilter(-10,10)
-# filter the contracts which expires more than 30 days but no longer than 60 days
-option.SetFilter(TimeSpan.FromDays(30),TimeSpan.FromDays(60))
-# filter the contracts with strikes between(ATM Strike - 10 * strike space value, market price + 10 * strike space value) and with expiration days less than 180 days
-option.SetFilter(-10, +10, timedelta(0), timedelta(180))
-
-
-
-
Step 3: Choose Contracts - Fine Selection
-For QuantConnect API, Slice class provides a data structure for all of an algorithm's data at a single time step. So you need use property Slice.OptionChains to request options data for this slice.
-
-OptionChains is a collection of OptionChain keyed by the option's underlying symbol. The elements in Slice.OptionChains have properties Key(the underlying symbol object) Value(the option chain).
-
-OptionChain represents an entire chain of option contracts for a single underlying security. In other words, It is a list of option contracts.
-
-OptionContract defines a single option contract at a specific expiration and strike price. For any contract x in option chain, you can use the following statements to check different options properties.
-
-
-
-
Properties of Option Contract x
-
-
-
-
-
x.Symbol.Value
-
Get the string of option contract's symbol
-
-
-
x.AskPrice, x.BidPrice
-
Get the ask price, Get the bid price
-
-
-
x.Expiry
-
Get the expiration date
-
-
-
x.Strike
-
Get the strike price
-
-
-
x.ImpliedVolatility
-
Get the implied volatility
-
-
-
x.Greeks
-
Get the Greeks letter
-
-
-
x.Right
-
Get the right being purchased
-x.Right ＝ OptionRight.Call call option[right to buy]
-x.Right ＝ OptionRight.Put put option[right to sell]
-
-
-
x.UnderlyingLastPrice
-
Get the last price the underlying security traded at
-
-
-
x.UnderlyingSymbol
-
Gets the underlying security's symbol
-
-
-
-We can print out the details of the contract after filtering with Python data frame to show these properties. Assume today is 01/03/2017. The stock price at 01/03/2017 09:31:00 is $776.01 per share. Here we use SetFilter(-1, +1, timedelta(0), timedelta(60)) to filter the contracts.
-
def OnData(self,slice):
- for i in slice.OptionChains:
- if i.Key != self.symbol: continue
- optionchain = i.Value
- self.Log("underlying price:" + str(optionchain.Underlying.Price))
- df = pd.DataFrame([[x.Right,float(x.Strike),x.Expiry,float(x.BidPrice),float(x.AskPrice)] for x in optionchain],
- index=[x.Symbol.Value for x in optionchain],
- columns=['type(call 0, put 1)', 'strike', 'expiry', 'ask price', 'bid price'])
- self.Log(str(df))
-
-
-
-
-
Symbol
-
type(call 0, put 1)
-
Strike
-
Expiry
-
Ask Price
-
Bid Price
-
-
-
-
-
GOOG 170217C00780000
-
0
-
780.0
-
2017-02-17
-
26.4
-
27.9
-
-
-
GOOG 170120P00782500
-
1
-
782.5
-
2017-01-20
-
14.7
-
16.3
-
-
-
GOOG 170120C00782500
-
0
-
782.5
-
2017-01-20
-
9.4
-
10.2
-
-
-
GOOG 170120P00780000
-
1
-
780.0
-
2017-01-20
-
13.4
-
15.0
-
-
-
GOOG 170120C00780000
-
0
-
780.0
-
2017-01-20
-
10.6
-
11.5
-
-
-
GOOG 170217P00780000
-
1
-
780.0
-
2017-02-17
-
28.9
-
30.8
-
-
-
GOOG 170120P00777500
-
1
-
777.5
-
2017-01-20
-
12.2
-
13.7
-
-
-
GOOG 170120C00777500
-
0
-
777.5
-
2017-01-20
-
11.8
-
12.9
-
-
-
-
-
-Here we give an example of how to find ATM, ITM OTM contracts for trading. First, we need to extract the OptionChain from OptionChains according to symbols we added in Initialize step. Secondly, we extract ATM, ITM and OTM contracts by using UnderlyingLastPrice and Strike properties. Note here the strikes of ATM options are not exactly the same as the market price of underlying stocks, thus here we first sort the contracts by the absolute values of the difference between the UnderlyingLastPrice and the Strike. Then we choose the contract with the minimum absolute value as the ATM contract.
-
for i in slice.OptionChains:
- if i.Key != self.symbol: continue
- chain = i.Value
-# differentiate the call and put options
-call = [x for x in optionchain if chain.Right == 0]
-put = [x for x in optionchain if chain.Right == 1]
-# choose ITM contracts
-contracts = [x for x in call if call.UnderlyingLastPrice - x.Strike > 0]
-# or choose ATM contracts
-contracts = sorted(optionchain, key = lambda x: abs(optionchain.Underlying.Price - x.Strike))[0]
-# or choose OTM contracts
-contracts = [x for x in call if call.UnderlyingLastPrice - x.Strike < 0]
-# sort the contracts by their expiration dates
-contracts = sorted(contracts, key = lambda x:x.Expiry, reverse = True)
-
-Finally, we trade the options by using the contract's symbol.
-
if len(contracts) == 0: continue
-# trade the contracts with the farthest expiration
-symbol = contracts[0].Symbol
-self.MarketOrder(symbol, 1)
-self.MarketOnCloseOrder(symbol, -1)
-
-
-
Algorithm
-This simple example demonstrates how you can inspect the option chain to pick a specific option contract to trade.
-
-
Summary
-After mastering the basic knowledge of options market, this tutorial we take a close at how to use Quantconnect to customize your own options trading. For example, how you can access an option chain, how to view the details of the contract as a Python data frame, and the most important how to trade the specific option contract.
-
-Next chapter we will examine some important topics of options like the payoff, Put-Call parity, and the synthetic positions. By learning all those concepts, we will start some brief hedging strategies involving options.
-
-
-This tutorial performs a simple linear regression to build the Capital Asset Pricing Model(CAPM) [ref]Sharpe, William, 1990 http://www.nobelprize.org/nobel_prizes/economic-sciences/laureates/1990/sharpe-lecture.pdf[/ref], a classical model developed by William F. Sharpe and Harry Markowitz. This model yields alpha and beta for each asset and is traded by going long on the stocks ranked with the highest alpha. This tutorial will demonstrate the following:
-
-
How to use historical data
-
Set an event handler
-
Conduct linear regression
-
Build your own functions in the QuantConnect Algorithm Lab
-
- The implementation of the strategy demonstrates that stocks beat the market last month are likely to beat the market again in the subsequent month. This algorithm performs well when the market is smooth. However when the market volatility increases the model fails to capture alpha and it performs poorly. What we learn from this is that market fluctuations decrease the significance level of the linear regression coefficients, especially when we are using daily returns to fit the model.
-
CAPM Theory
-The capital asset pricing model (CAPM) describes the relationship between systematic risk and expected return for assets, typically stocks. The formula for calculating the expected return of an asset given its risk is as follows:
-
-\[r_a = r_f + \beta_a*(r_m - r_f) + \epsilon \]
-
-where:
-
-\[r_f = Risk Free Rate\]
-\[\beta = Beta of the security\]
-
-\[r_m = Expected market return\]
-
-\[\epsilon = Tracking error\]
-
-This formula can be better understood if we refactor the formula as seen below:
-
-\[(r_a - r_f ) = \beta_a*(r_m - r_f) + \epsilon \]
-
-The left side of the equation gives us the difference between the asset return and risk free rate, the "excess return". If we regress the market excess return against the asset excess return the slope represents the "beta" of the asset. Therefore, beta can also be calculated by the equation:
-
-\[\beta = \frac{Cov(r_a,r_b)}{var(r_b)}\]
-
-So beta can be described as:
-
-\[\beta = \rho _a,_b*\frac{\sigma _a}{\sigma_b}\]
-
-The formula above indicates that beta can be explained as "correlated relative volatility". To make this simpler, beta can be calculated by doing a simple linear regression which can be viewed as a factor to explain the return, and the tracking error can represent alpha.
-
-To make this theory more convenient for our algorithm, we change the above formula into the following form:
-
-\[r_a = \beta*r_m + r_f*(1-\beta) + \epsilon\]
-
-r*(1-β) on the right hand side of the equation is a very small item, making it negligible in the context of the Dow 30 companies. If we regress the stocks return with the return of the benchmark, the slope and intercept will be beta and alpha.
-
-
Method
-Our investment logic is simple and straightforward. We assume that stocks which beat the market last month will continue to beat the market. We rank stocks according to their alpha, and each month we "long" the top two stocks. For this strategy to work, we need to do the following at the start of each month:
-
-
Get the historical price of Dow 30 stocks in the past 21 trading days and calculate their daily rates of return.
-
Conduct simple linear regression on the return of each stock against a benchmark (S&P 500 index, SPY).
-
Rank the stocks by their intercepts.
-
Liquidate all our positions and purchase the first 2 stocks in our sorted list.
-
-Dow Jones components change very infrequently, with the last change being on March 19th, 2015 [ref]https://en.wikipedia.org/wiki/Dow_Jones_Industrial_Average[/ref]. To make the implementation easier we have simply listed the current Dow components in this algorithm. This means that the earliest start date of this algorithm is March 19th, 2015.
-
Step 1: Setup Event Handler
-In the initialize method we define a Scheduled Event to trigger a monthly re-balancing of the portfolio. For more details about how to use Scheduled Events, you can read the Documentation or see the example ScheduledEventsAlgorithm.
-
-In order to conduct linear regression, we need to write a function to take the price data and output the regression results. The function takes a list of the "asset prices" (x) and a list of the "benchmark prices" (y). It then calculates the percentage change and conducts a linear regression. The output is a tuple which contains the intercept and slope.
-
def regression(self,x,y):
- x = np.array(x)
- x = np.diff(x)/x[:-1]
- y = np.array(y)
- y = np.diff(y)/y[:-1]
- A = np.vstack([x, np.ones(len(x))]).T
- result = np.linalg.lstsq(A, y)[0]
- beta = result[0]
- alpha = result[1]
- return(alpha,beta)
-
Step 3: History Function
-Each month we get the historical prices of the DOW30 components using the History API. The data is returned from the API as complex Slice objects. To make this useful in the algorithm we extract the asset prices, and benchmark prices to a list.
-
def get_regression_data(self,symbol,history):
- symbol_price = []
- benchmark_price = []
- for i in history:
- bar = i[symbol]
- benchmark = i[self.benchmark]
- symbol_price.append(bar.Close)
- benchmark_price.append(benchmark.Close)
-
- result = self.regression(symbol_price,benchmark_price)
- return result
-
Step 4: Rebalance Function:
-This function is where all the action happens, it will be executed on the first trading day of each month as a scheduled event. The second argument of SetHoldings is a decimal, setting this to "1" tells the algorithm to set the portfolio as "long 100%" with no leverage. More information on the function can be read on this link: SetHoldings.
-
def rebalance(self):
- # get historical stock symbols and prices, then put them in tuples
- history = self.History(self.regression_dates, Resolution.Daily)
- filter = []
- for i in self.symbols:
- filter.append((i,self.get_regression_data(i, history)[0]))
- # sort the filter by alpha
- filter.sort(key = lambda x : x[1],reverse = True)
- sorted_symbols = []
- for i in range(2):
- sorted_symbols.append(filter[i][0])
- # get the symbols of our holding stocks
- holding_list = []
- for i in self.Portfolio:
- if i.Value.Invested:
- holding_list.append(i.Value.Symbol)
- # if we have holdings and we are not going to hold them anymore, sell them
- if holding_list:
- for i in holding_list:
- if i not in sorted_symbols:
- self.Liquidate(i)
- # Long the 2 stock in our list.
- for i in sorted_symbols:
- self.SetHoldings(i,1)
-
Conclusion
-We have demonstrated that during a smooth market, the stocks that beat the market last month are likely to beat the market again in the subsequent month. When there is market fluctuation, the significance level of linear regression will reduce and the model performance will decrease.
-
-We can understand this by looking at the covariance of the asset(x) and the benchmark (y). As the covariance reduces to zero, the beta will decrease.
-
-\[\hat{\beta} = \frac{Cov[x,y]}{\sum (x_i - \b{x})^2}\]
-
-As an experiment, we tested the algorithm on market data from 2015. This was a much more volatile period for the market with a fluctuation that returned a mean close to zero and dropped neaerly 10% from Aug 18th to Aug 25th of that year. The algorithm performed quite poorly in this year with a return rate of -11.58%.
-
-The risks associated with this strategy include a high drawdown, lack of hedging and not stop-loss. Since we are using leverage, the risk is increased and it has a margin call in January as a result.
-
-We can improve the performance by applying the following techniques:
-
-
-
Conduct optimizations: we can implement mean-variance analysis to determine the asset allocation each month and select more stocks to trade. This will lower our risk and manage the portfolio more scientifically.
-
Take beta into consideration: If we want to be more aggressive, we can select targets by a combination of alpha and beta. This means we choose stocks with a high alpha that are more volatile than the market. If we are conservative investors however, we can make the strategy market-neutral, which means the portfolio would not be affected by the market performance. For example, if we long two stocks with beta 1 and -1 respectively at the same position size, our portfolio becomes market-neutral.
-
-
Algorithm
-
diff --git a/Strategy Tutorials/Tutorial02 Combining Mean Reversion and Momentum in Forex Market.html b/Strategy Tutorials/Tutorial02 Combining Mean Reversion and Momentum in Forex Market.html
deleted file mode 100644
index 9c2d533..0000000
--- a/Strategy Tutorials/Tutorial02 Combining Mean Reversion and Momentum in Forex Market.html
+++ /dev/null
@@ -1,195 +0,0 @@
-
Abstract
-In this tutorial we build a strategy combining momentum and mean reversion for the foreign exchange markets from Alina F. Serban's research [ref]Alina F. Serban, Combining mean reversion and momentum trading strategies in foreign exchange markets Online Copy[/ref] which was based on research in the equity market by Ronald J. Balvers and Yangru Wu [ref]Ronald J. Balvers, Yangru Wu, Momentum and mean reversion across national equity markets Online Copy[/ref]. Serban creates a momentum factor using returns of the last 3 months, and a mean reversion factor as a deviation from the mean price. Using these factors we use regression to predict the returns of the coming month. We apply the strategy from Serban's paper and update the mean reversion factor for to improve its significance level.
-
-In theory when trading foreign exchange the expected return accrued in each currency should be the same when adjusted for exchange rates (uncovered interest parity, UIP [ref]Investopedia, Uncovered Interest Rate Parity. Online Copy[/ref]). This suggests the markets should predominately be mean reverting, however in practice we see short term momentum trends and long term mean reversion. This was phenomenon was first noticed by Chiang and Jiang [ref]Chiang, T., Jiang, C., 1995. Foreign exchange returns over short and long horizons. International Review of Economics and Finance 4, 267–282. Online Copy[/ref].
-
-We tested the theory on EURUSD, GBPUSD, USDCAD and USDJPY and re-balanced monthly. The model significance level and coefficients are close to those in paper, but the returns and Sharpe Ratios obtained are not as good as what the paper claimed. The algorithm achieved a fairly stable annual return of 11%, 0.8 Sharpe Ratio and 11% drawdown.
-
Introduction
-The strategy is centered on uncovered interest parity (UIP) theory. UIP states that the change in the exchange rate should incorporate any interest rate differentials between the two currencies. By looking for patterns in the deviation from UIP we can potential generate abnormal returns.
-
Interest Parity Conditions
-UIP states that an investor who borrows money in their home country and lends it in another country with a higher interest rate should expect a zero return due to the changes in exchange rate. In other words:
-
-\[1+r_t = (1+r^{i}_t)(\frac{F^{i}_t}{S^{i}_t})\]
-Where \(r_t\) is the domestic interest rate, \(r^{i}\) is the foreign interest rate, \(S^{i}\) is the spot exchange rate and \(F^{i}\) is the forward rate. We can also replace F forward rate with expected spot rate:
-
-\[1+r_t = (1+r^{i}_t)(\frac{E(S^{i}_{t+1})}{S^{i}_t})\]
-
-Taking logs of the above two equations, we obtain:
-
-\[r_t - r^{i}_t = \ln F^{i}_t - \ln S^{i}_t\]
-
-\[r_t - r^{i}_t =\ln S^{i}_{t+1} - \ln S^{i}_t\]
-
-The deviation from UIP is denoted by y and defined as follows:
-
-\[y^{i}_{t+1} =\ln S^{i}_{t+1} -\ln F^{i}_t\]
-
Model and Parameter Estimation
-Fama and French and Summers [ref]Fama, E., 1984. Forward and spot exchange rates. Journal of Monetary Economics Online Copy 14, 319–338.[/ref] constructed a simple model for stock price that is the sum of a random walk and a stationary component - they represent the natural log of the stock price with x. The stationary component represents the temporary swings in stock price (characterized by coefficient \(\delta \)), the parameter \(\mu \) captures the random walk drift component and a coefficient accounts for the momentum effect \(\rho \). Balvers and Wu construct the log of stock prices as:
-
-\[x^{i}_t = (1 - \delta ^{i})\mu ^{i} + \delta ^{i}x^{i}_{t-1} + \sum_{j=1}^{J}\rho ^{i}(x^{i}_{t-1} - x^{i}_{t-j-1}) + \epsilon ^{u}_t\]
-
-Using the equation above Serban adapts it to find the abnormal return in the forex market. The \(\delta \) represents the speed of mean reversion and can differ by country, while the \(\rho \) represents the momentum strength and can vary by country and by lag. The parameter \(\mu \) also varies by country. Accounting for these changes:
-
-\[y^{i}_t = -(1 - \delta ^{i})(x^{i}_{t-1} - \mu ^{i}) + \sum_{j=1}^{J}\rho ^{i}(x^{i}_{t-1} - x^{i}_{t-j-1}) + \epsilon ^{u}_t\]
-
Trading Strategy
-The trading strategy from the paper allows \(\mu \) to change by country, while let \(\rho \) and \(\delta \) stay fixed. By applying Ordinary Least Squared(OLS) regression, the model estimates the return y for each currency. We construct the portfolio by taking a long position on the currency with the highest expected return and taking a short position on the currency with the lowest expected return. We hold these positions for one month, and repeat the process each month. There are two exceptions to this strategy: if all expected returns are positive, we take a long position only, and vice versa.
-
-To limit the number of parameters we need to estimate and find a solution easily we only allow \(\mu \) to change by country. According to the paper if we let ρ stay fixed and J =3, we can obtain the highest return for this strategy. If so the equation can be simplified as:
-
-\[y^{i}_t = -(1-\delta )(x^{i}_{t-1} - \mu ^{i}) + \rho (x^{i}_{t-1} - x^{i}_{t-4}) + \epsilon ^{i}_t\]
-
-When applying the above equation, we found that the scale of the mean reversion for each currency are very different, and this difference in scale is large enough to affect the accuracy of our rank. We made an adjustment to standardize the mean-reversion. While calculating \(\mu \) (the mean of the log prices) we also calculated standard deviation σ. In this tutorial we replace \(x-\mu \) with \(\frac{x - \mu}{\sigma } \). This captures the mean reversion factor better than the author's technique.
-
Data Description
-The paper used monthly exchange rate data for the Canadian Dollar/USD, German Mark/Euro, UK Pound/USD and Japanese Yen/USD, from 1978 to 2008. Due to data availability, we used Euro/USD instead of German Mark/Euro, and the earliest data available starts from 2004. Each time we launch the strategy we use all of the available historical data prior to the start date to build the OLS model and uses that model for the entire backtest. The paper used 1/3 of their data as the training dataset and the rest of the test set. We directly test our model on backtesting, because QuantConnect makes this easier.
-
Method
-In order to apply the model, we need to first pull history data to build it. The project can be briefly divided into four parts: the historical data request, model training, prediction and execution.
-
Step 1: Request Historical Data
-The first function takes two arguments: symbol and number of daily data points requested. This function requests historical QuoteBars and builds it into a pandas DataFrame. For more information about pandas DataFrame, please refer to the help documentation DataFrame. The calculate_return function takes a DataFrame as an argument to calculate the mean and standard deviation of the log prices, and create new columns for the DataFrame (return, reversal factor and momentum) - it prepares the DataFrame for multiple linear regression.
-
def get_history(self,symbol, num):
- data = {}
- dates = []
- history = self.History([symbol], num, Resolution.Daily).loc[symbol]['close'] #request the historical data for a single symbol
- for time in history.index:
- t = time.to_pydatetime().date()
- dates.append(t)
- dates = pd.to_datetime(dates)
- df = pd.DataFrame(history)
- df.reset_index(drop=True)
- df.index = dates
- df.columns = ['price']
- return df
-
-def calculate_return(self,df):
- #calculate the mean for further use
- mean = np.mean(df.price)
- # cauculate the standard deviation
- sd = np.std(df.price)
- # pandas method to take the last datapoint of each month.
- df = df.resample('BM',how = lambda x: x[-1])
- # the following three lines are for further experiment purpose
- # df['j1'] = df.price.shift(1) - df.price.shift(2)
- # df['j2'] = df.price.shift(2) - df.price.shift(3)
- # df['j3'] = df.price.shift(3) - df.price.shift(4)
- # take the return as depend variable
- df['log_return'] = df.price - df.price.shift(1)
- # calculate the reversal factor
- df['reversal'] = (df.price.shift(1) - mean)/sd
- # calculate the momentum factor
- df['mom'] = df.price.shift(1) - df.price.shift(4)
- df = df.dropna() #remove nan value
- return (df,mean,sd)
-
Step 2: Build Predictive Model
-The concat function requests history and joins the results into a single DataFrame. As \(\mu \) varies by country so we assign the mean and standard deviation to the symbol for each currency for future use. The OLS function takes the resulting DataFrame to conduct an OLS regression. We write it into a function because it's easier to change the formula here if we need.
-
def concat(self):
- # we requested as many daily tradebars as we can
- his = self.get_history(self.quoted[0].Value,20*365)
- # get the clean DataFrame for linear regression
- his = self.calculate_return(his)
- # add property to the symbol object for further use.
- self.quoted[0].mean = his[1]
- self.quoted[0].sd = his[2]
- df = his[0]
- # repeat the above procedure for each symbols, and concat the dataframes
- for i in range(1,len(self.quoted)):
- his = self.get_history(self.quoted[i].Value,20*365)
- his = self.calculate_return(his)
- self.quoted[i].mean = his[1]
- self.quoted[i].sd = his[2]
- df = pd.concat([df,his[0]])
- df = df.sort_index()
- # remove outliers that outside the 99.9% confidence interval
- df = df[df.apply(lambda x: np.abs(x - x.mean()) / x.std() < 3).all(axis=1)]
- return df
-
-def OLS(self,df):
- res = sm.ols(formula = 'return ~ reversal + mom',data = df).fit()
- return res
-
Step 3: Apply Predictive Model
-The predict function uses the history for the last 3 months, merges it into a DataFrame and then calculates the updated factors. Using these updated factors (together with the model we built) we calculate the expected return.
-
def predict(self,symbol):
- # get current month in string
- month = str(self.Time).split(' ')[0][5:7]
- # request the data in the last three months
- res = self.get_history(symbol.Value,33*3)
- # pandas method to take the last datapoint of each month
- res = res.resample('BM',how = lambda x: x[-1])
- # remove the data points in the current month
- res = res[res.index.month != int(month)]
- # calculate the variables
- res = self.calculate_input(res,symbol.mean,symbol.sd)
- res = res.ix[0]
- # take the coefficient. The first one will not be used for sum-product because it's the intercept
- params = self.formula.params[1:]
- # calculate the expected return
- re = sum([a*b for a,b in zip(res[1:],params)]) + self.formula.params[0]
- return re
-
-def calculate_input(self, df, mean, sd):
- df['reversal'] = (df.price - mean)/sd
- df['mom'] = df.price - df.price.shift(3)
- df = df.dropna()
- return df
-
-There are a few points of note:
-
-
We need historical TradeBars for the last three months. To do this we requested 99 bars and use a pandas DataFrame to extract a data point for the end of each month.
-
We use event schedule to execute the strategy at the first trading day, however, sometimes the first day of the month could be on the 2nd if the 1st falls on a weekend. To fix this we remove the data from the current month, leaving only the last 3 months of data.
-
We start from the second element of res (res[1:]) because res and params are different lengths. This was hard to detect because Python would not throw error when running [a*b for a,b in zip(res,params)] even if the length of the two lists are different.
-
This function also used pandas DataFrame methods extensively. For more information please refer to pandas.
-
-
Step 4: Initializing the Model
-In the Initialize function we prepare the data and conduct a linear regression. The class property 'self.formula' is the result of the OLS regression. We will use this object each time we rebalance the portfolio.
-
def Initialize(self):
- self.SetStartDate(2013,6,1)
- self.SetEndDate(2016,6,1)
- self.SetCash(10000)
- self.syls = ['EURUSD','GBPUSD','USDCAD','USDJPY']
- self.quoted = []
- for i in range(len(self.syls)):
- self.quoted.append(self.AddForex(self.syls[i],Resolution.Daily,Market.Oanda).Symbol)
- df = self.concat()
- self.Log(str(df))
- self.formula = self.OLS(df)
- self.Log(str(self.formula.summary()))
- self.Log(str(df))
- self.Log(str(df.describe()))
- for i in self.quoted:
- self.Log(str(i.mean) + ' ' + str(i.sd))
- self.Schedule.On(self.DateRules.MonthStart(), self.TimeRules.At(9,31), Action(self.action))
-
Step 5: Performing Monthly Rebalancing
-Every month we rebalance the portfolio using the Schedule Event helper method. The predicted returns are added to the rank array and then sorted by return. The first element in the list is the best return paired with the associated symbol. When all the expected returns in the rank array are positive we only go long the pair with the highest expected return. When all returns are negative, we only go short the pair with the lowest expected return.
-
def action(self):
- rank = []
- long_short = []
- for i in self.quoted:
- rank.append((i,self.predict(i)))
-# rank the symbols by their expected return
- rank.sort(key = lambda x: x[1],reverse = True)
-# the first element in long_short is the one with the highest expected return, which we are going to long, and the second one is going to be shorted.
- long_short.append(rank[0])
- long_short.append(rank[-1])
- self.Liquidate()
-
-# the product < 0 means the expected return of the first one is positive and that of the second one is negative--we are going to long and short.
- if long_short[0][1]*long_short[1][1] < 0:
- self.SetHoldings(long_short[0][0],1)
- self.SetHoldings(long_short[1][0],-1)
- # this means we long only because all of the expected return is positive
- elif long_short[0][1] > 0 and long_short[1][1] > 0:
- self.SetHoldings(long_short[0][0],1)
-# short only
- else:
- self.SetHoldings(long_short[1][0],-1)
-
Results
-The following regression output is obtained by backtesting the time period from Jun 2013 to Jun 2016. We can see the results are fairly close to those from the source paper with a R-squared value of 3.1% compared to the paper's 3.89%. Our momentum coefficient, ρ, is 0.0344 compared to the paper's 0.042. We obtained 0.9955 mean reversion coefficient (1 - 0.0045), and the paper got 0.9859.
-
-
-From these results we can say the limited sample size does not impair the feasibility of this model. The t-stats of the coefficients are -4.074 and 1.417 for the reversal factor and momentum factor respectively. The p-value of the reversal factor is very small which means this factor has a very high significance level.
-
Backtest Sensitivity Results
-We performed some rough period sensitivity analysis in different time periods and summarized the results as the following table:
-
-The compound annual returns are quite stable, however, the paper claimed that the average return is 27.5% vs our 11% achieved. This difference can be accounted for by the data time span and currency pairs.
-
Conclusion
-The paper demonstrates there are inefficiencies in the UIP which can be exploited with a hybrid momentum and mean reversion strategy. Although the sample size of the paper is much larger than ours the parameter and significance level of the two models are very close. The strategies we discussed above keep \(\rho \) fixed and only allow \(\mu \) to change by country. If we let \(\rho \) change by lag the significance level of the model might increase, but this could potentially make modeling more difficult by introducing multicollinearity. To test this we wrote this implementation in the algorithm and commented out the lines. If you are interested in exploring this extension to the model you can change these lines to test your strategy.
-
-We investigate two pairs trading methods and compare the results. Pairs trading involves in investigating the dependence structure between two highly correlated assets. With the assumption that mean reversion will occur, long or short positions are entered in the opposite direction when there is a price divergence. Typically the asset price distribution is modeled by a Gaussian distribution of return series but the joint normal distribution may fail to catch some key features of the dependence of stock pairs' price like tail dependence. We investigate using copula theory to identify these trading opportunities.
-
-In this tutorial, we will discuss the basic framework of copula from the mathematical perspective and explain how to apply the approach in pairs trading. The implementation of the algorithm is based on based on the paper Trading strategies with copulas [ref]Stander Y, Marais D, Botha I. Trading strategies with copulas[J]. Journal of Economic and Financial Sciences, 2013, 6(1): 83-107. Online Copy [/ref] from Stander Y, Marais D, Botha I(2013). We compare the performance of the copula pairs trading strategy with the co-integration pairs trading method based on the paper Statistical arbitrage trading strategies and high-frequency trading from Hanson T A, Hall J R. (2012)[ref]Hanson T A, Hall J R. Statistical arbitrage trading strategies and high-frequency trading[J]. 2012.[/ref]. The co-integration technique assumes a co-integration relationship between paired equities to identify profitable trading opportunities. The empirical results suggest that the copula-based strategy is more profitable than the traditional pairs trading techniques.
-
Framework of Copula
-
1. Definition
-Given a random vector \(X_1,X_2,...,X_p\), its marginal cumulative distribution functions (CDFs) are \(F_i(x) = P[X_i \leq x]\). By applying the probability integral transform to each component, the marginal distributions of \((U_1,U_2,...,U_p) = (F_1(X_1),F_2(X_2),...,F_p(X_p))\) are uniform (from Wikipedia).
-
-Then the copula of \(X_1,X_2,...,X_p\) is defined as the joint cumulative distribution function of \(U_1,U_2,...,U_p\), for which the marginal distribution of each variable U is uniform as \(U(0,1)\).
-
-\[C(u_1,u_2,...,u_p) = P[U_1\leq u_1,U_2\leq u_2,..., U_1\leq u_1]\]
-
-Copulas function contains all the dependency characteristics of the marginal distributions and will better describe the linear and non-linear relationship between variables, using probability. They allow the marginal distributions to be modeled independently from each other, and no assumption on the joint behavior of the marginals is required.[ref]Rad H, Low R K Y, Faff R. The profitability of pairs trading strategies: distance, cointegration and copula methods[J]. Quantitative Finance, 2016, 16(10): 1541-1558.online copy[/ref]
-
2. Bivariate Copulas
-Since this research focuses on bivariate copulas (for pairs trading we have 2 random variables) some probabilistic properties are specified.
-
-Let X and Y be two random variables with cumulative probability function \(F_1(X)\) and \(F_2(Y)\). \(U=F_1(X), V=F_2(Y)\) which are uniformly distributed. Then the copula function is \(C(u,v)=P(U\leq u,V\leq v)\). Taking the partial derivative of the copula function over U and V would give the conditional distribution function as follows:
-
-\[P(U\leq u\mid V= v)=\frac{\partial C(u,v)}{\partial v}\]
-
-\[P(V\leq v\mid U= u)=\frac{\partial C(u,v)}{\partial u}\]
-
3. Archimedean Copulas
-There are many copula functions that enable us to describe dependence structures between variables, other than the Gaussian assumption. Here we will focus three of these; the Clayton, Gumbel and Frank copula formulas from the Archimedean class.
-
-Archimedean copulas[ref]Mahfoud M, Michael M. Bivariate Archimedean copulas: an application to two stock market indices[J]. BMI Paper, 2012. Online Copy[/ref] are based on the Laplace transforms φ of univariate distribution functions. They are constructed by a particular generator function \(\phi\) [ref]LANDGRAF N, SCHOLTUS K, DIRIS D R B. High-Frequency copula-based pairs trading on US Goldmine Stocks[J]. 2016.[/ref].
-
-\[C(u,v)=\phi^{-1}( \phi(u),\phi(v) )\]
-
-The probability density function is:
-
-\[c(u,v)=\phi_{(2)}^{-1}(\phi(u)+\phi(v))\phi^{'}(u)\phi^{'}(v)\]
-
-Where \(\phi_{(2)}^{-1}\) is the inverse of the second derivative of the generator function.
-
-
-
-Genest and MacKay (1986) [ref]Genest, C. and MacKay, J., 1986, The Joy of Copulas: Bivariate Distributions with Uniform Marginals, The American Statistician, 40, 280-283[/ref] proved that the relation between the copula generator function and Kendall rank correlation tau in the bivariate case can be given by:
-
-\[\tau=1+4\int_{0}^{1} \frac{\partial \phi (v)}{\partial \phi^{'}(v)}dv\]
-
-So we can easily estimate the parameter in Archimedean copulas if we know Kendall’s tau rank measure and the generator function. Please refer to step 3 to see the formulas.
-
Part I: Copula Method
-ETFs have many different stock sectors and asset classes which provide us a wide range of pairs trading candidates. Our data set consists of daily data of the ETFs traded on the NASDAQ or the NYSE.
-
-We use the first 3 years of data to choose the best fitting copula and asset pair ("training formation period"). Next, we use a period of 5 years from 2011 to 2017 ("the trading period"), to execute the strategy. During the trading period we use a rolling 12 month window of data to get the copula parameters ("rolling formation period").
-
Step 1: Selecting the Paired Stocks
-The general method of pair selection is based on both fundamental and statistical analysis.[ref]Jean Folger. Pairs Trading Example Online Copy[/ref]
-
1) Assemble a list of potentially related pairs
-Any random pairs could be correlated. It is possible that those variables are not causally related to each other, but because of a spurious relationship due to either coincidence or the presence of a certain third, unseen factor. Thus, it is important for us to start with a list of securities that have something in common. For this demonstration, we choose some of the most liquid ETFs traded on the Nasdaq or the NYSE. The relationship for those potentially related pairs could be due to an index, sector or asset class overlap. e.g. QQQ and XLK are two ETFs which track the market leading indices.
-
2) Filter the trading pair with statistical correlation
-
-
-
-
-
-To determine which stock pairs to include in the analysis, correlations between the pre-selected ETF pairs are analyzed. Below are three types of correlation measures we usually use in statistics:
-
\(n\) = number of value in each data set
-\(n_c\) = number of concordant
-\(n_d\) = number of discordant
-\(d_i\) = the difference between the ranks of corresponding values \(x_i\) and \(y_i\)
-
-
-
-
-We can get these coefficients in Python using functions from the stats library in SciPy. The correlations have been calculated using daily log stock price returns during the training formation period. We found the 3 correlation techniques give the paired ETFs the same correlation coefficient ranking. The Pearson correlation assumes that both variables should be normally distributed. Thus here we use Kendall rank as the correlation measure and choose the pairs with the highest Kendall rank correlation to implement the pairs trading.
-
-We get the daily historical closing price of our ETFs pair by using the History function and converting the prices to a log return series. Let \(P_x\) and \(P_y\) denote the historical stock price series for stock x and stock y. The log returns for the ETFs pair are given by:
-
-\[R_x = ln(\frac{P_{x,t}}{P_{x,t-1}}), R_y = ln(\frac{P_{y,t}}{P_{y,t-1}})\] t = 1,2,...,n where n is the number of price data
-
def _pair_selection(self):
- tick_syl = [["QQQ","AGG","XME","TNA","FAS","XLF","EWC","QLD"],["XLK","JNK","EWG","TLT","FAZ","XLU","EWA","QID"]]
- logreturn={}
- for i in range(2):
- syl = [self.AddSecurity(SecurityType.Equity, x, Resolution.Daily).Symbol for x in tick_syl[i]]
- history = self.History(self.lookbackdays,Resolution.Daily)
- # generate the log return series of different ETFs
- for j in range(len(tick_syl[i])):
- close_price = []
- for slice in history:
- bar = slice[syl[j]]
- close_price.append(bar.Close)
- logreturn[tick_syl[i][j]] = np.diff(np.log([float(z) for z in close_price]))
- # estimate coefficients of different correlation measures
- tau_coef,pr_coef,sr_coef= [],[],[]
- for i in range(len(tick_syl[i])):
- tik_x, tik_y= logreturn[tick_syl[0][i]], logreturn[tick_syl[1][i]]
- tau_coef.append(kendalltau(tik_x, tik_y)[0])
- pr_coef.append(pearsonr(tik_x, tik_y)[0])
- sr_coef.append(spearmanr(tik_x, tik_y)[0])
- index_max = tau_coef.index(max(tau_coef))
- self.ticker = [tick_syl[0][index_max],tick_syl[1][index_max]]
-
-
Step 2: Estimating Marginal Distributions of log-return
-In order to construct the copula, we need to transform the log-return series \(R_x\) and \(R_y\) to two uniformly distributed values u and v. This can be done by estimating the marginal distribution functions of \(R_x\) and \(R_y\) and plugging the return values into a distribution function. As we make no assumptions about the distribution of the two log-return series, here we use the empirical distribution function to approach the marginal distribution \(F_1(R_x)\) and \(F_2(R_y)\). The Python ECDF function from the statsmodel library gives us the Empirical CDF as a step function.
-
Step 3: Estimating Copula Parameters
-As discussed above, we estimate the copula parameter theta by the relationship between the copula and the dependence measure Kendall’s tau, for each of the Archimedean copulas.
-
def _parameter(self, family, tau):
- if family == 'clayton':
- return 2*tau/(1-tau)
- elif family == 'frank':
- # debye = quad(integrand, sys.float_info.epsilon, theta)[0]/theta is first order Debye function
- # frank_fun is the squared difference
- # Minimize the frank_fun would give the parameter theta for the frank copula
- integrand = lambda t: t/(np.exp(t)-1)
- frank_fun = lambda theta: ((tau - 1)/4.0 - (quad(integrand, sys.float_info.epsilon, theta)[0]/theta - 1)/theta)**2
- return minimize(frank_fun, 4, method='BFGS', tol=1e-5).x
- elif family == 'gumbel':
- return 1/(1-tau)
-
-
-
Step 4: Selecting the Best Fitting Copula
-Once we get the parameter estimation for the copula functions, we use the AIC criteria to select the copula that provides the best fit in algorithm initialization.
-
-\[AIC=-2L(\theta)+2k\]
-
-where \(L(\theta)=\sum_{t=1}^T\log c(u_t,v_t;\theta)\) is the log-likelihood function and k is the number of parameters, here k=1.
-
-The density functions of each copula function are as follows:
-
def _lpdf_copula(self, family, theta, u, v):
- ''' estimate the log probability density function of three kinds of Archimedean copulas '''
- if family == 'clayton':
- pdf = (theta+1) * ((u**(-theta)+v**(-theta)-1)**(-2-1/theta)) * (u**(-theta-1)*v**(-theta-1))
- elif family == 'frank':
- num = -theta * (np.exp(-theta)-1) * (np.exp(-theta*(u+v)))
- denom = ((np.exp(-theta*u)-1) * (np.exp(-theta*v)-1) + (np.exp(-theta)-1))**2
- pdf = num/denom
- elif family == 'gumbel':
- A = (-np.log(u))**theta + (-np.log(v))**theta
- c = np.exp(-A**(1/theta))
- pdf = c * (u*v)**(-1) * (A**(-2+2/theta)) * ((np.log(u)*np.log(v))**(theta-1)) * (1+(theta-1)*A**(-1/theta))
- return np.log(pdf)
-
-The copula that provides the best fit is the one that corresponds to the lowest value of AIC criterion. The chosen pair is "QQQ" & "XLK".
-
self.family = ['clayton', 'frank', 'gumbel']
-tau = kendalltau(x, y)[0] # estimate Kendall'rank correlation
-AIC ={} # generate a dict with key being the copula family, value = [theta, AIC]
-for i in self.family:
- lpdf = [self._lpdf_copula(i, self._parameter(i,tau), x, y) for (x, y) in zip(u, v)]
- # Replace nan with zero and inf with finite numbers in lpdf list
- lpdf = np.nan_to_num(lpdf)
- loglikelihood = sum(lpdf)
- AIC[i] = [self._parameter(i,tau), -2*loglikelihood + 2]
- # choose the copula with the minimum AIC
- self.copula = min(AIC.items(), key = lambda x: x[1][1])[0]
-
-
-
Step 5: Generating the Trading Signals
-The copula functions include all the information about the dependence structures of two return series. According to Stander Y, Marais D, Botha I(2013)[ref]Stander Y, Marais D, Botha I. Trading strategies with copulas[J]. Journal of Economic and Financial Sciences, 2013, 6(1): 83-107. Online Copy [/ref], the fitted copula is used to derive the confidence bands for the conditional marginal distribution function of \(C(v\mid u)\) and \(C(u\mid v)\), that is the mispricing indexes. When the market observations fall outside the confidence band, it is an indication that pairs trading opportunity is available. Here we choose 95% as the upper confidence band, 5% as the lower confidence band as indicated in the paper. The confidence level was selected based on a back-test analysis in the paper that shows using 95% seems to lead to appropriate trading opportunities to be identified.
-
-Given current returns \(R_x, R_y\) of stock X and stock Y, we define the "mis-pricing indexes" are:
-
-\[MI_{X|Y}=P(U\leq u\mid V\leq v)=\frac{\partial C(u,v)}{\partial v}\]
-
-\[MI_{Y|X}=P(V\leq v\mid U\leq u)=\frac{\partial C(u,v)}{\partial u}\]
-
-For further mathematical proof, please refer to Xie W, Wu Y(2013)[ref]Xie W, Wu Y. Copula-based pairs trading strategy[C]//Asian Finance Association (AsFA) 2013 Conference. doi. 2013, 10.[/ref]
-
-The conditional probability formulas of bivariate copulas can be derived by taking partial derivatives of copula functions shown in Table 1. The results are as follows:
-
-Gumbel Copula
-
-\[C(v\mid u)=C(u,v;\theta)[(-\ln u)^\theta+(-\ln v)^\theta]^{\frac{1-\theta}{\theta}}(-\ln u)^{\theta-1}\frac{1}{u}\]
-
-\[C(u\mid v)=C(u,v;\theta)[(-\ln u)^\theta+(-\ln v)^\theta]^{\frac{1-\theta}{\theta}}(-\ln v)^{\theta-1}\frac{1}{v}\]
-
-
-
-
-Clayton Copula
-
-\[C(v\mid u)=u^{-\theta-1}(u^{-\theta}+v^{-\theta}-1)^{-\frac{1}{\theta}-1}\]
-
-\[C(u\mid v)=v^{-\theta-1}(u^{-\theta}+v^{-\theta}-1)^{-\frac{1}{\theta}-1}\]
-
-Frank Copula
-
-\[C(v\mid u)=\frac{(exp(-\theta u)-1)(exp(-\theta v)-1)+(exp(-\theta v)-1)}{(exp(-\theta u)-1)(exp(-\theta v)-1)+(exp(-\theta)-1)} \]
-
-\[C(u\mid v)=\frac{(exp(-\theta u)-1)(exp(-\theta v)-1)+(exp(-\theta u)-1)}{(exp(-\theta u)-1)(exp(-\theta v)-1)+(exp(-\theta)-1)} \]
-
-After selection of trading pairs and the best-fitted copulas, we take the following steps for trading. Please note we implement the Steps 1, 2, 3 and 4 on the first day of each month using the daily data for the last 12 months, which means our empirical distribution functions and copula parameters theta estimation are updated once a month. In summary each month:
-
-
During the 12 months' rolling formation period, daily close prices are used to calculate the daily log returns for the pair of ETFs and then compute Kendall's rank correlation.
-
Estimate the marginal distribution functions of log returns of X and Y, which are ecdf_x and ecdf_y separately.
-
Plug Kendall's tau into copula parameter estimation functions to get the value of theta.
-
Run linear regression over the two price series. The coefficient is used to determine how many shares of stock X and Y to buy and sell. For example, if the coefficient is 2, for every X share that is bought or sold, 2 units of Y are sold or bought.
-
-
def _set_signal(self):
- history = self.History(self.lookbackdays,Resolution.Daily)
- # generate the log return series of paired stocks
- # logreturn_trade is a dictionary to store the history log return series of paired stocks each trading day
- price = {}
- logreturn_trade = {}
- for j in range(len(self.syl)):
- close = []
- for slice in history:
- bar = slice[self.syl[j]]
- close.append(bar.Close)
- price[self.ticker[j]] = close
- logreturn_trade[self.ticker[j]] = np.diff(np.log([float(z) for z in close]))
-
- x, y = logreturn_trade[self.ticker[0]], logreturn_trade[self.ticker[1]]
-
- # estimate Kendall'rank correlation each trading day
- tau = kendalltau(x, y)[0]
-
- # etstimate the copula parameter: theta
- self.theta = self._parameter(self.copula, tau)
-
- # simulate the empirical distribution function for returns of two paired stocks
- self.ecdf_x, self.ecdf_y = ECDF(x), ECDF(y)
- # run linear regression over the two history return series
- ols = linear_model.LinearRegression()
- self.coef = ols.fit(np.array(price[self.ticker[0]]).reshape(-1,1), np.array(price[self.ticker[1]])).coef_
-
-
-Finally during the trading period, each day we convert today's returns to u and v by using empirical distribution functions ecdf_x and ecdf_y. After that, two mispricing indexes are calculated every trading day by using the estimated copula C. The algorithm constructs short positions in X and long positions in Y on the days that \(MI_{Y|X}<0.05\) and \(MI_{X|Y}>0.95\). It constructs short position in Y and long positions in X on the days that \(MI_{Y|X}>0.95\) and \(MI_{X|Y}<0.05\).
-
def OnData(self,data):
- for i in self.syl:
- self.price_list[i].append(self.Portfolio[i].Price)
- # compute today's log return of 2 stocks
- if len(self.price_list[self.syl[0]]) < 2 or len(self.price_list[self.syl[1]]) < 2: return
- else:
- return_x = np.log(float(self.price_list[self.syl[0]][-1]/self.price_list[self.syl[0]][-2]))
- return_y = np.log(float(self.price_list[self.syl[1]][-1]/self.price_list[self.syl[1]][-2]))
- # Convert the two returns to uniform values u and v using the empirical distribution functions
- u_value = self.ecdf_x(return_x)
- v_value = self.ecdf_y(return_y)
- # Compute the mispricing indices for u and v by using estimated copula
- self._misprice_index(self.copula, self.theta, u_value, v_value)
- quantity = self.CalculateOrderQuantity(self.syl[1],0.4)
- if self.MI_u_v < self.floor_CL and self.MI_v_u > self.cap_CL:
- if self.Portfolio[self.syl[0]].Quantity < 0 and self.Portfolio[self.syl[1]].Quantity > 0:
- self.Liquidate(self.syl[0])
- self.Liquidate(self.syl[1])
- quantity = self.CalculateOrderQuantity(self.syl[1],0.4)
- self.Sell(self.syl[1], 1 * quantity )
- self.Buy(self.syl[0], self.coef * quantity)
- else:
- self.Sell(self.syl[1], 1 * quantity )
- self.Buy(self.syl[0], self.coef * quantity)
- elif self.MI_u_v > self.cap_CL and self.MI_v_u < self.floor_CL:
- if self.Portfolio[self.syl[0]].Quantity > 0 and self.Portfolio[self.syl[1]].Quantity < 0:
- self.Liquidate(self.syl[0])
- self.Liquidate(self.syl[1])
- quantity = self.CalculateOrderQuantity(self.syl[1],0.4)
- self.Buy(self.syl[1], 1 * quantity )
- self.Sell(self.syl[0], self.coef * quantity)
- else:
- self.Buy(self.syl[1], 1 * quantity )
- self.Sell(self.syl[0], self.coef * quantity)
-
Part II: Cointegration Method
-For the cointegration pairs trading method, we choose the same ETF pair "GLD" & "DGL". There is no need to choose a copula function so there is only a 12 month rolling formation period. The trading period is 5 years from January 2011 to May 2017.
-
Step 1: Generate the Spread Series
-At the start of each month, we generate the log price series of two ETFs with the daily close. Then the spread series is estimated using regression analysis based on log price series data.
-
-For equities X and Y, we run linear regression over the log price series and get the coefficient β.
-
-\[spread_t=\log(price_t^y)-\beta \log(price_t^x)\]
-
Step 2: Compute the Threshold
-
-
-
-
-Using the standard deviation of spread during the rolling formation period, a threshold of two standard deviations is set up for the trading strategy as indicated in the paper.
-
-
-
def _set_signal(self):
- history = self.History(self.numdays,Nullable[Resolution](Resolution.Daily))
- logprice = {}
- for j in range(len(self.syl)):
- close = []
- for slice in history:
- bar = slice[self.syl[j]]
- close.append(bar.Close)
- logprice[self.ticker[j]] = np.log([float(z) for z in close]) # generate the log return series of stock price
- # run linear regression over the two history log price series
- reg = linear_model.LinearRegression()
- x,y = logprice[self.ticker[0]],logprice[self.ticker[1]]
- reg.fit([[n] for n in x],y)
- self.coef = reg.coef_ # reg.intercept_
- self.spread = y - self.coef * x #compute the spread series based on regression result
- self.mean, self.std = np.mean(self.spread),np.std(self.spread)
-
- logprice_x = np.log(float(self.Portfolio[self.syl[0]].Price))
- logprice_y = np.log(float(self.Portfolio[self.syl[1]].Price))
-
- syl_x, syl_y = self.syl[0],self.syl[1]
- quantity = float(self.CalculateOrderQuantity(syl_x,0.4))
-
- current_spread = float(logprice_y) - self.coef * float(logprice_x)
-
- if current_spread > self.mean + self.threshold * self.std:
- self.Sell(syl_y, np.exp(self.coef) * quantity)
- self.Buy(syl_x, quantity)
- elif current_spread < self.mean - self.threshold * self.std:
- self.Buy(syl_y, np.exp(self.coef) * quantity )
- self.Sell(syl_x, quantity)
- if self.Portfolio[self.syl[0]].Quantity != 0 and self.Portfolio[self.syl[1]].Quantity != 0:
- if current_spread < 0.5 * self.std and current_spread > -0.5 * self.std:
- self.Liquidate()
-
-
-
-
-
-
-
Step 3: Set up the Trading Signals
-On each trading day, we enter a trade whenever the spread moves more than two standard deviations away from its mean. In other words, we construct short positions in X and long positions in Y on the day that spread>mean+2*std. We construct short positions in Y and long positions in X on the day that spread<mean-2*std. The trade is exited if the spread reverts to its equilibrium (defined as less than half a standard deviation from zero spread).
-
-The value of mean and standard deviation are calculated from the rolling formation period and will be updated once a month.
-
-
-
-
-
Conclusion
-
-
-
-
method
-
Transactions
-
Profit
-
Sharpe Ratio
-
Drawdown
-
-
-
-
-
Copula
-
347
-
325.4%
-
1.005
-
20.2%
-
-
-
Cointegration
-
33
-
71.2%
-
0.781
-
15.6%
-
-
-
-Ultimately pairs trading intends to capture the price divergence of two correlated assets through mean reversion. Our results demonstrate that the copula approach for pairs trading is superior to the conventional cointegration method because it is based on the probability of the dependence structure, vs cointegration which relies on simple linear regression variance from normal pricing. We found through testing the performance of the copula method less sensitive to the starting parameters. Because the cointegration method relies on standard distribution and the ETF pairs had low volatility there were few trading opportunities.
-
-Generally, ETFs are not very volatile and so mean-reversion did not provide many trading opportunities. There are only 39 trades during 5 years for cointegration method.
-
-It is observed that the use of copula in pairs trading provides more trading opportunities as it does not require any rigid assumptions[ref]Liew R Q, Wu Y. Pairs trading: A copula approach[J]. Journal of Derivatives & Hedge Funds, 2013, 19(1): 12-30.[/ref].
-
Backtest
-Backtest for copula method
-
-Backtest for cointegration method
-
diff --git a/Strategy Tutorials/Tutorial04 The Dynamic Breakout II Strategy.html b/Strategy Tutorials/Tutorial04 The Dynamic Breakout II Strategy.html
deleted file mode 100644
index 6f79c26..0000000
--- a/Strategy Tutorials/Tutorial04 The Dynamic Breakout II Strategy.html
+++ /dev/null
@@ -1,64 +0,0 @@
-
Abstract
-In this tutorial we will take a close look at the Dynamic Breakout II strategy based on the book Building Winning Trading Systems [ref]George Pruitt, John R. Hill, Michael Russak (September 2012). Building Winning Trading Systems, page 126, Online Copy[/ref].
-
-First we decide the look-back period based on the change rate of volatility, then we make trading decisions based on the highest high and lowest low from the look back period as well as a Bollinger Bands indicator. It is an auto adaptive trading system that can adjust its buy and sell rules depending on the performance of these rules in the past. In addition to Forex markets it is widely used in future and equity markets. You can refer to this video to learn more about dynamic break out II.
-
-The original Dynamic Break Out system was developed by George Pruitt for Futures Magazine in 1996. The logic behind the dynamic breakout system is that the volatility component changes the lookback period, then the enter and exit points are decided by the highest high and lowest low price over the lookback period. The newer version of the Dynamic Break Out is just like the original, except we introduce the Bollinger Band and adjust the number of look back days using the market volatility, so different market conditions perform better with different parameters. In addition, the stop loss signal is fixed in version one, but in version two the liquidate point is based on the moving average indicator and the length of moving average is dynamically changed with the look-back period.
-
-We backtested the strategy on EURUSD and GBPUSD over 6 years period. The result suggests a drawdown of 20% and the strategy caught the market turning points. It is especially profitable in a trending market.
-
Method
-
Step 1: Determine the look back periods
-
-The lookback period is the number of bars back from the most recent bar that the price or indicator looks at to make the momentum calculations.[ref]Robert C. Miner(October 20, 2008). High Probability Trading Strategies: Entry to Exit Tactics for the Forex, Futures, and Stock Markets, page 37, Online Copy[/ref]
-
-To start the look back period is set to 20 days to determine its buy and sell levels. We change the number of look back days in proportion to changes in market volatility. Through this method the number of look back days changes on a daily basis. At the end of each day, the current market volatility is calculated by the standard deviation of the past 30 day's closing prices.
-
close = self.History(self.syl, 31, Resolution.Daily)['close']
- todayvol = np.std(close[1:self.numdays+1])
- yesterdayvol = np.std(close[0:self.numdays])
- deltavol = (todayvol - yesterdayvol) / todayvol
- self.numdays = round(self.numdays * (1 + deltavol)) # the number of days must be integer
-
-
-Though the look back days are dynamic, it needs to be restricted within an acceptable range of 20 to 60.
-
-
Step 2: Choose the algorithm buy/sell point
-
-For a buy setup, the close price of the previous day must be above the upper Bollinger Band. In addition the ask price must be above the highest high of the most recent N days. Where N is the look back days from Step-1.
-
-For a sell setup, the close price of previous day must be below the lower Bollinger Band and the ask price must be below the lowest low of the most recent N days. The length of the Bollinger Band calculation is the same number of look back days that is generated by Step-1.
-
-Bollinger Band is a popular technical indicator. k is a constant. Here we choose k=2.
-\[ Upper Band = moving\ average + k\times standard\ deviation \]
-
-\[ Lower Band = moving\ average - k\times standard\ deviation \]
-
-
-
-QuantConnect provides more than 100 technical indicators for you to use in your algorithm. These are provided as class objects in Python. A full list of the indicators and their properties can be found in the reference table of the documentation page.
-
-The exit signal for an existing holding is determined by calculating a simple moving average of closing prices for the past look back days. That is to say, we liquidate a long position if the current price is lower than the moving average of the close price over the look back period, and vice versa for selling a short position.
-
-For six years backtesting of EURUSD, the overall statistics show an annual rate of return of 2.3% and with a Sharpe Ratio of 0.31. EURUSD has a significant uptrend from 2010 to 2012. This momentum strategy outperforms the market and seems to be profitable from 2010 to 2014. The maximum drawdown occurs in May 2015 to December 2015 and is roughly 14%. From our results we find the strategy works best in an trending forex market.
-
-In contrast, GBPUSD is pretty volatile during the tested period from 2010 to 2016. Our testing demonstrated a negative annual rate of return with a drawdown of approximately 19%.
-
-When the volatility decreases, the price tends to continue following the current trend. Volatility causes the the look back days to decrease when computing the bollinger bands, making it easier to enter a trade. If the market volatility increases we increase the look back days in order to filter the fake signals, making it harder to enter a trade.
-
-Here we use the standard deviation of price as a measure of market volatility. To improve the model we could choose other measures of volatility like standard deviation of logarithm return series or other stochastic volatility measures.
-
-
-The Dual Thrust trading algorithm [ref]Gang Wei(May 2012). Dual Thrust Intraday Strategy, Online Copy[/ref] is a famous strategy developed by Michael Chalek. It has been commonly used in futures, forex and equity markets. The idea of Dual Thrust is similar to a typical breakout system, however dual thrust uses the historical price to construct update the look back period - theoretically making it more stable in any given period.
-
-In this tutorial we give a brief introduction to the strategy and show how to implement this algorithm on QuantConnect. After pulling in the historical price of the chosen stock, the range is calculated based on the close, high and low over the most recent N-days. A position is opened when the market moves a certain range from the opening price. We tested the strategy on individual stocks under two market states: a trending market and range bound market. The results suggest this momentum trading system works better in trending market but will trigger some fake buy and sell signals in much more volatile market. Under the range bound market, we can adjust the parameters to get better return. As a comparison of individual stocks, we also implemented the strategy on SPY. The result suggested that the strategy beat the market.
-
Method
-
Step 1 : Initialization of algorithm
-Firstly we need to initialize the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must be initialized.
-
-Although this is an intraday strategy, we still want to test the strategy within a long period not just within one day. The scheduling methods sets up an event to fire at a specific date or time and will execute the scheduled event function.
-
-Here Schedule.On(DateRules, TimeRules, Action()) will trigger every trading day for our stock, at market open. Events are scheduled using date and time rules. Date rules specify on what dates and event will fire. Time rules specify at what time on those dates the event will fire. Inside of the scheduled function, we can pull the recent historical data and current open price each trading day.
-
-The long signal is calculated by \[cap = open + K_1 \times Range\]. The short signal is calculated by \[floor = open – K_2 \times Range\] where K1 and K2 are the parameters. When K1 is greater than K2, it is much easier to trigger the long signal and vice versa. For demonstration, here we choose K1 = K2 = 0.5. In live trading, we can still use historical data to optimize those parameters or adjust the parameters according to the market trend. K1 should be small than k2 if you are bullish on the market and k1 should be much bigger if you are bearish on the market.
- holdings = self.Portfolio[self.syl].Quantity
- if self.Portfolio[self.syl].Price >= self.selltrig:
- if holdings >= 0:
- self.SetHoldings(self.syl, 1)
- else:
- self.Liquidate(self.syl)
- self.SetHoldings(self.syl, 1)
- elif self.Portfolio[self.syl].Price < self.selltrig: if holdings >= 0:
- self.Liquidate(self.syl)
- self.SetHoldings(self.syl, -1)
- else:
- self.SetHoldings(self.syl, -1)
-
Conclusion
-We tested this strategy on the S&P 500 ETF SPY from 2004 to 2017. During the backtesting period, SPY resulted in a Sharpe Ratio of 0.906 and the drawdown is 25%. As expected the strategy works well in a trending market. The strategy seemed to detect most of the market turning points and beat the market from 2009 to 2017.
-This is just a basic implementation and the parameters K1 and K2 are fixed. The strategy can be further extended to Futures and Forex markets. When K1 is smaller than k2, buy signals are prone to trigger and vice versa. To improve the model we can apply technical indicators to judge the trend of price and adjust the value of two parameters dynamically and apply risk control in the position sizing.
-
Algorithm
-Backtest result for ETF: SPY from 2004 to 2017
-
diff --git a/Strategy Tutorials/Tutorial06 Can Crude Oil Predict Equity Returns.html b/Strategy Tutorials/Tutorial06 Can Crude Oil Predict Equity Returns.html
deleted file mode 100644
index 49e0446..0000000
--- a/Strategy Tutorials/Tutorial06 Can Crude Oil Predict Equity Returns.html
+++ /dev/null
@@ -1,94 +0,0 @@
-
Abstract
-In this tutorial we use regression to predict the return from the stock market and compare it to the short-term U.S. T-bill rate. It is based on the paper?"Striking Oil: Another Puzzle?". [ref]Gerben, Driesprong (2007). Striking Oil: Another Puzzle? page 1, Online Copy[/ref] by?by Gerben, Ben and Benjamin (2007).
-
-If the predicted return is larger than the risk-free rate, the portfolio is fully invested in stock; if the predicted return is lower than the risk-free rate, the portfolio is invested in short-term U.S T-bills. The backtesting period starts in 1980 and is divided into an in-sample period where regression analysis is made and an out?of sample period where the regression result is embedded "statically" into the strategy.
-
-In our implementation of the strategy we adapt the method of the original paper to make it more applicable to the current market. We have set our backtesting period to be from 2010 to 2017 and we refresh our regression analysis each month to form a rolling dynamic projection. This is because?empirical evidence shows?us the correlation between oil and stocks is not as strong as in the 1980's. We use?the price of S&P GSCI? Crude Oil Total Return Index ETNs to represent spot oil price, and import T-bill data from Quandl by defining a custom class.?We use the "Schedule" API to trigger an event every month automatically?and the "History" function to retrieve data for regression analysis.
-
-Our analysis shows this strategy under performs the market in recent years. In the 9 year analysis period the algorithm was mostly long the S&P500 index and only 9 trades were performed as the markets were strongly bullish. The trades could potentially simply be due to the weakening of the relationship between stocks and oil.
-
Background
-We assume the predicted return of the stock is proportional to the return of oil. This can be represented by the regression equation:
-
-\[r^{stock}_t=a_0+a_1r^{oil}_{t-1}+e_t\]
-
-with
-
-\[e_t=r^{stock}_t-E_{t-1}[r^{stock}_t]\].
-
-The independent variable is the return of the oil and the dependent variable is the return of the stock. We use the monthly returns over a regression period of 2 years, giving us 22 observations to regress.?Every month regression analysis is conducted, and we use the estimated coefficient from the regression to compute the expected stock return with the given return of oil.
-
Method
-The algorithm implementation consists of mainly three parts: Defining the custom imported data, initialization of the strategy parameters, and monthly re-balancing of the portfolio.
-
Step 1: Defining Custom Imported Data
-We import T-Bill data from Quandl - a marketplace for financial, economic and alternative data. This requires defining a small class that tells QuantConnect how to interpret?the Quandl data.
-
class TBill(PythonData):
- def GetSource(self, config, date, isLiveMode):
- return SubscriptionDataSource("https://www.quandl.com/api/v3/datasets/USTREASURY/BILLRATES.csv?api_key=XXXXXXXXX&order=asc", SubscriptionTransportMedium.RemoteFile)
- def Reader(self, config, line, date, isLiveMode):
- tbill = TBill()
- tbill.Symbol = config.Symbol
- # Example Line Format:
- # Date 4 Wk Bank Discount Rate
- # 2017-06-01 0.8
- if not (line.strip() and line[0].isdigit()): return None
- try:
- data = line.split(',')
- value = float(data[1])*0.01
- value = decimal.Decimal(value)
- if value == 0: return None
- tbill.Time = datetime.strptime(data[0], "%Y-%m-%d")
- tbill.Value = value
- tbill["Close"] = float(value)
- return tbill;
- except ValueError:
- return None
-
-We first provide the source of the data as a URL to Quandl's API in the GetSource method. We need to make sure the data is?organized in ascending order which is done with the?"order=asc" parameter.?You need to substitute the API key in the URL for your personal Quandl API token.
-
-The Reader method parses a line of the data file. When using custom data you need to minimally set?the Time property?and Value property. In this example we find the value property from the headings in the spreadsheet is the second column and we reference it with data[1]. We set the Close property to the same value.
-
-In our "Initialize" function we use the following commands to add the custom data into our portfolio.
-
-In our?"Initialize" function we set the cash amount, start-end date as well as other parameters that are specific to this strategy.?We set two parameters for the regression analysis period:
-
self.regPeriod = 24
-self.daysInMonth = 21
-
-The variable "regPeriod" indicates how many months we are going to take into consideration in our regression analysis. We assume 21 days per month and request a historical period of approximately 2 years. We jump back in steps of 21 days and assume it is roughly 1 month of return.
-
-We need to set up "Schedule" function in "Initialize" so as to trigger the monthly re-balancing function every month.
-
-Every month we reconstruct the regression analysis to determine whether to be 100% long stocks or T-Bill contracts. We perform this re-balancing in the MonthlyReg function at the start of each month.?We use the History function to retrieve historical data for oil and stocks?and then divide the T-Bill rate by 12 to make it comparable to the monthly expected return of stocks.
-
oilHist = self.History(self.oil, self.regPeriod*self.daysInMonth, Resolution.Daily)
-spyHist = self.History(self.spy, self.regPeriod*self.daysInMonth, Resolution.Daily)
-oilSeries = [float(x.Close) for x in oilHist][self.daysInMonth-1:self.regPeriod*self.daysInMonth:self.daysInMonth]
-spySeries = [float(x.Close) for x in spyHist][self.daysInMonth-1:self.regPeriod*self.daysInMonth:self.daysInMonth]
-rf = float(self.Securities[self.tbill].Price)/12.0
-
-Then we make an OLS regression by using "numpy" to make the prediction on next month's stock return.
-
-Finally, we compare the expected return of stocks with risk-free rate. If the former is larger than the latter, we invest fully in stocks; otherwise we liquidate our holdings. Because we cannot purchase T-Bill contracts the performance is likely slightly underestimated.
-
if yPred > rf:
- self.SetHoldings(self.spy, 1)
-else:
- self.Liquidate(self.spy)
-
Conclusion
-We backtested this strategy over the period beginning in 2010 and ending in 2017. It has a sharpe ratio of 0.72 beating the benchmark's 0.6 over a similar period.
-
-Although the annual return closely matches that of the paper,?it is largely a coincidence of the strong bull market in recent years.?If we look at the monthly regression results, we could find that in most cases, the p-value is not small enough to reject the null hypothesis that there is no correlation between oil and stocks. So the investment decisions based on the insignificant statistical results are almost meaningless. The performance of this strategy cannot effectively beat the benchmark, mostly?due to?the weakened correlation between oil and stocks.
-
-Further research and backtesting could be conducted on assets other than oil that have a stronger relationship with stocks.
-
Algorithm
-Strategy code, as well as backtesting result, is attached below. We also put other choices of implementation in the comments.
-
-
\ No newline at end of file
diff --git a/Strategy Tutorials/Tutorial07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach.html b/Strategy Tutorials/Tutorial07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach.html
deleted file mode 100644
index 35884ce..0000000
--- a/Strategy Tutorials/Tutorial07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach.html
+++ /dev/null
@@ -1,328 +0,0 @@
-
Abstract
-In this tutorial we implement a high frequency and dynamic pairs trading strategy based on market-neutral statistical arbitrage strategy using a two-stage correlation and cointegration approach. This strategy is based on George J. Miao's work.[ref]George J. Miao High Frequency and Dynamic Pairs Trading Based on Statistical Arbitrage Using a Two-Stage Correlation and Cointegration Approach Online Copy[/ref]We applied this trading strategy to the U.S. bank sector stocks, backtested this strategy with 10-minute stock data from 2012 to 2013. Our trading strategy yields a compounding annual return up to 29.4% and a 0.968 sharpe ratio.
-
-This strategy is especially profitable when the market is performing poorly. The profit is resulted from mispricing, and mispricings are likely to happen when the market goes down or volatility increases.
-
-To explore this strategy further, we design this strategy to be flexible. We can change the data resolution into 5 minutes, 10 minutes or even 30 minutes by simply changing a parameter. It's also essential to choose optimized entering, closing and stop loss threshold. Everyone can has his/her own version of this strategy.
-
Introduction
-High Frequency Trading(HFT) is a type of quantitative trading characterized by short holding period and the use of sophisticated computer method to trade securities rapidly. It aims to capture small profit on every short-term trade.(Cartea & Penalva, 2012[ref]Cartea & Penalva, 2012 Where is the value in high frequency trading? Online Copy[/ref]).
-
-
-
-
-Statistical arbitrage is a situation where there is a statistical mispricing of one or more assets based on the expected values of these assets. When a profit situation takes place from pricing inefficiencies between securities, traders can identify the statistical arbitrage situation through mathematical models. Statistical arbitrage depends heavily on the ability of market prices to return to a historical or predicted mean. The Law of One Price(LOP) lays the foundation for this assumption. LOP states that two stocks with the same payoff in every state of nature must have the same current value (Gatev, Goetzmann, & Rouwenhorst, 2006[ref]Gatev, Goetzmann, & Rouwenhorst, 2006 Pairs trading: Performance of a relative-value arbitrage rule. The Review of Financial Studies, 19(3), 797–827. Online Copy[/ref]) Thus, two stock prices spread between close substitute assets should have a stable, long-term equilibrium price over time.
-
-
-
Data Description
-In order to have more pairs with high correlation, we select stocks in a specific industry. Economically, we prefer traditional sectors because the companies in these sector are more likely to be close substitutes. If we selected N stocks, the number of pairs can be calculated by \(\textrm{C}_{n}^{2} = \frac{n*(n-1)}{2}\). In the demonstrated strategy we used 80 stocks, so we have 3160 pairs in total. We used minute data and aggregate them into lower resolution, thus 1 minute is the highest resolution for this strategy.
-
Correlation Approach
-Correlations measure the relationship between two stocks that have price trends. They tend to move together, and thus are correlated. Correlation filter is the first step to screen the candidate pairs.
-
-Consider two stocks A and B, a correlation coefficient between the stocks was a statistic that provide a measure of how the two stocks A and B were associated. The correlation coefficient \(\rho\) of stock A and stock B was obtained by
-
-\[\rho = \frac{\sum_{i}^{N}(A_i - \bar{A})(B_i - \bar{B}))}{[\sum_{i}^{N}(A - \bar{A})^2\sum_{i}^{N}(B_i - \bar{B})^2]^\frac{1}{2}}}\]
-
-Where \(\bar{A}\) and \(\bar{B}\) are the mean prices of stock A and stock B respectively, N denoted a trading data range. \(\rho\) is in the range of [-1,1]. The more positive \(\rho\) is, the more positive the association of stock A and stock B is.
-
-However, the pairs trading based on a correlation approach alone would have a disadvantage of instabilities over time. Correlation coefficients do not necessarily imply mean-reversion between the prices of the two stock pairs. In order to overcome the above issue, a cointegration approach was further used as the second-step of the selection process for the pairs.
-
Cointegration Approach
-The Cointegration concept, an innovative mathematical model in economics developed by Nobel laureates Engle and Granger[ref]Engle and Granger Co-integration and error correction: Representation, estimation, and testing. Econometrica, 55(2), 251–276. Online Copy[/ref]Cointegration states that, in some instances, despite two given non-stationary time series, a specific linear combination of the two time series is actually stationary. In other word, the two time series move together in a lockstep pattern.
-
-The definition of cointegration is the following: assume that \(x_t\) and \(y_t\) are two time series that were non-stationary. If there exists a parameter \(\gamma\) such that the following equation:
-
-\[z_t = y_t - \gamma x_t\]
-
-was a stationary process, then \(x_t\) and \(y_t\) would be cointegrated. This process is a powerful tool for investigating common asset trends in multivariate time series.
-
-In our case, Let \(p_t^A\) and \(p_t^B\) be the prices of two stocks A and B respectively. If it is assumed that {\({p_t^A, p_t^B}\)} is individually non-stationary, there exists the parameter \(\gamma\) such that the following equation was a stationary process
-
-\[P_t^A - \gamma P_t^B = \mu + \epsilon_t\]
-
-where \(\mu\) is a mean of the cointegration model. \(\epsilon_t\) is a stationary, mean-revering process and was referred to as a cointegration residual. The parameter \(\gamma\) is known as a cointegration coefficient. The equation above represents a model of cointegrated pair for stocks A and B.
-
-It's essential to understand how the conitegration residual together with the cointegration coefficient determines our trading direction. If \(\epsilon\) is positive, in a given confidence interval, this is a signal that stock A is relatively overpriced and stock B is relatively underpriced, and we are going to long B and short A; If If \(\epsilon\) is negative, we are going to long A and short B.
-
Cointegration Verification(optional reading part)
-
-
-
-
-In the Engle-Granger method(Engle & Granger, 1987), we first set up a cointegration regression between stock A and stock B as stated in the equation above, and then estimate the regression parameters \(\mu\) and \(\gamma\) using an ordinary least squares(OLS). Subsequently, we tested the regression residual \(epsilon_t\) to determine whether or not it was stationary.
-
-The most popular stationary test in the area of cointegration, the Augmented Dickey Fuller (ADF) test, was used on the regression residual \(\epsilon\) to determine whether it had a unit root.
-
-
-
-
-Testing for the presence of the unit root in the regression residual using the ADF test was given by
-
-\[\Delta Z_t = \alpha + \beta t + \gamma Z_{t-1} + \sum_{i = 1}^{p -1}\delta_i \DeltaZ_{t-i} + \mu_t\]
-
-where \(\alpha\) is a constant, \(\beta\) is the coefficient on a time trend, p is the lag of order of the autoregressive process, \(\mu_t\) is an error term and serially uncorrelated.
-
-The number of lag order p in the equation is usually unknown and therefore had to be estimated. To determine the number of lag p, the information criteria for lag order selection was used. Here we choose Bayesian Information Criterion(BIC)
-
-\[BIC = (T-p)\ln\frac{T\hat{\sigma}_p^2}{T-p} + T[1+ln(\sqrt{2\pi})] + p\ln[\frac{\sum_{t=1}^{T}(\Delta Z_t)^2 -T\hat{\sigma}_p^2}{p}]\]
-
-Where T is the sample size.
-
-The unit root test for the regression residual \(\epsilon\) using the ADF test was then carried out under the null hypothesis \(H_0 : \gamma = 0\) versus the alternative hypothesis \(H_1 : \gamma < 0\). A statistical value of the ADF test was obtained by
-
-\[ADF test = \frac{\hat{\gamma }}{SE(\hat{\gamma })}\]
-
-The test result in the equation above is compared with the critical value of the ADF test. If the test result is less than the critical value, then the null hypothesis is rejected. This means the regression residual \(\epsilon\) is stationary. Thus, the two stock prices {\({p_t^A, p_t^B}\)} are cointegrated.
-
Pairs Trading Strategy
-The pairs trading strategy uses trading signals based on the regression residual \(\epsilon\) and were modeled as a mean-reverting process.
-
-In order to select potential stocks for pairs trading, the two-stage correlation and cointegration approach was used. The first step is to identify potential stock pairs from the same sector, where the stock pairs are selected with correlation coefficient of at least 0.9 using the correlation approach. The second step is to check the the cointegration of the pairs passed the correlation test. If the test value of cointegration is equal or less than -3.34, which is the critical value at a 95% confidence lever, the null hypothesis \(H_0 : \gamma = 0\) is rejected, thus the residual \(\epsilon\) is stationary, and the pair passed the cointegration test. The third step is to rank all of the stock pairs that passed the two-stage test according to their cointegration test values. The smaller the cointegration test value is, the higher rank the stock pair is assigned to. Financial selection of the stock pairs from the top rank is used for pairs trading.
-
-The final step of the strategy is to define trading rules. To open a pairs trading, the regression residual \(\epsilon_t\) must cross over and down the positive \(\sigma\) standard deviation above the mean or cross down and over the negative \(\sigma\) standard deviation below the mean. If the residual is positive, we short stock B and long stock A; if the residual is negative, we short Stock A and long Stock B. When the regression residual (\epsilon_t\) returned to a certain level, the pairs trading is closed. Further more, in order to prevent the loss of too much on a single pairs trading, a stop-loss is used to close the pairs when the residual hit \(4\epsilon\) positive or negative standard deviation.
-
-In the training period, each of the training data contained a 3-month period, which is a dynamic rolling window size. Immediately after the training period, we begin our one-month trading period, and the dynamic rolling window automatically shift ahead to record the new prices of the stocks in each pair. After the first trading period, we use the updated stock prices to select our pairs for trading again, and begin another trading period.
-
Parameter Adjustment
-The performance of the strategy is sensitive to the parameters. There are mainly four parameter to adjust: Opening Threshold, Closing Threshold, Stop-loss Threshold and data resolution.
-
-Opening threshold represents by how many times the residual \(\epsilon\) exceed the standard deviation, which is calculated by \(\frac{\epsilon - \bar{\epsilon}}{\sigma}\). By default we set it to 2.32 and -2.32, which is the critical value for 99% confidence interval if we assume the residual follows normal distribution.
-
-Closing threshold is calculated in the same way as opening threshold, we set it to 0.5 by default to close early to prevent further divergence.
-
-Stop-loss Threshold is set to 4.5. This depends on the level of mispricing we can bear. The higher degree our tolerance to risk is, the higher we can set this parameter. However, if we set this number too low, we may have too many pairs closed before reversion to stop loss.
-
-
-
-
Method
-In this trading strategy we would define a class named 'pairs'. We manage pairs instead of stocks directly to make it's more convenient for us to calculate correlation and cointegration, update stock prices in the pair and trade on the selected pairs.
-
Step 1: Pairs Class Definition
-The pairs is made up of two stocks, stock A and stock B. This class has several properties. The basic properties include symbols of stock A and stock B, the pandas DataFrame that contains time and prices of the two stocks, the current error, the error of the last datapoint, and the lists to record stock prices for update purpose. Instead of updating the DataFrame every 5 minutes, we record the prices in lists to update the DataFrame monthly. This would speed up the algorithm at least 10 times because manipulating DataFrame is very time consuming.
-The cor_update method is used every month to update the correlation between the two stocks in this pair. The cointegration_test method is also used monthly to do OLS regression, conduct ADF test, and calculate the mean and standard deviation of the residual. The method also assign these calculated values as properties to the pair object.
-
class pairs(object):
- def __init__(self, a, b):
- self.a = a
- self.b = b
- self.name = str(a) + ':' + str(b)
- self.df = pd.concat([a.df,b.df],axis = 1).dropna()
- # The number of bars in the rolling window would be determined by the resolution, so we get this
- information from the shape of the DataFrame here.
- self.num_bar = self.df.shape[0]
- self.cor = self.df.corr().ix[0][1]
- # Set the initial signals to be 0
- self.error = 0
- self.last_error = 0
- self.a_price = []
- self.a_date = []
- self.b_price = []
- self.b_date = []
-
- def cor_update(self):
- self.cor = self.df.corr().ix[0][1]
-
- def cointegration_test(self):
- self.model = sm.ols(formula = '%s ~ %s'%(str(self.a),str(self.b)), data = self.df).fit()
- # This line conduct ADF test on the residual. ts.adfuller() returns a tuple and the first element in
- the tuple is the test value.
- self.adf = ts.adfuller(self.model.resid,autolag = 'BIC')[0]
- self.mean_error = np.mean(self.model.resid)
- self.sd = np.std(self.model.resid)
-
- def price_record(self,data_a,data_b):
- self.a_price.append(float(data_a.Close))
- self.a_date.append(data_a.EndTime)
- self.b_price.append(float(data_b.Close))
- self.b_date.append(data_b.EndTime)
-
- def df_update(self):
- new_df = pd.DataFrame({str(self.a):self.a_price,str(self.b):self.b_price},index =
- [self.a_date]).dropna()
- self.df = pd.concat([self.df,new_df])
- self.df = self.df.tail(self.num_bar)
- # after updating the DataFrame, we empty the lists for the incoming data
- for list in [self.a_price,self.a_date,self.b_price,self.b_date]:
- list = []
-
-
Step 2: Generate and Clean Pairs
-The function generate_pairs generates pairs using the stock symbols. self.pair_threshold and self.pair_num are pre-determined to control the number of candidate pairs. The pairs in self.pair_list would be kept and updated throughout our backtesting period. we set self.pair_threshold to 0.88 and self.pair_num to 120 to limit the number of pairs in the list. If we put too many pairs in the list, the backtesting would be too time consuming.
-The function pair_clean is called after the two-stage screen. If the first pair contains stock A and stock B, and the second pair contains stock B and stock C, we would remove the second pair because the overlapped signal would disturb the balance of our portfolio.
-
def generate_pairs(self):
- for i in range(len(self.symbols)):
- for j in range(i+1,len(self.symbols)):
- self.pair_list.append(pairs(self.symbols[i],self.symbols[j]))
-
- self.pair_list = [x for x in self.pair_list if x.cor > self.pair_threshold]
-
- self.pair_list.sort(key = lambda x: x.cor, reverse = True)
-
- if len(self.pair_list) > self.pair_num:
- self.pair_list = self.pair_list[:self.pair_num]
-
-def pair_clean(self,list):
- l = []
- l.append(list[0])
- for i in list:
- symbols = [x.a for x in l] + [x.b for x in l]
- if i.a not in symbols and i.b not in symbols:
- l.append(i)
- else:
- pass
- return l
-
-
Step 3: Warming up Period
-This part is under the OnData step. We set self.num_bar equals to the number of TradeBar in three months, which is determined by the resolution. During this period we fill the stock prices in lists, and assign each stock's price list to the symbol as a property. We would also remove the symbol from the symbol list if it has no data.
-
if len(self.symbols[0].prices) < self.num_bar:
- for symbol in self.symbols:
- if data.ContainsKey(i) is True:
- symbol.prices.append(float(data[symbol].Close))
- symbol.dates.append(data[symbol].EndTime)
- else:
- self.Log('%s is missing'%str(symbol))
- self.symbols.remove(symbol)
- self.data_count = 0
- return
-
Step 4: Pairs Selection
-This process is also under the OnData step. This step would generate pairs if it is the first trading period of this algorithm. If it's not, it will update the DataFrame and correlation coefficient of each pair in self.pair_list. After that the pairs have a correlation coefficient higher than 0.9 would be selected into self.selected_pair. Then all the pairs in self.selected_pair would be tested on their cointegration, and the pairs with a test value less than -3.34 would be selected to the final list. This step will also limit the number of stocks in the final list, by default we set self.selected_num to 10. self.count is a flag to count the number of datapoint we received. Once it reach 1-month amount, that means one trading period is passed and it would be set to 0.
-
if self.count == 0 and len(self.symbols[0].prices) == self.num_bar:
- if self.generate_count == 0:
- for symbol in self.symbols:
- symbol.df = pd.DataFrame(symbol.prices, index = symbol.dates, columns = ['%s'%str(symbol)])
-
- self.generate_pairs()
- self.generate_count +=1
- self.Log('pair list length:'+str(len(self.pair_list)))
-
- for pair in self.pair_list:
- pair.cor_update()
- # Update the DataFrame and correlation selection
- if len(self.pair_list[0].a_price) != 0:
- for pair in self.pair_list:
- pair.df_update()
- pair.cor_update()
-
- self.selected_pair = [x for x in self.pair_list if x.cor > 0.9]
- # Cointegration test
- for pair in self.selected_pair:
- pair.cointegration_test()
-
- self.selected_pair = [x for x in self.selected_pair if x.adf < self.BIC]
- self.selected_pair.sort(key = lambda x: x.adf)
- # If no pair passed the two-stage test, return.
- if len(self.selected_pair) == 0:
- self.Log('no selected pair')
- self.count += 1
- return
- # clean the pair to avoid overlapping stocks.
- self.selected_pair = self.pair_clean(self.selected_pair)
- # assign a property to the selected pair, this is a signal that would be used for trading.
- for pair in self.selected_pair:
- pair.touch = 0
- self.Log(str(pair.adf) + pair.name)
- # limit the number of selected pairs.
- if len(self.selected_pair) > self.selected_num:
- self.selected_pair = self.selected_pair[:self.selected_num]
-
- self.count +=1
- self.data_count = 0
- return
-
-
Step 5: Trade Period
-It would be too long to read if we paste all the code in trading period together. Thus we would separate the code into three part: updating pairs, opening pairs trading and closing pairs trading. But all those lines are under OnData step and are under the condition: if self.count != 0 and self.count < self.one_month. This means it's in the trading period.
-
Updating Pairs
-This step would update the stock prices in each pair. It would also update the signal called 'last_error' and immediately after this the pairs would receive new signals.
-
num_select = len(self.selected_pair)
-for pair in self.pair_list:
- if data.ContainsKey(pair.a) is True and data.ContainsKey(pair.b) is True:
- i.price_record(data[i.a],data[i.b])
- else:
- self.Log('%s has no data'%str(pair.name))
- self.pair_list.remove(pair)
-
-for pair in self.selected_pair:
- pair.last_error = pair.error
-
-for pair in self.trading_pairs:
- pair.last_error = pair.error
-
Opening Pairs Trading
-This is most complex part. For each pair in self.selected_pair, we receive the current prices of the stocks, and then use the cointegration model to calculate the residual \(\epsilon\), which is assigned to the pair as a property named 'error'. self.trading.pairs is a list to store the trading pairs. Once a pairs trading is open, this pair would be add to the list, and it would be removed when the trading is closed. The property 'touch' is signal. If the residual \(\epsilon\) cross over the positive threshold standard deviation(we set \(\ 2.23*sigma\) here), the signal would become +1; while if it cross down the negative threshold deviation(\(\ -2.23*sigma\), the signal would become -1. For those pairs with +1 signal, if the error cross down positive threshold, there is a signal to open a trade. We long stock B and short stock A. For those pairs with -1 signal, if the error cross over negative threshold, we long Stock A and short stock B.
-When we opening a trade, we need to record the current model, current mean and standard deviation of the residual. This is necessary because if we enter a new trading period and the trade has not been closed yet, the cointegration model, mean and standard deviation of the pairs would be changed. We need to use the original thresholds to close the trades. while adding the pairs into self.trading_pairs, we also need to set the signal 'touch' to 0 for further use.
-
for i in self.selected_pair:
- price_a = float(data[i.a].Close)
- price_b = float(data[i.b].Close)
- i.error = price_a - (i.model.params[0] + i.model.params[1]*price_b)
- if (self.Portfolio[i.a].Quantity == 0 and self.Portfolio[i.b].Quantity == 0) and i not in
- self.trading_pairs:
- if i.touch == 0:
- if i.error < i.mean_error - self.open_size*i.sd and i.last_error > i.mean_error -
- self.open_size*i.sd:
- i.touch += -1
- elif i.error > i.mean_error + self.open_size*i.sd and i.last_error < i.mean_error + self.open_size*i.sd: i.touch += 1 else: pass elif i.touch == -1: if i.error > i.mean_error - self.open_size*i.sd and i.last_error < i.mean_error -
- self.open_size*i.sd:
- self.Log('long %s and short %s'%(str(i.a),str(i.b)))
- i.record_model = i.model
- i.record_mean_error = i.mean_error
- i.record_sd = i.sd
- self.trading_pairs.append(i)
- self.SetHoldings(i.a, 5.0/(len(self.selected_pair)))
- self.SetHoldings(i.b, -5.0/(len(self.selected_pair)))
- i.touch = 0
- elif i.touch == 1:
- if i.error < i.mean_error + self.open_size*i.sd and i.last_error > i.mean_error +
- self.open_size*i.sd:
- self.Log('long %s and short %s'%(str(i.b),str(i.a)))
- i.record_model = i.model
- i.record_mean_error = i.mean_error
- i.record_sd = i.sd
- self.trading_pairs.append(i)
- self.SetHoldings(i.b, 5.0/(len(self.selected_pair)))
- self.SetHoldings(i.a, -5.0/(len(self.selected_pair)))
- i.touch = 0
- else:
- pass
- else:
- pass
-
-
Closing Pairs Trading
-This part controls pairs trading exit. It works similar to the opening part. It uses the recorded original model and thresholds to determine whether or not we should close the position. If the residual \(\epsilon\) reaches our closing threshold, we liquidate stock A and stock B to close. If the residual continue to deviate from the mean and goes too far, we would also close the position to stop loss. When we close a pairs trading, we also remove the pairs from self.trading_pairs.
-
for i in self.trading_pairs:
- price_a = float(data[i.a].Close)
- price_b = float(data[i.b].Close)
- i.error = price_a - (i.record_model.params[0] + i.record_model.params[1]*price_b)
- if ((i.error < i.record_mean_error + self.close_size*i.record_sd and i.last_error >i.record_mean_error + self.close_size*i.record_sd) or (i.error > i.record_mean_error -
- self.close_size*i.record_sd and i.last_error i.record_mean_error +
- self.stop_loss*i.record_sd:
- self.Log('close %s to stop loss'%str(i.name))
- self.Liquidate(i.a)
- self.Liquidate(i.b)
- self.trading_pairs.remove(i)
- else:
- pass
-
Result
-We used 10-minute resolution data to backtest the strategy from Jan 2013 to Dec 2016. To demonstrate the in sample training results, we randomly selected a training period that from 2016-09-07 to 2013-11-30.
-
Training Result
-The following table demonstrates the top 10 selected pairs in the training period mentioned above. We can see that the pairs with the highest correlation coefficient doesn't not necessarily has the best ADF test value. We made the rank by ADF test value because it's more robust.
-
-
-
-The upper part of the following chart plots the stock prices of pair ING vs TCB. The lower part plots by how many times standard deviation the residual deviate from its mean. There are 5 trading opportunities if we set the opening threshold to be 2.32.
-
-
-
-The following chart is the density plot of the residual error. From the shape we can see the error is approximately normal distributed.
-
-
-
-Backtesting Result
-
-The strategy is considered to be market neutral strategy because it a long/short strategy betting on price convergence. Out backtested beta is -0.112, which is within our expectation.
-
-Theoretically, the higher resolution we use, the higher win rate is because on one hand the higher resolution would increase the number of datapoint in our training period, which would make it's harder to past the two-stage test; on the other hand the higher resolution data would let us capture minor profit more accurately. However, there is a trade off between performance and backtesting time. The higher resolution will lead backtesting time to increase drastically.
-
-The number of stocks in the initialize step would also affect our performance. Theoretically, the more stock we have, we better pairs we are likely to pick. But too many stocks would also be time consuming.
-
-what's worth mentioning is that the optimized parameters are different for each sector. It depends on the features of the price patterns in the specific industry. Plotting the pairs prices and the residual to observe is good option to adjust the thresholds.
-
Algorithm
-
-
-
-
-
-
-
-
-
diff --git a/Strategy Tutorials/Tutorial08 The Momentum Strategy Based on the Low Frequency Compoment of Forex Market.html b/Strategy Tutorials/Tutorial08 The Momentum Strategy Based on the Low Frequency Compoment of Forex Market.html
deleted file mode 100644
index 3f08ca8..0000000
--- a/Strategy Tutorials/Tutorial08 The Momentum Strategy Based on the Low Frequency Compoment of Forex Market.html
+++ /dev/null
@@ -1,182 +0,0 @@
-
Abstract
-Trend estimation is a family of methods to detect and predict tendencies and trends in price series just using the history information. Moving average is a commonly used trend following trading tool. Lots of momentum trading strategies in the Forex market are based on the moving average rule, in which signals are triggered if the close is above or below the moving average. But MA has the time lag, therefore can't be used to predict the turning points of market price changes.
-
-In this tutorial, I developed a trend following strategy which is proposed in the paper Harris R D F, Yilmaz F(2009) [ref]Harris R D F, Yilmaz F. A momentum trading strategy based on the low-frequency component of the exchange rate[J]. Journal of Banking & Finance, 2009, 33(9): 1575-1585. online copy[/ref].
-
-This strategy exploits short-term momentum in the non-linear trend component of the exchange rate which is generated by Hodrick-Prescott Filter (rather than the exchange rate itself) and uses the MA(1, 2) rule to measure this momentum. The strategy was tested on seven kinds of exchange rates and the results shows less robustness and the performance is sensitive to the change of model parameters.
-
-
Introduction
-Hodrick-Prescott Filter decomposes a time series\(y_t\) into two components: the cyclical part(which is short-term) and the trend part(which is long term).
-
-\[y_t=\x _t +c_t\]
-
-The filter is the solution to the following optimization problem for \(x_t\)
-
-\[\min _{x_t}\left[\sum_{t=1}^n(y_t-x_t)^2+\lambda\sum_{t=2}^{n-1}[(x_{t+1}-x_t)-(x_{t}-x_{t-1})^2] \right]\]
-
-[ref]Dao T L. Momentum Strategies with L1 Filter[J]. Browser Download This Paper, 2014. online copy[/ref]The second term is the discrete derivative of the trend xt which characterizes the smoothness of the curve. We can rewrite the above formula in vector form:
-
-\[\min_{\bf x}{\parallel {\bf{y}}-{\bf{x}}\parallel}_2^2+\lambda {\parallel D\bf x\parallel}_2^2\]
-
-where \({\bf y}=(y_1,y_2,...,y_n),{\bf x}=(x_1,x_2,...,x_n)\in {\rm I\!R}^n\),\(\parallel\cdot\parallel_2\) is the Euclidean norm. D is the (n-2)*n matrix:
-
-\[
-
-\left[
-\begin{matrix}
-1 & -2 & 1 & \\
-& 1 & -2 & 1 \\
-& & & \ddots &\\
-& & & 1 & -2 & 1 \\
-& & & & 1 & -2 & 1 \\
-\end{matrix}
-\right]
-
-\]
-
-The solution of this optimization problem is given by solving the following linear system:
-
-\[y=(I+2\lambda D^TD)^{-1}x\]
-
def hpfilter(self,X, lamb=1600):
- X = np.asarray(X, float)
- if X.ndim > 1:
- X = X.squeeze()
- nobs = len(X)
- I = sparse.eye(nobs,nobs)
- offsets = np.array([0,1,2])
- data = np.repeat([[1.],[-2.],[1.]], nobs, axis=1)
- K = sparse.dia_matrix((data, offsets), shape=(nobs-2,nobs))
- use_umfpack = True
- self.trend = spsolve(I+lamb*K.T.dot(K), X,use_umfpack=use_umfpack)
- cycle = X - self.trend
-
-
-
Method
-
-This low-frequency momentum trading strategies are applied to daily data on seven kinds of exchange rates. We use five years history data before January 2011 for initial estimation of the trend model. Daily exchange rates for the period January 2011 to May 2017 is used for out of sample trading.
-
def Initialize(self):
- self.SetStartDate(2011,1,1)
- self.SetEndDate(2017,5,30)
- self.SetCash(100000)
- self.numdays = 360*5 # set the length of training period
- self.syl = self.AddSecurity(SecurityType.Forex, "EURUSD", Resolution.Daily).Symbol
- self.n,self.m = 2, 1
- self.trend = None
- self.SetBenchmark(self.syl)
- self.MA_rules = None
- history = self.History(self.numdays,Resolution.Daily)
- self.close = [slice[self.syl].Close for slice in history]
-
-
Step 1: Calibrating the Filter Smoothing Parameter λ
-The Ravn–Uhlig rule is commonly used to set the smoothing parameter λ in HP filter and must be greater than 0. It is adjusted by the changing frequency of observations and must be greater than 0. Hodrick and Prescott (1997) recommended setting λ to 1,600 for quarterly data. The Ravn–Uhlig rule sets \(\lambda = 1600p^4\) , where p is the number of periods per quarter. As for our daily exchange rate data, we should have set λ to be \(\1600\times (30 \times 4)^4\). But when we use this value as the λ, the curve is almost a straight line since the trend becomes smoother as λ → ∞. In order to avoid excessive smoothing, we gradually decrease the λ and draw the smoothing curve. Below is the chart of EURUSD daily price from the year 2010 to 2011. t100 denotes the trend component after filter with the parameter λ=100.
-
-Out-of-sample EUR/USD Trend Estimation
-
-
-
-Trading Signals when λ=100
-
-
-The above charts are the in-sample trading signals after applying MA rules on the low-frequency component. The trend curve is more smooth with larger λ. Thus when we applied MA rules, a less smooth trend will trigger more trading opportunities.
-
Conclusion
-
-
-
-
Strategy Performance for different currencies in Forex
-
-
-
-
-
Currency
-
USDCAD
-
EURUSD
-
USDCHF
-
EURGBP
-
CADUSD
-
USDNOK
-
USDZAR
-
-
-
Sharp Ratio
-
0.361
-
0.375
-
0.131
-
0.337
-
0.052
-
0.054
-
0.195
-
-
-
Total Trades
-
14
-
11
-
12
-
11
-
6
-
16
-
9
-
-
-
Annual Return
-
3.128%
-
3.272%
-
1.162%
-
2.689%
-
0.043%
-
0.093%
-
2.201%
-
-
-
Max Drawdown
-
10.3%
-
8.3%
-
24.8%
-
17.6%
-
22.5%
-
30.3%
-
23%
-
-
-
-
-The table reports the strategy performance statistics during six and a half years backtesting period. From the table we can see, most of them have the higher maximum drawdown. The number of total trades is small because we applied MA rules on the smoothed trend component. As the author indicated in the paper, we still find that the performance of this strategy is very sensitive to the choice of lag parameters in MA rules and in a non-monotonic way.
-
-The strategy does not generate more stable profits in Forex market generally. That might because that the HP filter technique was designed to be viewed as a trend curve through the entire set of data. When we applied it in trading strategy, the entry of new data into the filter model can cause the trend line to change the trend through past data, makes it harder to identify the trend accurately.
-
-We also tried the kernel regression method in the paper. However, because the distribution parameter in the Python kernel regression package can not be adjusted. The appropriate trend component is not being extracted well from kernel regression. The smoothing effect of the regression is not good as expected. Thus here we choose not to move on to the trading part of kernel regression method.
-
Algorithm
-
-
diff --git a/Strategy Tutorials/Tutorial10 Short-Term Reversal Strategy in Stocks.html b/Strategy Tutorials/Tutorial10 Short-Term Reversal Strategy in Stocks.html
deleted file mode 100644
index 60ab3e3..0000000
--- a/Strategy Tutorials/Tutorial10 Short-Term Reversal Strategy in Stocks.html
+++ /dev/null
@@ -1,81 +0,0 @@
-
Abstract
-This strategy is called Short-Term Reversal Strategy which is discussed in detail in the paper written by Wilma de Groot, Joop Huij and Weili Zhou (2011) titled "Another look at trading costs and short-term reversal profits". [ref]Groot, Wilma (2011). Another look at trading costs and short-term reversal profit, page 1,? Online Copy[/ref] The standard reversal strategy takes the whole universe of stocks into consideration, while this paper limits the stock universe only to large cap stocks so that trading costs could be significantly reduced.
-
-One simple version of this strategy could be described like this: The investment universe consists of 100 biggest companies by market capitalization. We go long on the 10% stocks which have the?lowest performances in the last month while going short on the 10% stocks with the highest ones. The portfolio is rebalanced weekly.
-
-In the paper, however, strategies with different investment universes and different rebalancing frequencies are all backtested. The results show that, the larger the size of the investment universe, the larger the trading costs caused by extensively trading in small cap stocks which are less liquid; and trading costs become substantially lower when the rebalancing frequency is decreased from daily to weekly, but so do gross returns.
-
-In this tutorial, we only use 100 stocks with weekly rebalancing for illustration.
-
Method
-The strategy code mainly consists of three parts: Initialization, Warm Up, and Weekly Rebalancing.
-
Step 1:?Initialization
-In the Initialize function, we set up look-back period, beginning cash balance, the size of the investment universe, the number of traded stocks, etc. We use self._numOfWeeks to count?the number of weeks that have passed since the start date, and self._LastDay to indicate whether it is a new week. self._ifWarmUp is true when the self._numOfWeeks is 3, which means as long as next week's data come, we can make our investment decisions.??self._stocks is a list containing all the symbols of the 100 stocks that are taken into consideration. self._values is a dictionary with keys the stock symbols and values the lists containing the prices of stock each week since 4 weeks ago.
-
-Also, we need to use?CoarseSelectionFunction to select 100 qualified stocks from the total stock universe. Here, we sort the total stock universe by each stock's DollarVolume in decreasing order. Then, we select the first 100 stocks that have the largest DollarVolume among all the stocks in the universe.
-
def CoarseSelectionFunction(self, coarse):
- sortedByDollarVolume = sorted(coarse, key=lambda x: x.DollarVolume, reverse=True)
- top100 = sortedByDollarVolume[:self._numberOfSymbols]
- list = List[Symbol]()
- for x in top100:
- list.Add(x.Symbol)
- return list
-
-
Step 2:?Warm Up
-Before we are able to make our investment decisions, we must have at least 4 weeks' data to calculate the performance, i.e. the monthly return, of each stock. Hence, we need a warm up period as long as 3 weeks to accumulate price series, so that once the fourth week's data come we can calculate?the return of the whole month.
-
self._stocks = []
-self.uni_symbol = None
-symbols = self.UniverseManager.Keys
-for i in symbols:
- if str(i.Value) == "QC-UNIVERSE-COARSE-USA":
- self.uni_symbol = i
- for i in self.UniverseManager[self.uni_symbol].Members:
- self._stocks.append(i.Value.Symbol)
- self._values[i.Value.Symbol] = [self.Securities[i.Value.Symbol].Price]
-
-
-We get all the symbols of qualified stocks from UniverseManager and keep them in self._stocks which is a list. Then we create for each key in the dictionary self._values a list where its first week's price is stored. And every time new data come, we append the new price to the end of the list of each stock.
-
for stock in self._stocks:
- self._values[stock].append(self.Securities[stock].Price)
-
Step 3:?Weekly Rebalancing
-After the warm-up period, we calculate monthly returns every week and based on the returns, we make our investment decisions.
-
-Every week when new data come, we use them along with the data four weeks ago to calculate the monthly returns. At the same time, we remove the oldest data from our lists. This step is essential to prevent memory size exceeding the limit.
-
newArr = [(v,k) for k,v in returns.items()]
-newArr.sort()
-for ret, stock in newArr[self._numberOfTradings:-self._numberOfTradings]:
- self.SetHoldings(stock, 0)
-for ret, stock in newArr[0:self._numberOfTradings]:
- self.SetHoldings(stock, 0.5/self._numberOfTradings)
-for ret, stock in newArr[-self._numberOfTradings:]:
- self.SetHoldings(stock, -0.5/self._numberOfTradings)
-
-Finally, we sort the returns in increasing order. For the stocks whose monthly returns fall into the first 10% (performed badly in last month), we long them; For those fall into the last 10% (performed well in last month), we short them. Others (between 10% and 90%) will be set to 0.
-
Conclusion
-In the paper, the look-back period is from 1990 to 2009. However, we want to test whether the strategy is still profitable in the new time period. Hence we use different look-back periods instead.
-
-If we begin from 2005 and end in 2017, there will be a total return of 131.50%. Although to some extent the performance of this strategy is dependent on different market situations,?nevertheless, in either situation mentioned above, this strategy could significantly beat the S&P 500 benchmark.
-
-Further research and backtesting could be done on different look-back periods, rebalancing frequencies, investment universes, numbers of traded stocks, etc.
-
Algorithm
-
\ No newline at end of file
diff --git a/Strategy Tutorials/Tutorial11 Fundamental Factor Long:Short Strategy.html b/Strategy Tutorials/Tutorial11 Fundamental Factor Long:Short Strategy.html
deleted file mode 100644
index 53eabaf..0000000
--- a/Strategy Tutorials/Tutorial11 Fundamental Factor Long:Short Strategy.html
+++ /dev/null
@@ -1,111 +0,0 @@
-
Introduction
-In this tutorial we implemented a long/short equity strategy based on fundamental factors. The idea comes from AQR white book: A New Core Equity Paradigm[ref]A New Core Equity ParadigmOnline Copy[/ref]. The original version is a long only strategy. We developed it into a long/short version. The paper strategy used some fundamental data as measures of value, quality and momentum, and then ranked all the stocks in the universe according to the factors. The strategy only long the stocks ranking at the top, but our algorithm would at the same time short the stocks ranking at the bottom. This strategy consistently beats the market and has solid economic intuition.
-
-
Factors
-The paper strategy used three factors together to rank stocks: value, quality and momentum.
-
-Value: The most commonly used measure for value is P/B ratio(price-to-book value). Intuitively, the stocks with high P/B ratio are likely to be overpriced, and those stocks are labeled as growth stock. On the other hand, the stocks with low P/B value are considered to be value stocks. Following this logic, we use book value per share as a measure for value in our algorithm: the stocks with high book value per share rank high.
-
-Quality: Quality is a comprehensive factor. The paper used total profits over asset, gross margins, and free cash flow over assets. For simplicity, we used only operation margin as our quality factor. Here we assume that the companies with high operation margin are profitable, and their stocks are the quality ones.
-
-Momentum: The paper strategy is quarterly rebalanced, so it used recent one-year return, three-month and returns around earning events as measures for momentum. While our algorithm is monthly rebalanced, we simply use recent monthly return as our momentum factor.
-
-
Ranking
-Ranking is the core process for stock selection. We first rank all the stocks according to each factor, then assign weights to each factor to get the final rank.
-
-Specifically, in our algorithm we have 250 stocks in total. We rank them according to their book values per share, operation margins and one-month returns by descending order. For each stock, its index in each sorted list is its score on each factor. e.g. If stock A ranks 1st by value, 10th by quality and 30th by momentum, its scores on the value, quality and momentum are 1, 10 and 30 respectively.
-
-The last step is to calculate the final score of each stocks. We use the same weight as the paper does: 40% on value, 40% on quality and 20% on momentum. In this way, stock A's final score is 1*0.4 + 10*0.4 + 30*0.2 = 10.4. Finally, we can rank all the stocks by their scores by ascending order. It worth attention that the stock with the lowest score is the best and it ranks 1st, and the one with the highest score is the worst.
-
-
Implementation
-In this implementation, the FineSelectionFunction would be the core part because we have to rank the stocks in this process. We also need a ScheduledEvent handler to rebalance the portfolio every month. We would introduce the process step by step.
-
-
CoarseSelectionFunction
-This function is a filter for the whole asset universe(around 8000 stocks). We select the top 250 with highest dollar volume to ensure liquidity. We also filter out the stocks without fundamental information or with a too low price(less than $5).
-
-def CoarseSelectionFunction(self, coarse):
- # if the rebalance flag is not 1, return null list to save time.
- if self.reb != 1:
- return []
-
- # make universe selection once a month
- # drop stocks which have no fundamental data or have too low prices
- selected = [x for x in coarse if (x.HasFundamentalData)
- and (float(x.Price) > 5)]
-
- sortedByDollarVolume = sorted(selected, key=lambda x: x.DollarVolume, reverse=True)
- top = sortedByDollarVolume[:self.num_coarse]
- return [i.Symbol for i in top]
-
-
-
FineSelectionFunction
-Here is the core function. The process is that we make three sorted list to store the stocks, and then use a dictionary to store the score information. For the dictionary, the keys are Symbols and the values are their scores. Finally we sort the dictionary to get the final rank. we store the top 20 stocks to long in the list self.long and the bottom 20 stocks to short in the list self.short.
-
- def FineSelectionFunction(self, fine):
- # return null list if it's not time to rebalance
- if self.reb != 1:
- return []
-
- self.reb = 0
-
- # drop stocks which don't have the information we need.
- # you can try replacing those factor with your own factors here
-
- filtered_fine = [x for x in fine if x.OperationRatios.OperationMargin.Value
- and x.ValuationRatios.PriceChange1M
- and x.ValuationRatios.BookValuePerShare]
-
- self.Log('remained to select %d'%(len(filtered_fine)))
-
- # rank stocks by three factor.
- sortedByfactor1 = sorted(filtered_fine, key=lambda x: x.OperationRatios.OperationMargin.Value, reverse=True)
- sortedByfactor2 = sorted(filtered_fine, key=lambda x: x.ValuationRatios.PriceChange1M, reverse=True)
- sortedByfactor3 = sorted(filtered_fine, key=lambda x: x.ValuationRatios.BookValuePerShare, reverse=True)
-
- stock_dict = {}
-
- # assign a score to each stock, you can also change the rule of scoring here.
- for i,ele in enumerate(sortedByfactor1):
- rank1 = i
- rank2 = sortedByfactor2.index(ele)
- rank3 = sortedByfactor3.index(ele)
- score = sum([rank1*0.2,rank2*0.4,rank3*0.4])
- stock_dict[ele] = score
-
- # sort the stocks by their scores
- self.sorted_stock = sorted(stock_dict.items(), key=lambda d:d[1],reverse=False)
- sorted_symbol = [x[0] for x in self.sorted_stock]
-
- # sotre the top stocks into the long_list and the bottom ones into the short_list
- self.long = [x for x in sorted_symbol[:self.num_fine]]
- self.short = [x for x in sorted_symbol[-self.num_fine:]]
-
- topFine = self.long + self.short
- return [i.Symbol for i in topFine]
-
Rebalance
-Our portfolio is rebalanced monthly, so first of all we should write a ScheduledEvent handler in the Initialize function:
-
-def Initialize(self):
-# Use SPY as a benchmark for market open
- self.Schedule.On(self.DateRules.MonthStart(self.spy), self.TimeRules.AfterMarketOpen(self.spy,5), Action(self.rebalance))
-Our rebalanced method is straightforward: We first liquidate the stocks that are no longer in the long/short list, and then assign equal weight to the stocks we are going to long or short.
-def rebalance(self):
-# if this month the stock are not going to be long/short, liquidate it.
- long_short_list = self.long + self.short
- for i in self.Portfolio.Values:
- if (i.Invested) and (i.Symbol not in long_short_list):
- self.Liquidate(i.Symbol)
-
- # Assign each stock equally. Always hold 10% cash to avoid margin call
- for i in self.long:
- self.SetHoldings(i,0.9/self.num_fine)
-
- for i in self.short:
- self.SetHoldings(i,-0.9/self.num_fine)
-
-
Summary
-The paper strategy was backtest at a 60-year timespan. It's persistent, systematic and intuitive. Although our version is very different from the paper one, the logic and intuition behind are the same. It has a better performance than the paper strategy because we added short positions.
-For further development, we can try to rank a large number of stocks, and do some portfolio optimization instead of holding stocks equally.
-
-
The goal of this series is to introduce the common options strategies to those who already have basic knowledge of options markets and most importantly, we will teach users how to start your simple options trading algorithm on QuantConnect. These strategies will demonstrate a few of the ways in which options can be used to produce an interesting relationship between profit and stock price. We will primarily talk about the strategies like the Covered Call which involves a single option and the undelying stock, the spreads which involve either taking a position in two or more calls or puts, the conbinations like straddle or strangle which involve taking a position in both calls and puts on the same stocks. For each strategy, except for the description of strategy itself, we will demonstrate the QuantConnect algorithm implemented in Python.
-
-
-
-
-
-
-
-
-
-
8 Tutorials
-
-
-
-
-
10 Backtests
-
-
-
-
-
45 Code Snippets
-
-
-
-
-
-
-
-
What Will I Learn?
-
-
Common Options Strategies
-
Using Options API
-
Payoff Analysis
-
Risk Profile of Options Trading
-
-
-
-
-
-
-
-
-
-
1
-
-
Covered Call
-A brief introduction to Covered Call Strategy and the algorithm implemented in python.
- Read Tutorial
-
-
-
2
-
-
Bull Call Spread
-A brief introduction to Bull Call Spread strategy and the algorithm implemented in python.
- Read Tutorial
-
-
-
3
-
-
Long Straddle
-A brief introduction to Long Straddle strategy and the algorithm implemented in python.
- Read Tutorial
-
-
-
4
-
-
Long Strangle
-A brief introduction to Long Strangle strategy and the algorithm implemented in python.
- Read Tutorial
-
-
-
5
-
-
Butterfly Spread
-A brief introduction to Butterfly Spread strategy and the algorithm implemented in python.
- Read Tutorial
-
-
-
6
-
-
Iron Condor
-A brief introduction to Iron Condor strategy and the algorithm implemented in python.
- Read Tutorial
-
-
-
7
-
-
Iron Butterfly
-A brief introduction to Iron Butterfly strategy and the algorithm implemented in python.
- Read Tutorial
-
-
-
8
-
-
Protective Collar
-A brief introduction to Protective Collar strategy and the algorithm implemented in python.
- Read Tutorial
-A Covered Call is an options strategy that involves both underlying stock and an options contract. The trader buys (or already owns) a stock, then sells call options for the same amount of stock. The aim of the Covered Call is to gain profits from option premium by selling calls written on the stock you already owned. At any time for US options or at expiration for European options, if the stock moves below the strike price, you can keep the premium and still maintain the stock position. If the price moves above the strike, the options contract is exercised you will sell the stock at the strike price but still keep the premium. The risk of a Covered Call also comes from the long stock position, which could drop.
-
-The payoff is as follows:
-
import numpy as np
-import matplotlib.pyplot as plt
-%pylab inline
-price = np.arange(110,230,1) # the stock price at expiration date
-strike = 160 # the strike price
-premium = 7.5 # the option premium
-# the payoff of short call position
-payoff_short_call = [min(premium, -(i - strike-premium)) for i in price]
-# the payoff of long stock postion
-payoff_long_stock = [i-strike for i in price]
-# the payoff of covered call
-payoff_covered_call = np.sum([payoff_short_call, payoff_long_stock], axis=0)
-plt.figure(figsize=(20,11))
-plt.plot(price, payoff_short_call, label = 'short call')
-plt.plot(price, payoff_long_stock, label = 'long stock')
-plt.plot(price, payoff_covered_call, label = 'covered call')
-plt.legend(fontsize = 20)
-plt.xlabel('Stock Price at Expiry',fontsize = 15)
-plt.ylabel('payoff',fontsize = 15)
-plt.title('Covered Call Strategy Payoff at Expiration',fontsize = 20)
-plt.grid(True)
-
-
-
Implementation
-
Step 1: Initialize the Algorithm
-At the beginning of your algorithm, you need to set the start date, the end date and the cash required for the algorithm. For options algorithm, you need to add the equity and the options written on this equity.
-
def Initialize(self):
- self.SetStartDate(2016, 1, 1)
- self.SetEndDate(2016, 3, 1)
- self.SetCash(100000)
- equity = self.AddEquity("IBM", Resolution.Minute)
- option = self.AddOption("IBM", Resolution.Minute)
- self.symbol = option.Symbol
- # set our strike/expiry filter for this option chain
- option.SetFilter(-3, +3, timedelta(0), timedelta(30))
- # use the underlying equity as the benchmark
- self.SetBenchmark(equity.Symbol)
- self.call = "IBM" # Initialize the call contract
-
-Second, in the initialization process, you need to add a coarse selection for the options contracts. Here we use option.SetFilter(-3, +3, timedelta(0), timedelta(60)) to implement the coarse selection process. If today's market price of underlying stock is $159, the strike prices of IBM options are spaced $5. Then SetFilter will look up the most at the money contract with the strike being K=$160 (Here K might not be $159 since rarely will option be ATM exactly). The filter will look for options with strikes between and including (160-5*3, 160+5*3). The time to expiration of these options is restricted within 60 days from now on.
-
Step 2: Choose the Call Options Contract
-First, purchase the underlying stock for 100 shares or an integral multiple of 100 shares. For options contract, one contract represents 100 shares of stock.
-
-Second, filter out the call options from candidate contracts.call = [x for x in chain if x.Right == 0] For call options, the right is 0, for put options, the right is 1.
-
-Third, select the most ATM contract with the furthest expiration date from call options contracts. Sell this call contract for each 100 shares of stock you own. Here you can also choose ITM or OTM contract based on your expected level of profit and the level of risk you can take.
-
def TradeOptions(self,slice):
- if slice.OptionChains.Count == 0: return
- for i in slice.OptionChains:
- if i.Key != self.symbol: continue
- chain = i.Value
- call = [x for x in chain if x.Right == 0] # filter the call options contracts
- # sorted the contracts according to their expiration dates and choose the ATM options
- contracts = sorted(sorted(call, key = lambda x: abs(chain.Underlying.Price - x.Strike)),
- key = lambda x: x.Expiry, reverse=True)
- if len(contracts) == 0: return
- contract = contracts[0]
- self.call = contract.Symbol
- self.Sell(self.call, 1) # short the call options
- if self.Portfolio["IBM"].Quantity == 0:
- self.Buy("IBM",100) # buy 100 the underlying stock
- self.Log("The stock price at time 0 S(0): {}".format(self.Securities["IBM"].Price))
-
-Fourth, at the expiration date we print out the price and position information
-
def OnData(self,slice):
- if not self.Portfolio[self.call].Invested and self.Time.hour != 0 and self.Time.minute == 1:
- self.TradeOptions(slice) # sell the call option
-
- # if the option contract expires, print out the price and position information
- if slice.Delistings.Count > 0:
- if [x.Key == self.call for x in slice.Delistings]:
- self.Log("stock IBM quantity: {0}".format(self.Portfolio["IBM"].Quantity))
- self.Log("{0} quantity: {1}".format(self.call.Value, self.Portfolio[self.call].Quantity))
- self.Log("The stock price at Expiry S(T): {}".format(self.Securities["IBM"].Price))
-
-
Summary
-From the above strategy we can see, the share price of IBM had been increasing during the backtesting period from January 2016 to June 2016. The drawdown is small. The Covered Call strategy performs better than a simple buy-and-hold strategy of underlying stock in a bearish market. The benefit of Covered Call is that you keep the premium, stock gains up to the strike price, and accrued dividends during the stock holding period. But in a bullish market, you will lose the potential gains over the strike price.
-
-Bull Call Spread is an option strategy involved with two call option contracts with the same expiration but different strikes. The strategy buys the call options with a lower strike and sells the same amount of call options with a higher strike price.
-
-This strategy creates a ceiling and floor for the profit. By purchasing a call and selling a call with higher strike simultaneously, traders can reduce the cost of just one long call option with the premium of a short call option. But the premium of ITM call is more expensive than the OTM call. The strategy limits the loss from the dropping price of the stock but still create a ceiling to the profit while the price is increasing.
-
-Take GOOG as an example. If the share price of GOOG is $950 at time 0, the premium of ITM call option is 20 with strike 900, the premium of OTM call option is 2 with strike 1000. If we ignore the commission, dividends and other transaction fees, the payoff of Bull Call Spread strategy is as follows:
-
price = np.arange(800,1100,1)
-k_low = 900 # lower strike price for call
-k_high = 1000 # higher strike price for call
-premium_low = 20 # premium of call option with lower strike
-premium_high = 2 # premium of call option with higher strike
-# long call with lower strike
-payoff_long_call = [max(-premium, i-k_low-premium_low ) for i in price]
-# short call with higher strike
-payoff_short_call = [min(premium, -(i-k_high-premium_high)) for i in price]
-payoff = np.sum([payoff_long_call, payoff_short_call], axis=0)
-plt.figure(figsize=(20,11))
-plt.plot(price, payoff_long_call, label = 'long call')
-plt.plot(price, payoff_short_call, label = 'short call')
-plt.plot(price, payoff, label = 'Bull Call Spread')
-plt.legend(fontsize = 20)
-plt.xlabel('Stock Price at Expiry',fontsize = 15)
-plt.ylabel('payoff',fontsize = 15)
-plt.title('Bull Call Spread Payoff at Expiration',fontsize = 20)
-plt.grid(True)
-
-
-
-From the payoff plot we can see, the maximum profit of the strategy is the difference between call option strike price sold and call option strike price purchased minus the difference between buying lower strike call premium and selling higher strike call premium.
-
Implementation
-Step 1: First, you need to initialize the algorithm including set the start date, end date and the cash required. Then use option.SetFilter(-6, 6, timedelta(30), timedelta(60)) to filter the candidate contracts which expire in 30 days to 60 days from now on. The strike price range involves both ITM and OTM options. Then we get the option chains of GOOG.
-
def Initialize(self):
- self.SetStartDate(2016, 5, 1)
- self.SetEndDate(2016, 10, 1)
- self.SetCash(200000)
- equity = self.AddEquity("GOOG", Resolution.Minute)
- option = self.AddOption("GOOG", Resolution.Minute)
- self.symbol = option.Symbol
- # set our strike/expiry filter for this option chain
- option.SetFilter(-6, 6, timedelta(30), timedelta(60))
- # use the underlying equity GOOG as the benchmark
- self.SetBenchmark(equity.Symbol)
-
-Step 2: Choose the contracts with the same expiration date. For demonstration purpose here we sorted the contracts by their expiration dates and choose the options with the furthest expiration date in the option chain.
-
def TradeOptions(self,optionchain):
- for i in optionchain:
- if i.Key != self.symbol: continue
- chain = i.Value
- # sorted the optionchain by expiration date and choose the furthest date
- expiry = sorted(chain,key = lambda x: x.Expiry, reverse=True)[0].Expiry
-
-Step 3: Filter the call options from the contracts which expire on the furthest expiration date in the option chain.
-
call = [i for i in chain if i.Expiry == expiry and i.Right == 0]
-
-Step 4: Sort the call options with the same expiration date according to their strike price. Then buy the call option with the lowest strike price and sell the call with the highest strike price.
-
-Note here you need to add the following rules in OnData(self,slice) method because you only need to trade options once and wait until the contracts expire. If you already had securities invested in the portfolio, then you do not need to trade new options.
-
if not self.Portfolio.Invested:
- self.TradeOptions(optionchain)
-
-
Summary
-This strategy can be implemented when you have a moderate outlook on the stock because the payoff reaches its maximum when the price is between the strike price range of two traded options. The strategy protects the downside move of the stock price. But when the price is above the higher strike, the profit is capped.
-
Algorithm
-Backtest (SetFilter)
-
-Backtest (OptionChainProvider)
-
diff --git a/Tutorial Series/Applied Options/Tutorial03 Long Straddle.html b/Tutorial Series/Applied Options/Tutorial03 Long Straddle.html
deleted file mode 100644
index bea2081..0000000
--- a/Tutorial Series/Applied Options/Tutorial03 Long Straddle.html
+++ /dev/null
@@ -1,64 +0,0 @@
-
Definition
-Long Straddle is an option strategy involved with the long position of a call option and a put option. Both of them have the same strike price and the same expiration date. This strategy aims to gain profit when you feel that a stock was about to make a big move, but are not sure which way the price will move.
-
Payoff
-
price = np.arange(750,1000,1)
-strike = 900 # strike price for both call and put
-premium_call = 20 # premium of call option
-premium_put = 10 # premium of put option
-# payoff for the long call
-payoff_long_call = [max(-premium_call, i-strike-premium_call) for i in price]
-# payoff for the long put
-payoff_long_put = [max(-premium_put, strike-i-premium_put) for i in price]
-payoff = np.sum([payoff_long_call, payoff_long_put], axis=0)
-plt.figure(figsize=(20,15))
-plt.plot(price, payoff_long_call, label = 'Long Call')
-plt.plot(price, payoff_long_put, label = 'long put')
-plt.plot(price, payoff, label = 'Long Straddle')
-plt.legend(fontsize = 20)
-plt.xlabel('Stock Price at Expiry',fontsize = 15)
-plt.ylabel('payoff',fontsize = 15)
-plt.title('Long Straddle Payoff',fontsize = 20)
-plt.grid(True)
-
-
-Given this plot, if the stock price moves sharply at the expiration either up or down, the Long Straddle will collect positive profit. the potential profit is unlimited on the upside because the stock price can rise indefinitely. On the downside, the potential profit is substantial, because the stock price can fall to zero. The potential loss is limited to the premium of both call and put options. The maximum loss will be reached if the stock price is exactly equal to the strike price at expiration. Both options will expire worthless.
-
Implementation
-Step 1: Initialize your algorithm and filter the contract. Here we choose the time to expiration between 30 to 60 days from now on.
-
def Initialize(self):
- self.SetStartDate(2017, 4, 01)
- self.SetEndDate(2017, 6, 30)
- self.SetCash(100000)
- equity = self.AddEquity("GOOG", Resolution.Minute)
- option = self.AddOption("GOOG", Resolution.Minute)
- self.symbol = option.Symbol
- # set our strike/expiry filter for this option chain
- option.SetFilter(-5, 5, timedelta(30), timedelta(60))
- # use the underlying equity GOOG as the benchmark
- self.SetBenchmark(equity.Symbol)
-Step 2: Sorted the option chain by expiration and choose the furthest date to filter the call contract. Then sorted those call contracts by their strike price and choose the call contracts with the highest strike price to trade.
-
for i in optionchain:
- if i.Key != self.symbol: continue
- chain = i.Value
- # sorted the optionchain by expiration date and choose the furthest date
- expiry = sorted(chain,key = lambda x: x.Expiry, reverse=True)[0].Expiry
- # filter the call options from the contracts expires on that date
- call = [i for i in chain if i.Expiry == expiry and i.Right == 0]
- # sorted the contracts according to their strike prices
- call_contracts = sorted(call,key = lambda x: x.Strike)
- if len(call_contracts) == 0: continue
- self.call = call_contracts[0]
-
-Step 3: According to the call option contract, choose the put option with the same strike price and the same expiration date. Then buy the call option and the put option at the same time and wait until expiration.
-
for i in chain:
- if i.Expiry == expiry and i.Right == 1 and i.Strike ==call_contracts[0].Strike:
- self.put = i
-self.Buy(self.call.Symbol ,1)
-self.Buy(self.put.Symbol ,1)
-
-
Summary
-There are three possible outcomes at expiration for the Long Straddle strategy. If the stock price is at the strike price at expiration, then both the call and the put become worthless and no stock position is created. If the stock price is above the strike price at expiration, the put option expires worthless, the long call is exercised, the stock is purchased at the strike price and a long stock position for is created. If the stock price is below the strike price at expiration, the call expires worthless, the long put is exercised, the stock is sold at the strike price and a short stock position is created. In this algorithm, the undelying asset is GOOG stock. We purchase both the $820 put and the $820 call at time 0. At the expiration, the share price of GOOG rises to 930 then the call option is exercised and the put options become worthless. After expiration, we hold long position for 100 shares of GOOG stock.
-
Algorithm
-Backtest (Using SetFilter)
-
-Backtest (Using OptionChainProvider)
-
diff --git a/Tutorial Series/Applied Options/Tutorial04 Long Strangle.html b/Tutorial Series/Applied Options/Tutorial04 Long Strangle.html
deleted file mode 100644
index cf44671..0000000
--- a/Tutorial Series/Applied Options/Tutorial04 Long Strangle.html
+++ /dev/null
@@ -1,77 +0,0 @@
-
Definition
-Long Strangle is an options trading strategy that involves the simultaneous buying of an out-of-the-money put and an out-of-the-money call of the same underlying stock and expiration date. Similar to Long Straddle, Long Strangle has unlimited profit and limited risk and can be applied if traders think some major news events may cause the stock to make a sharp move either up or down during the life of the options. But it differs from Long Straddle in that the call strike is above the put strike.
-
Payoff
-
price = np.arange(700,1000,1)
-# Suppose the undelying price at time 0 is 830
-k_call = 870 # The strike price of OTM call
-k_put = 795 # The strike price of OTM put
-premium_call = 8 # premium of call option
-premium_put = 10 # premium of put option
-# payoff for the long call
-payoff_long_call = [max(-premium_call, i-k_call-premium_call) for i in price]
-# payoff for the long put
-payoff_long_put = [max(-premium_put, k_put-i-premium_put) for i in price]
-payoff = np.sum([payoff_long_call, payoff_long_put], axis=0)
-plt.figure(figsize=(20,15))
-plt.plot(price, payoff_long_call, label = 'Long Call')
-plt.plot(price, payoff_long_put, label = 'long put')
-plt.plot(price, payoff, label = 'Long Strangle')
-plt.legend(fontsize = 20)
-plt.xlabel('Stock Price at Expiry',fontsize = 15)
-plt.ylabel('payoff',fontsize = 15)
-plt.title('Long Strangle Payoff',fontsize = 20)
-plt.grid(True)
-
-
-
-
-From the payoff plot, the most that you can lose in a Long Strangle is the total premium you pay for holding the long position of both a put and a call option. The maximum loss occurs when the stock price falls between the strike price of two options. All options are worthless on expiration. The maximum gain of Long Strangle is unlimited for upside move because a stock's price has no maximum threshold.
-
Implementation
-Step 1: Initialize your algorithm including setting the start and end date, setting the cash and filtering the options contracts. Note here in SetFilter, the strike price should range from negative to positive because we need to choose out-of-the-money put and call options from candidate contracts. The strike price of OTM call should be greater than ATM options and the strike price of OTM put should be lower than ATM options.
-
def Initialize(self):
- self.SetStartDate(2017, 4, 1)
- self.SetEndDate(2017, 5, 30)
- self.SetCash(100000)
- equity = self.AddEquity("GOOG", Resolution.Minute)
- option = self.AddOption("GOOG", Resolution.Minute)
- self.symbol = option.Symbol
- # set our strike/expiry filter for this option chain
- option.SetFilter(-15, 15, timedelta(30), timedelta(60))
- # use the underlying equity GOOG as the benchmark
- self.SetBenchmark(equity.Symbol)
-
-Step 2: Sort the option chain by expiration date and choose an expiration date you want to trade. For demonstration purpose, here we choose options with the furthest expiration date in candidate contracts. Then filter out the call options which expire on that date.
-
for i in optionchain:
- if i.Key != self.symbol: continue
- chain = i.Value
- # sorted the option chain by expiration date and choose the furthest date
- expiry = sorted(chain,key = lambda x: x.Expiry, reverse=True)[0].Expiry
- # filter the call options from the contracts expires on that date
- call = [i for i in chain if i.Expiry == expiry and i.Right == 0]
-
-Step 3: Sort the call options by their expiration date and choose the deep OTM contract which has the largest strike price.
-
-Step 4: Select the put options which have the same expiration date with the call option and sort the put options by strike price. Then choose the deep out-of-the-money put which has the minimum strike price among all the available put options.
-
put_contracts = sorted([i for i in chain if i.Expiry == expiry and i.Right == 1], key = lambda x: x.Strike)
-# choose the deep OTM put option
-self.put = put_contracts[0]
-
-Step 5: Buy the call and the put options at the same time and wait until expiration.
-
-In this algorithm, at time 0, we buy OTM call with strike price 870 and OTM put with strike price 795. The share price of GOOG at time 0 is $832.8. At the expiry, the share price of GOOG is $930.16. Therefore we conclude the call option is exercised then we get 100 long stocks position. The put option expires worthless.
-
-You can enter into Long Strangle if you have no clear idea of market direction but forecast there will be a great movement in the underlying asset. As the options you buy are all out of the money, that reduces the cost of this strategy. But because the call and the put options are all out of the money, the stock will need to move even more significantly than long straddle to gain positive profit from this strategy.
-
-
-Butterfly Spread strategy involves four option contracts with the same expiration but three different strike prices. There are four kinds of Butterfly Spread:
-
-
-
-
Name
-
Strategy
-
-
-
-
-
Long butterfly spread with calls
-
Buy 1 ITM call, sell 2 ATM call, buy 1 OTM call
-
-
-
Long butterfly spread with puts
-
Buy 1 ITM put, sell 2 ATM put, buy 1 OTM put
-
-
-
Short butterfly spread with calls
-
Sell 1 ITM call, buy 2 ATM call, sell 1 OTM call
-
-
-
Short butterfly spread with puts
-
Buy 1 ITM put, sell 2 ATM put, buy 1 OTM put
-
-
-
-Butterfly Spread strategy consists of three legs with a total of four options. In this tutorial, we take Long Butterfly Spread as an example: long one ITM call, short two ATM calls and long one OTM call. All the calls have the same expiration. On the other hand, the middle strike is halfway between the lower and the higher strikes.
-
-The aim of Butterfly Spread strategy is to gain profits when traders think that the underlying stock will not rise or fall much by expiration.
-
Payoff
-
price = np.arange(800,1100,1)
-# Suppose the undelying price at time 0 is 935
-k_itm = 915 # the strike price of ITM call
-k_otm = 955 # the strike price of OTM call
-k_atm = 935 # the strike price of ATM call
-premium_itm = 45 # the premium of ITM call
-premium_otm = 15 # the premium of OTM call
-premium_atm = 25 # the premium of ATM call
-# payoff for the long ITM call position
-payoff_itm_long = [max(-premium_itm, i-k_itm-premium_itm) for i in price]
-# payoff for the long OTM call position
-payoff_otm_long = [max(-premium_otm, i-k_otm-premium_otm) for i in price]
-# payoff for the 2 short ATM call position
-payoff_atm_short = [min(2*premium_atm, -2*(i-k_atm-premium_atm)) for i in price]
-# payoff for Butterfly Spread Strategy
-payoff = np.sum([payoff_itm_long,payoff_otm_long,payoff_atm_short], axis=0)
-plt.figure(figsize=(20,15))
-plt.plot(price, payoff_itm_long, label = 'Long ITM Call')
-plt.plot(price, payoff_otm_long, label = 'Long OTM Call')
-plt.plot(price, payoff_atm_short, label = 'Short 2 ATM Call')
-plt.plot(price, payoff, label = 'Long Call Butterfly Spread')
-plt.legend(fontsize = 20)
-plt.xlabel('Stock Price at Expiry',fontsize = 15)
-plt.ylabel('payoff',fontsize = 15)
-plt.title('Long Call Butterfly Spread Payoff',fontsize = 20)
-plt.grid(True)
-
-
-
Implementation
-Step 1: Initialize your algorithm including setting the start date and the end date, setting the cash and implement a coarse selection of option contract. SetFilter(-9, 9, timedelta(30), timedelta(60)) helps us choose the contracts which expire in 30 to 60 days from now on. Since ITM call strike and OTM call strike are symmetrical with ATM call strike. For the strike parameter, the first parameter is the minimum strike rank relative to market price, the second parameter is the maximum strike rank relative to market price. The rank of ATM contract is 0. Here we need to choose 2 numbers which are symmetrical with 0.
-
-Step 2: Second we need to choose an expiration date for all the contracts in Butterfly Spread strategy. Then filter out all the call options expire on that date.
-
for i in optionchain:
- if i.Key != self.symbol: continue
- chain = i.Value
- # sorted the optionchain by expiration date and choose the furthest date
- expiry = sorted(chain,key = lambda x: x.Expiry, reverse=True)[0].Expiry
- # filter the call options from the contracts expires on that date
- call = [i for i in chain if i.Expiry == expiry and i.Right == 0]
-
-Step 3: Sort the call options by their strike price in ascending order. Then the ATM option is the one which has the smallest absolute value of the difference between the strike price and the underlying asset price. The OTM option is the last one in this call options list which has the highest strike price. The corresponding ITM option is the first one in the list which has the lowest strike price.
-
-From the following algorithm, at time 0, the GOOG share price is $832.8. We purchase 1 OTM call option strike at $855, 1 ITM call option strike at $810 and sell 2 ATM options strike at 835. At the expiry 05/19/2017, the share price is $930, then the long positions of the ITM option and the OTM option are all exercised, we buy 100 GOOG shares at $810 and buy another 100 shares at $855. At the same time, the 2 short positions of the ATM option are also exercised. We have to sell 200 GOOG shares to option holder at $835. Then we no longer hold positions after the expiration of this Long Call Butterfly Spread. Since the stock price had a sharp increase during the life of options, we make no profits from this strategy.
-
Algorithm
-Backtest using SetFilter
-
-Backtest using OptionChainProvider
-
diff --git a/Tutorial Series/Applied Options/Tutorial06 Iron Condor.html b/Tutorial Series/Applied Options/Tutorial06 Iron Condor.html
deleted file mode 100644
index 6b44e08..0000000
--- a/Tutorial Series/Applied Options/Tutorial06 Iron Condor.html
+++ /dev/null
@@ -1,110 +0,0 @@
-
Definition
-Iron Condor is an option strategy which involves four option contracts.All options have the same expiration date. The order of strike for four contracts is A > B > C > D.
-
-
-
-
Position
-
Strike
-
-
-
-
-
long 1 OTM put
-
A
-
-
-
short 1 OTM put
-
B
-
-
-
short 1 OTM call
-
C
-
-
-
long 1 OTM call
-
D
-
-
-
-The Iron Condor is the combination of a bear put spread and a bull call spread in which the strike price of the long put is lower than the strike price of the long call. If the stock price is between the two short strike prices when the options expire, the strategy will be profitable.
-
Payoff
-
price = np.arange(700,950,1)
-k_call_higher = 850 # the strike price of OTM call(Higher k)
-k_call_lower = 840 # the strike price of OTM call(Lower k)
-k_put_higher = 760 # the strike price of OTM put(Higher k)
-k_put_lower = 750 # the strike price of OTM put(Lower k)
-premium_call_higher = 1 # the premium of OTM call(Higher k)
-premium_call_lower = 10 # the premium of OTM call(Lower k)
-premium_put_higher = 11 # the premium of oTM put(Higher k)
-premium_put_lower = 1 # the premium of OTM put(Lower k)
-# payoff for the long put position
-payoff_long_put = [max(premium_put_lower, k_put_lower-i-premium_put_lower) for i in price]
-# payoff for the short put position
-payoff_short_put = [min(premium_put_higher, -(k_put_higher-i+premium_put_higher)) for i in price]
-# payoff for the short call position
-payoff_short_call = [min(premium_call_lower, -(i-k_call_lower+premium_call_lower)) for i in price]
-# payoff for the long call position
-payoff_long_call = [max(premium_call_higher, i-k_call_higher-premium_call_higher) for i in price]
-# payoff for Long Iron Condor Strategy
-payoff = np.sum([payoff_long_put,payoff_short_put,payoff_short_call,payoff_long_call], axis=0)
-plt.figure(figsize=(20,15))
-plt.plot(price, payoff_long_put, label = 'Long Put',linestyle='--')
-plt.plot(price, payoff_short_put, label = 'Short Put',linestyle='--')
-plt.plot(price, payoff_short_call, label = 'Short Call',linestyle='--')
-plt.plot(price, payoff_long_call, label = 'Long Call',linestyle='--')
-plt.plot(price, payoff, label = 'Long Iron Condor',c='black')
-plt.legend(fontsize = 20)
-plt.xlabel('Stock Price at Expiry',fontsize = 15)
-plt.ylabel('payoff',fontsize = 15)
-plt.title('Long Iron Condor Strategy Payoff',fontsize = 20)
-plt.grid(True)
-
-
-Here the strike price is A(750), B(760), C(850) and D(860). From the payoff plot, the maximum profit all come from the options premium because the deeper OTM options are cheaper than the less deep ones. It is reached when the stock price is between higher put strike and lower call strike. They are two short positions. In this condition, all the options expire worthless. The maximum loss of Iron Condor is reached when the stock price is lower than the lowest strike A, then the two call options become worthless, the two puts are in the money. For the other condition, the stock price is higher than the highest strike D.Consequently, The two call options are in the money but the two puts expire worthless.
-
Implementation
-Step 1: Initialize your algorithm which involves setting the start date and the end date, setting the cash for your algorithm and implement the coarse selection of option contracts.
-
-Step 2: Break the candidate options into two parts: call and put options.
-
for i in optionchain:
- if i.Key != self.symbol: continue
- chain = i.Value
- # filter the call and put options on the contracts
- call = [i for i in chain if i.Right == 0]
- put = [i for i in chain if i.Right == 1]
-
-Step 3: Sort the call and put options by their strike price respectively.
-
-Step 4: Choose the corresponding options and trade them. In this algorithm, according to criteria,SetFilter(-20, 20, timedelta(0), timedelta(40)) for put option list, there are 41 contracts in total: 1 ATM put, 20 OTM puts and 20 ITM puts. we choose the first in the put option list as the OTM put with the lower strike, choose the 15 contract as the OTM put with the higher strike.
-
-The iron condor is an option strategy that earns money as long as the underlying asset price does move out of a predetermined price range. In this algorithm, that range is $775 to $827.5. At 02/01/2017, we long $750 put at $1.25 and short $775 put at $3.5. At the same time, we short $827.5 call at$2.3 and long $850 call at $0.75. At this moment, the GOOG share price is $799.55 all the options are out the money. At expiration date 02/17/2017, the share price of GOOG is $828.07. The long put, short put and long call expire worthless. The short call is exercised. Thus we get the short position of 100 GOOG shares.
-
Algorithm
-Backtesing using SetFilter
-
-Backtest using OptionChainProvider
-
diff --git a/Tutorial Series/Applied Options/Tutorial07 Iron Butterfly.html b/Tutorial Series/Applied Options/Tutorial07 Iron Butterfly.html
deleted file mode 100644
index e2afa5a..0000000
--- a/Tutorial Series/Applied Options/Tutorial07 Iron Butterfly.html
+++ /dev/null
@@ -1,112 +0,0 @@
-
Definition
-Iron Butterfly is an option strategy which involves four option contracts. All options have the same expiration date. The order of strike for four contracts is A > B > C.
-
-
-
-
Position
-
Strike
-
-
-
-
-
Buy 1 OTM put
-
A
-
-
-
Sell 1 ATM put
-
B
-
-
-
Sell 1 ATM call
-
B
-
-
-
Buy 1 OTM call
-
C
-
-
-
-Similar to the Iron Condor, Iron Butterfly is a limited risk, limited profit trading strategy. It profits from lower volatility meaning that traders gain profits from this strategy if the stock price changes within a small range. Iron Butterfly has a more narrow range for the price to move up or down compared with Iron Condor.
-
Payoff
-
price = np.arange(700,950,1)
-k_atm = 830 # the strike price of ATM call & put
-k_otm_put = 800 # the strike price of OTM put
-k_otm_call = 860 # the strike price of OTM call
-premium_otm_put = 2 # the premium of OTM put
-premium_atm_put = 7 # the premium of ATM put
-premium_atm_call = 8 # the premium of ATM call
-premium_otm_call = 1 # the premium of OTM call
-# payoff for the long put position
-payoff_long_put = [max(-premium_otm_put, k_otm_put-i-premium_otm_put) for i in price]
-# payoff for the short put position
-payoff_short_put = [min(premium_atm_put, -(k_atm-i-premium_atm_put)) for i in price]
-# payoff for the short call position
-payoff_short_call = [min(premium_atm_call, -(i-k_atm-premium_atm_call)) for i in price]
-# payoff for the long call position
-payoff_long_call = [max(-premium_otm_call, i-k_otm_call-premium_otm_call) for i in price]
-# payoff for Iron Butterfly Strategy
-payoff = np.sum([payoff_long_put,payoff_short_put,payoff_short_call,payoff_long_call], axis=0)
-plt.figure(figsize=(20,15))
-plt.plot(price, payoff_long_put, label = 'Long Put',linestyle='--')
-plt.plot(price, payoff_short_put, label = 'Short Put',linestyle='--')
-plt.plot(price, payoff_short_call, label = 'Short Call',linestyle='--')
-plt.plot(price, payoff_long_call, label = 'Long Call',linestyle='--')
-plt.plot(price, payoff, label = 'Iron Butterfly',c='black')
-plt.legend(fontsize = 20)
-plt.xlabel('Stock Price at Expiry',fontsize = 15)
-plt.ylabel('payoff',fontsize = 15)
-plt.title('Iron Butterfly Strategy Payoff',fontsize = 20)
-plt.grid(True)
-
-
-From the payoff plot, the maximum gain is simply the net credit you received when you buy and sell 4 options. This occurs if the stock price is exactly the same as the strike price of ATM options. In this condition, all options expire worthless and you keep all premiums received. We can see the Iron Butterfly has more narrow structures than the Iron Condor. However, the profit can be higher than with the Iron Condor as you receive more premium by selling ATM options than OTM options.
-
-The maximum loss occurs if the underlying price is either below the OTM put strike or above the OTM call strike. In these two conditions, two puts or two calls are exercised and the other two options expire worthless.
-
Implementation
-Step 1: Initialize your algorithm which includes setting the start date and end date, setting the cash and implement the coarse selection of option contracts.
-
-Step 2: Break the candidate contracts into the call and put options.
-
def TradeOptions(self,optionchain):
- for i in optionchain:
- if i.Key != self.symbol: continue
- chain = i.Value
- # filter the call and put options from the contracts
- call = [i for i in chain if i.Right == 0]
- put = [i for i in chain if i.Right == 1]
-
-Step 3: Sort the call and put options according to their strike price respectively. option.SetFilter(-10, 10, timedelta(0), timedelta(30)) helps us choose 21 call options and 21 put options which expire within 30 days from now on.Then for call option, the first 10 contracts are in the money, the last 10 contracts are out of the money. The middle one is at the money option. For put options, the first 10 contracts are out of the money, the last 10 contracts are in the money.
-
-Step 4: Find the specific contracts to trade. At the money options have the minimum absolute value of the difference between the underlying price and the strike price.
-
-In this algorithm, on 04/03/2017, the share price of Google is $832.8. We buy OTM put(strike = $805) at $2, OTM call(strike = $860) and sell an ATM call and an ATM put. At the expiry 04/21/2017, the share price is $841.53. The ATM call is exercised and the other 3 options expire worthless. As we hold the short position of ATM call, after expiration we hold 100 short positions of GOOG stock.
-
-Protective Collar is an option strategy that involves both the underlying stock and two option contracts. The trader buys (or already owns) a stock, then buys an out-the-money put option and sells an out-the-money call option. It is similar to the covered call strategy with the purchase of an additional put option. It is being used if the trader is writing covered calls but wish to protect himself from an unexpected downside sharp move in the price of the underlying security. As a tradeoff, the profit will become limited compared with the covered call strategy.
-
Payoff
-
# Protective Collar
-price = np.arange(700,950,1)
-# assume at time 0, the price of the undelying stock is 830
-k_otm_put = 800 # the strike price of OTM put
-k_otm_call = 860 # the strike price of OTM call
-premium_otm_put = 6 # the premium of OTM put
-premium_otm_call = 2 # the premium of OTM call
-# payoff for the long put position
-payoff_long_put = [max(-premium_otm_put, k_otm_put-i-premium_otm_put) for i in price]
-# payoff for the short call position
-payoff_short_call = [min(premium_otm_call, -(i-k_otm_call-premium_otm_call)) for i in price]
-# payoff for the underlying stock
-payoff_stock = price - 830
-# payoff for the Protective Collar Strategy
-payoff = np.sum([payoff_long_put,payoff_short_call,payoff_stock], axis=0)
-plt.figure(figsize=(20,15))
-plt.plot(price, payoff_long_put, label = 'Long Put',linestyle='--')
-plt.plot(price, payoff_short_call, label = 'Short Call',linestyle='--')
-plt.plot(price, payoff_stock, label = 'Underlying Stock',linestyle='--')
-plt.plot(price, payoff, label = 'Protective Collar',c='black')
-plt.legend(fontsize = 20)
-plt.xlabel('Stock Price at Expiry',fontsize = 15)
-plt.ylabel('payoff',fontsize = 15)
-plt.title('Protective Collar Strategy - Payoff',fontsize = 20)
-plt.grid(True)
-
-
-
-According to the payoff plot, the maximum profit is the strike price of short call minus the purchase price of the underlying asset add the net credit from the premium. It occurs when the stock price is beyond the strike price of the short call option. The maximum loss is the purchase price of the underlying asset minus the strike price of the long put minus the net credit from the premium. It occurs when the stock price is below the strike price of the long put. It is a strategy with limit risk and limit profit.
-
Implementation
-Step 1: Initialize your algorithm that involves setting the start date and the end date, setting the cash and implement the coarse selection of option contracts.
-
def Initialize(self):
- self.SetStartDate(2017, 4, 1)
- self.SetEndDate(2017, 5, 30)
- self.SetCash(1000000)
- equity = self.AddEquity("GOOG", Resolution.Minute)
- option = self.AddOption("GOOG", Resolution.Minute)
- self.symbol = option.Symbol
- # set our strike/expiry filter for this option chain
- option.SetFilter(-10, +10, timedelta(0), timedelta(30))
- # use the underlying equity as the benchmark
- self.SetBenchmark(equity.Symbol)
-
-Step 2: Choose the expiration date for your options traded and break the options into the call and put contracts. The choice of expiration date depends on the holding period of stocks in your portfolio.
-
def TradeOptions(self,optionchain):
- for i in optionchain:
- if i.Key != self.symbol: continue
- chain = i.Value
- # choose the furthest expiration date within 30 days from now on
- expiry = sorted(chain, key = lambda x: x.Expiry)[-1]
- # filter the call options contracts
- call = [x for x in chain if x.Right == 0 and x.Expiry == expiry]
- # filter the put options contracts
- put = [x for x in chain if x.Right == 1 and x.Expiry == expiry]
-
-Step 3: Choose the deep in-the-money call and put options in the list and then sell the call options and buy the put options.
-
self.otm_call = sorted(call, key = lambda x: x.Strike)[-1]
-self.otm_put = sorted(put, key = lambda x: x.Strike)[0]
-if (self.otm_call is None) or (self.otm_put is None): continue
-self.Sell(self.otm_call.Symbol, 1) # sell the OTM call
-self.Buy(self.otm_put.Symbol, 1) # buy the OTM put
-
-Step 4: In Ondata, if there is no assets in portfolio, we buy the undelying stocks. After that, we trade the options which equivalent to the amount of your stocks holding. (one option contracts equals 100 undelying shares).
-
def OnData(self,slice):
- optionchain = slice.OptionChains
- for i in slice.OptionChains:
- if i.Key != self.symbol: continue
- chains = i.Value
- contract_list = [x for x in chains]
- if (slice.OptionChains.Count == 0) or (len(contract_list) == 0): return
- # if you don't hold options and stocks, buy the stocks and trade the options
- if not self.Portfolio.Invested:
- self.Buy("GOOG",100) # buy 100 shares of the underlying stock
- self.TradeOptions(optionchain) # sell OTM call and buy OTM put
-
-
Summary
-In this algorithm, at the beginning 01/04/2016, we purchased 100 GOOG shares. At the same time, we purchased a $715 put at $6 and sells a $772.5 call at $2.45. The share price of GOOG is $739.32, which is between the strike prices of two out-the-money options. At the expiry 01/15/2016, the share price of GOOG drops to $714.32. The call option expire worthless but the put option is exercised. Then we sell 100 GOOG shares at $715. Then we hold neither option positions and stock positions.
-
This tutorial series introduces basic Python applied to financial concepts. If you have great investment ideas but don't know how to write them, or if you think you need to learn some basic skills in quantitative finance, then this is a good starting point. The series is broken into four parts: python, math and statistics, basic financial concepts related to investment and financial time series analysis.
-
-
We not only introduce the concepts but also show you how to apply the introduced techniques step by step using Python code snippets. We use real financial datasets as examples and after each chapter we design a QuantConnect algorithm applying what we learned.
-The most popular asset pricing model since 1992.
- Read Tutorial
-
-
-
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial01 Data Types and Data Structures.html b/Tutorial Series/Introduction to Financial Python/Tutorial01 Data Types and Data Structures.html
deleted file mode 100644
index 4f0da86..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial01 Data Types and Data Structures.html
+++ /dev/null
@@ -1,230 +0,0 @@
-This tutorial provides a basic introduction to the Python programming language. If you are new to Python, you should run the code snippets while reading this tutorial. If you are an advanced Python user, please feel free to skip this chapter.
-
-
Basic Variable Types
-
-The basic types of variables in Python are: strings, integers, floating point numbers and booleans.
-
-Strings in python are identified as a contiguous set of characters represented in either single quotes (' ') or double quotes (" ").
-
-
-An integer is a round number with no values after the decimal point.
-
my_int = 10
-print my_int
-[out]: 10
-print type(my_int)
-[out]: type 'int'
-
-
-The built-in function int() can convert a string into an integer.
-
my_string = "100"
-print type(my_string)
-[out]: type 'str'
-my_int = int(my_string)
-print type(my_int)
-[out]: type 'int'
-
-
-A floating point number, or a float, is a real number in mathematics. In Python we need to include a value after a decimal point to define it as a float.
-
my_float = 1.0
-print type(my_float)
-[out]: type 'float'
-my_int = 1
-print type(my_int)
-[out]: type 'int'
-
-
-As you can see above, if we don't include a decimal value, the variable would be defined as an integer. The built-in function float() can convert a string or an integer into a float.
-
-
-A boolean, or bool, is a binary variable. Its value can only be True or False. It is useful when we do some logic operations, which would be covered in our next chapter.
-
-
-To get a float instead of an integer, either the numerator or denominator must be a float as shown above. This isn't a problem in Python 3 since 1/3 will return 0.3333333333
-
-
Data Collections
-
-
List
-
-A list is an ordered collection of values. A list is mutable, which means you can change a list's value without changing the list itself. Creating a list is simply putting different comma-separated values between square brackets.
-
-
-The values in a list are called "elements". We can access list elements by indexing. Python index starts from 0. So if you have a list of length n, the index of the first element will be 0, and that of the last element will be n − 1. By the way, the length of a list can be obtained by the built-in function len().
-
-
-The slice starts from the first element indicated, but excludes the last element indicated. Here we select all elements starting from index 1, which refers to the second element:
-
print my_list[1:]
-[out]: ['Connect', 1, 2, 3]
-
-
-And all elements up to but excluding index 3:
-
-
-When there are repeated instances of "Hello", the first one is removed.
-
-
Tuple
-
-A tuple is a data structure type similar to a list. The difference is that a tuple is immutable, which means you can't change the elements in it once it's defined. We create a tuple by putting comma-separated values between parentheses.
-
my_tuple = ('Welcome','to','QuantConnect')
-
-
-Just like a list, a tuple can be sliced by using index.
-
-Set is an easy way to remove duplicate elements from a list.
-
-
Dictionary
-
-A dictionary is one of the most important data structures in Python. Unlike sequences which are indexed by integers, dictionaries are indexed by keys which can be either strings or floats.
-
-A dictionary is an unordered collection of key : value pairs, with the requirement that the keys are unique. We create a dictionary by placing a comma-separated list of key : value pairs within the braces.
-
-
-A string is an immutable sequence of characters. It can be sliced by index just like a tuple:
-
my_str = 'Welcome to QuantConnect'
-print my_str[8:]
-[out]: to QuantConnect
-
-
-There are many methods associated with strings. We can use string.count() to count the occurrences of a character in a string, use string.find() to return the index of a specific character, and use string.replace() to replace characters.
-
-print "Counting the number of e's in this sentence".count('e')
-[out]: 6
-print 'The first time e appears in this sentence'.find('e')
-[out]: 2
-print 'all the a in this sentence now becomes e'.replace('a','e')
-[out]: ell the e in this sentence now becomes e
-
-
-The most commonly used method for strings is string.split(). This method will split the string by the indicated character and return a list:
-
-
-Another way to format a string is to use the % symbol.
-
print 'pi is %f' % 3.14
-[out]: pi is 3.140000
-print '%s to %s' % ('Welcome', 'Quantconnect')
-[out]: Welcome to Quantconnect
-
-
-%s is a placeholder that takes in a string. Similarly %f takes a float and %d takes an integer.
-
-
Summary
-
-We have seen the basic data types and data structures in Python. It's important to keep practicing to become familiar with these data structures. In the next tutorial, we will cover for and while loops and logical operations in Python.
\ No newline at end of file
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial02 Logical Operations and Loops.html b/Tutorial Series/Introduction to Financial Python/Tutorial02 Logical Operations and Loops.html
deleted file mode 100644
index abd7ba1..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial02 Logical Operations and Loops.html
+++ /dev/null
@@ -1,194 +0,0 @@
-We discussed the basic data types and data structures in Python in the last tutorial. This chapter covers logical operations and loops in Python, which are very common in programming.
-
-
Logical Operations
-
-Like most programming languages, Python has comparison operators:
-
print 1 == 0 # 1 equals 0
-print 1 == 1 # 1 equals 1
-print 1 != 0 # 1 is not equal to 0
-print 5 >= 5 # 5 is greater than or equal to 5
-print 5 >= 6 # 5 is greater than or equal to 6
-[out]:
-False
-True
-True
-True
-False
-
-
-Each statement above has a boolean value, which must be either True or False, but not both.
-
-We can combine simple statements P and Q to form complex statements using logical operators:
-
-
The statement "P and Q" is true if both P and Q are true, otherwise it is false.
-
The statement "P or Q" is false if both P and Q are false, otherwise it is true.
-
The statement "not P" is true if P is false, and vice versa.
-
-
-
print 2 > 1 and 3 > 2
-print 2 > 1 and 3 < 2
-print 2 > 1 or 3 < 2
-print 2 < 1 and 3 < 2
-[out]:
-True
-False
-True
-False
-
-
-When dealing with a very complex logical statement that involves in several statements, we can use brackets to separate and combine them.
-
print (3 > 2 or 1 < 3) and (1!=3 and 4>3) and not ( 3 < 2 or 1 < 3 and (1!=3 and 4>3))
-print 3 > 2 or 1 < 3 and (1!=3 and 4>3) and not ( 3 < 2 or 1 < 3 and (1!=3 and 4>3))
-[out]:
-False
-True
-
-
-Comparing the above two statements, we can see that it's wise to use brackets when we make a complex logical statement.
-
-
If Statement
-
-An if statement executes a segment of code only if its condition is true. A standard if statement consists of 3 segments: if, elif and else.
-
if condition1:
- # if condition1 is true, execute the code here
- # and ignore the rest of this if statement
-elif condition2:
- # if condition1 is false, and condition2 is true, execute the code here
- # and ignore the rest of this if statement
-else:
- # if none of the above conditions is True, execute the code here
-
-
-An if statement doesn't necessarily has elif and else part. If it's not specified, the indented block of code will be executed when the condition is true, otherwise the whole if statement will be skipped.
-
i = 0
-if i == 0: print 'i == 0 is True'
-[out]: i==0 is True
-
-
-As we mentioned above, we can write some complex statements here:
-
p = 1 > 0
-q = 2 > 3
-if p and q:
- print 'p and q is true'
-elif p and not q:
- print 'q is false'
-elif q and not p:
- print 'p is false'
-else:
- print 'None of p and q is true'
-[out]: q is false
-
-
-
Loop Structures
-
-Loops are an essential part of programming. The "for" and "while" loops run a block of code repeatedly.
-
-
While Loop
-
-A "while" loop will run repeatedly until a certain condition has been met.
-
i = 0
-while i < 5:
- print i
- i += 1
-[out]:
-0
-1
-2
-3
-4
-
-
-When making a while loop, we need to ensure that something changes from iteration to iteration so that the while loop will terminate, otherwise it will run forever. Here we used i += 1 (short for i = i + 1) to make i larger after each iteration. This is the most commonly used method to control a while loop.
-
-
For Loop
-
-A "for" loop will iterate over a sequence of value and terminate when the sequence has ended.
-
for x in [1,2,3,4,5]: print x
-[out]:
-1
-2
-3
-4
-5
-
-
-We can also add if statements in a for loop. Here is a real example from our pairs trading algorithm:
-
stocks = ['AAPL','GOOG','IBM','FB','F','V', 'G', 'GE']
-selected = ['AAPL','IBM']
-new_list = []
-for stock in stocks:
- if stock not in selected:
- new_list.append(stock)
-print new_list
-[out]: ['GOOG', 'FB', 'F', 'V', 'G', 'GE']
-
-
-Here we iterated all the elements in the list 'stocks'. Later in this chapter we will introduce a smarter way to do this, which is just an one-line code.
-
-
Break and continue
-
-These are two commonly used commands in a for loop. If "break" is triggered while a loop is executing, the loop will terminate immediately:
-
-
-List comprehension is a Pythonic way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence. For example, if we want to create a list of squares using for loop:
-
squares = []
-for i in [1,2,3,4,5]:
- squares.append(i**2)
-print squares
-[out]: [1, 4, 9, 16, 25]
-
-
-Using list comprehension:
-
foo = [1,2,3,4,5]
-squares = [x**2 for x in foo]
-print squares
-[out]: [1, 4, 9, 16, 25]
-
-
-Recall the example above where we used a for loop to select stocks. Here we use list comprehension:
-
stocks = ['AAPL','GOOG','IBM','FB','F','V', 'G', 'GE']
-selected = ['AAPL','IBM']
-new_list = [x for x in stocks if x not in selected]
-print new_list
-[out]: ['GOOG', 'FB', 'F', 'V', 'G', 'GE']
-
-
-A list comprehension consists of square brackets containing an expression followed by a "for" clause, and possibly "for" or "if" clauses. For example:
-
print [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
-print [str(x) + ' vs ' + str(y) for x in ['AAPL','GOOG','IBM','FB']
- for y in ['F','V','G','GE'] if x != y]
-[out]:
-[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
-['AAPL vs F', 'AAPL vs V', 'AAPL vs G', 'AAPL vs GE', 'GOOG vs F', 'GOOG vs V', 'GOOG vs G', 'GOOG vs GE', 'IBM vs F', 'IBM vs V', 'IBM vs G', 'IBM vs GE', 'FB vs F', 'FB vs V', 'FB vs G', 'FB vs GE']
-
-
-List comprehension is an elegant way to organize one or more for loops when creating a list.
-
-
Summary
-This chapter has introduced logical operations, loops and list comprehension. In the next chapter we will introduce functions and object-oriented programming, which will enable us to make our codes clean and versatile.
\ No newline at end of file
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial02 Logical Operations and Loops.ipynb b/Tutorial Series/Introduction to Financial Python/Tutorial02 Logical Operations and Loops.ipynb
deleted file mode 100644
index 4270da9..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial02 Logical Operations and Loops.ipynb
+++ /dev/null
@@ -1,372 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "False\n",
- "True\n",
- "True\n",
- "True\n",
- "False\n"
- ]
- }
- ],
- "source": [
- "print 1 == 0\n",
- "print 1 == 1\n",
- "print 1 != 0\n",
- "print 5 >= 5\n",
- "print 5 >= 6"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "True\n",
- "False\n",
- "True\n",
- "False\n"
- ]
- }
- ],
- "source": [
- "print 2 > 1 and 3 > 2\n",
- "print 2 > 1 and 3 < 2 \n",
- "print 2 > 1 or 3 < 2\n",
- "print 2 < 1 and 3 < 2"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "False\n",
- "True\n"
- ]
- }
- ],
- "source": [
- "print (3 > 2 or 1 < 3) and (1!=3 and 4>3) and not ( 3 < 2 or 1 < 3 and (1!=3 and 4>3))\n",
- "print 3 > 2 or 1 < 3 and (1!=3 and 4>3) and not ( 3 < 2 or 1 < 3 and (1!=3 and 4>3))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [
- {
- "ename": "IndentationError",
- "evalue": "expected an indented block (, line 5)",
- "output_type": "error",
- "traceback": [
- "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m elif statement2:\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
- ]
- }
- ],
- "source": [
- "if statement1:\n",
- " # if the statement1 is true, execute the code here.\n",
- " # code.....\n",
- " # code.....\n",
- "elif statement2:\n",
- " # if the statement 1 is false, skip the codes above to this part.\n",
- " # code......\n",
- " # code......\n",
- "else:\n",
- " # if none of the above statements is True, skip to this part\n",
- " # code......"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "i==0 is True\n"
- ]
- }
- ],
- "source": [
- "i = 0\n",
- "if i == 0:\n",
- " print 'i==0 is True'"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "q is false\n"
- ]
- }
- ],
- "source": [
- "p = 1 > 0\n",
- "q = 2 > 3\n",
- "if p and q:\n",
- " print 'p and q is true'\n",
- "elif p and not q:\n",
- " print 'q is false'\n",
- "elif q and not p:\n",
- " print 'p is false'\n",
- "else:\n",
- " print 'None of p and q is true'"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "0\n",
- "1\n",
- "2\n",
- "3\n",
- "4\n"
- ]
- }
- ],
- "source": [
- "i = 0\n",
- "while i < 5:\n",
- " print i\n",
- " i += 1 "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1\n",
- "2\n",
- "3\n",
- "4\n",
- "5\n"
- ]
- }
- ],
- "source": [
- "for i in [1,2,3,4,5]:\n",
- " print i"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "['AAPL', 'GOOG', 'IBM', 'FB', 'F', 'V', 'G', 'GE']\n"
- ]
- }
- ],
- "source": [
- "stocks = ['AAPL','GOOG','IBM','FB','F','V', 'G', 'GE']\n",
- "selected = ['AAPL','IBM']\n",
- "new_list = []\n",
- "for i in stocks:\n",
- " if i not in selected:\n",
- " new_list.append(i)\n",
- "print stocks"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "AAPL\n",
- "GOOG\n",
- "IBM\n",
- "FB\n"
- ]
- }
- ],
- "source": [
- "stocks = ['AAPL','GOOG','IBM','FB','F','V', 'G', 'GE']\n",
- "for i in stocks:\n",
- " print i\n",
- " if i == 'FB':\n",
- " break"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "AAPL\n",
- "GOOG\n",
- "IBM\n",
- "F\n",
- "V\n",
- "G\n",
- "GE\n"
- ]
- }
- ],
- "source": [
- "stocks = ['AAPL','GOOG','IBM','FB','F','V', 'G', 'GE']\n",
- "for i in stocks:\n",
- " if i == 'FB':\n",
- " continue\n",
- " print i"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[1, 4, 9, 16, 25]\n"
- ]
- }
- ],
- "source": [
- "squares = []\n",
- "for i in [1,2,3,4,5]:\n",
- " squares.append(i**2)\n",
- "print squares"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[1, 4, 9, 16, 25]\n"
- ]
- }
- ],
- "source": [
- "list = [1,2,3,4,5]\n",
- "squares = [x**2 for x in list]\n",
- "print squares"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 15,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "['AAPL', 'IBM']\n"
- ]
- }
- ],
- "source": [
- "stocks = ['AAPL','GOOG','IBM','FB','F','V', 'G', 'GE']\n",
- "selected = ['AAPL','IBM']\n",
- "new_list = [x for x in stocks if x in selected]\n",
- "print new_list"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 17,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]\n",
- "['AAPL vs F', 'AAPL vs V', 'AAPL vs G', 'AAPL vs GE', 'GOOG vs F', 'GOOG vs V', 'GOOG vs G', 'GOOG vs GE', 'IBM vs F', 'IBM vs V', 'IBM vs G', 'IBM vs GE', 'FB vs F', 'FB vs V', 'FB vs G', 'FB vs GE']\n"
- ]
- }
- ],
- "source": [
- "print [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]\n",
- "print [str(x)+' vs '+str(y) for x in ['AAPL','GOOG','IBM','FB'] for y in ['F','V','G','GE'] if x!=y]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 2",
- "language": "python",
- "name": "python2"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 2
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.13"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial03 Functions and Objective-Oriented Programming.html b/Tutorial Series/Introduction to Financial Python/Tutorial03 Functions and Objective-Oriented Programming.html
deleted file mode 100644
index 295e09f..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial03 Functions and Objective-Oriented Programming.html
+++ /dev/null
@@ -1,194 +0,0 @@
-In the last tutorial we introduced logical operations, loops and list comprehension. We will introduce functions and object-oriented programming in this chapter, which will enable us to build complex algorithms in more flexible ways.
-
-
Functions
-
-A function is a reusable block of code. We can use a function to output a value, or do anything else we want. We can easily define our own function by using the keyword "def".
-
-
-
-The keyword "def" is followed by the function name and the parenthesized list of formal parameters. The statements that form the body of the function start at the next line, and must be indented. The product() function above has "x" and "y" as its parameters. A function doesn't necessarily have parameters:
-
-
def say_hi():
- print "Welcome to QuantConnect'
-say_hi()
-[out]: Welcome to QuantConnect
-
-
-
Built-in Function
-
-range() is a function that creates a list containing an arithmetic sequence. It's often used in for loops. The arguments must be integers. If the "step" argument is omitted, it defaults to 1.
-
-
-len() is another function used together with range() to create a for loop. This function returns the length of an object. The argument must be a sequence or a collection.
-
-tickers = ['AAPL', 'GOOGL', 'IBM', 'FB', 'F', 'V', 'G', 'GE']
-print "The number of tickers is {}".format(len(tickers))
-for k in range(len(tickers)):
- print k + 1, tickers[k]
-[out]:
-The number of tickers is 8
-1 AAPL
-2 GOOGL
-3 IBM
-4 FB
-5 F
-6 V
-7 G
-8 GE
-
-
-Note: If you want to print only the tickers without those numbers, then simply write "for ticker in tickers: print ticker"
-
-map() is a function that applies a specific function to every item of a sequence or collection, and returns a list of the results.
-
-
-Python is an object-oriented programming language. It's important to understand the concept of "objects" because almost every kind of data from QuantConnect API is an object.
-
-
Class
-A class is a type of data, just like a string, float, or list. When we create an object of that data type, we call it an instance of a class.
-
-In Python, everything is an object - everything is an instance of some class. The data stored inside an object are called attributes, and the functions which are associated with the object are called methods.
-
-For example, as mentioned above, a list is an object of the "list" class, and it has a method list.sort().
-
-We can create our own objects by defining a class. We would do this when it's helpful to group certain functions together. For example, we define a class named "Stock" here:
-
-
-The "Stock" class has attributes "ticker", "open", "close", "volume" and "rate_return". Inside the class body, the first method is called __init__, which is a special method. When we create a new instance of the class, the __init__ method is immediately executed with all the parameters that we pass to the "Stock" object. The purpose of this method is to set up a new "Stock" object using data we have provided.
-
-Here we create two Stock objects named "apple" and "google".
-
-
-By calling the update() function, we updated the open and close prices of a stock. Please note that when we use the attributes or call the methods inside a class, we need to specify them as self.attribute or self.method(), otherwise Python will deem them as global variables and thus raise an error.
-
-We can add an attribute to an object anywhere:
-
-
-Inheritance is a way of arranging classes in a hierarchy from the most general to the most specific. A "child" class is a more specific type of a "parent" class because a child class will inherit all the attribues and methods of its parent. For example, we define a class named "Child" which inherits "Stock":
-
class Child(Stock):
- def __init__(self, name):
- self.name = name
-
-
-A NumPy array is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. Here we make an array by passing a list of Apple stock prices:
-
-
-Notice that the type of array is "ndarray" which is a multi-dimensional array. If we pass np.array() a list of lists, it will create a 2-dimensional array.
-
-
-If we want to access the matrix by column instead:
-
print 'First column:', Ar[:,0]
-[out]: First column: [1 2]
-print 'Second column:', Ar[:,1]
-[out]: Second column: [3 4]
-
-
Array Functions
-
-Some functions built in NumPy that allow us to perform calculations on arrays. For example, we can apply the natural logarithm to each element of an array:
-
-The functions above return the mean, standard deviation, total and maximum value of an array.
-
-
Pandas
-
-Pandas is one of the most powerful tools for dealing with financial data. First we need to import Pandas:
-
import pandas as pd
-
-
Series
-
-Series is a one-dimensional labeled array capable of holding any data type (integers, strings, float, Python object, etc.)
-
-We create a Series by calling pd.Series(data), where data can be a dictionary, an array or just a scalar value.
-
-
-Series are usually accessed using the iloc[] and loc[] methods. iloc[] is used to access elements by integer index, and loc[] is used to access the index of the series.
-
-iloc[] is necessary when the index of a series are integers, take our previous defined series as example:
-
-
-If we intended to take the second element of the series, we would make a mistake here, because the index are integers. In order to access to the element we want, we use iloc[] here:
-
print s.iloc[1]
-[out]: 145.83
-
-
-While working with time series data, we often use time as the index. Pandas provides us with various methods to access the data by time index.
-
-
-As demonstrated, we can use logical operators like & (and), | (or) and ~ (not) to group multiple conditions.
-
-
Summary
-
-Here we have introduced NumPy and Pandas for scientific computing in Python. In the next chapter, we will dive into Pandas to learn resampling and manipulating Pandas DataFrame, which are commonly used in financial data analysis.
\ No newline at end of file
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial06 Rate of Return, Mean and Variance.html b/Tutorial Series/Introduction to Financial Python/Tutorial06 Rate of Return, Mean and Variance.html
deleted file mode 100644
index e1da695..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial06 Rate of Return, Mean and Variance.html
+++ /dev/null
@@ -1,122 +0,0 @@
-
Introduction
-In this chapter we are going to introduce some basic concepts in quantitative finance. We start with rate of return, mean and variance. You may think it's simple to calculate these values, however, there are number of different methods to calculate them. It's important to choose the appropriate calculation methods case by case.
-
Rate of Return
-
Single-period Return
-The single-period rate of return can be calculated as following:
-\[r = \frac{p_t}{p_0} - 1 = \frac{p_t - p_0}{p_0}\]
-Where \(r\) is the rate of return, \(p_t\) is the asset price at time \(t\), and \(p_0\) is the asset price at time 0.
-
-Let's say we bought a stock at $100, and half a year later it will grow to $102. A year later the price will come to $104. How to calculate our total return?
-Well, we can either deem it as a single-period:
-\[r = 104/100 - 1 = 0.04\]
-or as a two-stage period:
-\[ r = (1+r_1)*(1+r_2) - 1 = \frac{102}{100} * \frac{104}{102} -1 = 0.04\]
-Here we make calculations twice a year. It's called semi-annual compounding. How about quarterly compounding?
-Let's assume the stock prices at the end of each quarter are \(p_1, p_2, p_3, p_4\) respectively.
-\[r = (1+r_1)*(1+r_2)*(1+r_3)*(1+r_4) -1\]
-The rate of return we calculate here is called cumulative return or overall return. It measures the total return of this asset over a period of time.
-Now consider the following situation: we have two strategies: strategy A and strategy B. We backtested strategy A for 1 years and the cumulative return is 20%, while we backtested strategy B and the cumulative return is 65%. Which strategy has a high rate of return? Our commonly used method is to convert all the returns into compounding annual return, regardless of the investing horizon of each strategy. We can compare the returns of strategies with different time horizon now!
-\[(1+r)^3 = 1+0.65\]
-\[ r = \sqrt[3]{1.65} - 1\ = 0.18167\]
-Strategy A has an higher compounding annual return!
-
Logarithm Return
-We introduced compounding annual return above, which is a kind of effective rate of return. You can regard it as a 'hypothetical return'. Strategy B might never have a 18.167% rate of rate annually during the 3-year backtesting period. However, if we assume that the strategy has a 18.167% rate of return every year, it has the same cumulative return over the 3 years.
-As we mentioned previously, if we assume a strategy is quarterly compounding, the relation between quarterly effective rate of return and annual return is:
-\[(1+\frac{r}{4})^4 = 1+r\]
-More generally, if the times of compounding in one year is \(n\) and the annual rate of return is \(r\), the relation is given by:
-\[(1+\frac{r}{n})^n = 1+r\]
-Now imagine the stock markets. The prices of your assets is changing every second, or even every millisecond. If the times of compounding, or n, approach to infinite, this is called continuous compounding. The calculation formula is given below:
-\[\lim_{n \to \infty }(1+\frac{r}{n})^n = e^r\]
-From the above limitation equation, we know that if we assume continuous compounding:
-\[e^r = 1 + r = \frac{p_t}{p_0}\]
-Then we take \(ln\) on both side of the equation:
-\[r = ln\frac{p_t}{p_0} = lnp_t - lnp_0\]
-Here we got the logarithmic return, or continuously compounded return.
-This is frequently used when calculating returns, because once we take logarithm of asset prices, we can calculate the logarithm return by simply doing a subtraction. Here we use Apple stock prices as a example:
-
-
-Here we calculated the daily logarithmic return of Apple stock. Given that we know the daily logarithm return of in this month, we can calculate the monthly return by simply sum all the daily returns up.
-
-It may sounds incorrect to sum up the daily returns, but we can prove that it's mathematically correct. Let's assume the stock prices in a period of time are represented by \([p_0, p_1, p_2, p_3.....p_n]\). Then the cumulative rate of return is given by:
-\[1+r = ln\frac{p_t}{p_0} = ln\frac{p_t}{p_{t-1}} + ln\frac{p_{t-1}}{p_{t-2}}+......+ln\frac{p_1}{p_0}\]
-According to the equation above, we can simple sum up each logarithmic return in a period to get the cumulative return. The convenience of this method is also one of the reasons why we use logarithmic return in quantitative finance.
-
Mean
-
Arithmetic Mean
-Mean is a measure of the central tendency of a data series. It capture the key character of the distribution of the data series. When we talk about mean, by default it refers to arithmetic mean. It's defined as the sum of the values divided by the number of observations:
-\[\mu = \frac{\sum_{i = 1}^{n}x_i}{n}\]
-Where \((x_1,x_2,x_3.....x_n)\) is our data series.
-In python we can use NumPy.mean() to do the calculation:
-
-The geometric mean is an average that is useful for data series of positive numbers that are better interpreted according to their product, such as growth rate. It's calculated by:
-\[\bar{x} = \sqrt[n]{x_1x_2x_3...x_n}\]
-Let's calculate the geometric mean of a series of single-period return:
-\[1+\bar{r} = \sqrt[n]{\frac{p_t}{p_{t-1}}*\frac{p_{t-1}}{p_{t-2}}*...*\frac{p_2}{p_1}}\]
-\[(1+\bar{r}) = \sqrt[n]{\frac{p_t}{p_0}}\]
-Now the equation becomes the form which we are familiar with:
-\[(1+\bar{r})^n = \frac{p_t}{p_0}\]
-This is why we said it make sense when applied to growth rates.
-
Variance and Standard Deviation
-
Variance
-Variance is a measure of dispersion. In finance, most of the time variance is a synonym for risk. The higher the variance of an asset price is, the higher risk the asset bears. Variance is usually represented by \(\sigma\), and it's calculated by
-\[\sigma^2 = \frac{\sum_{i = 1}^{n}(x_i- \mu)^2}{n}\]
-In python we can use NumPy.var to calculate it:
-
print np.var(aapl.log_price)
-
-
Standard Deviation
-The most commonly used measure of dispersion in finance is standard deviation. It's usually represented by \(\sigma\). It's obvious to see the relation between standard deviation and variance:
-\[\sigma = \sqrt{\sigma^2} = \sqrt{\frac{\sum_{i = 1}^{n}(x_i- \mu)^2}{n}}\]
-NumPy also provides us a method to calculate standard deviation.
-
-We introduced different types of rate of return in this chapter, which could be a little bit tricky when we calculate them. Mean and standard deviation are also very important concepts when we conduct hypothesis test or measure the risk associated with a asset. We will use those comcepts intensively in our later chapter.
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial07 Random Variables and Distributions.html b/Tutorial Series/Introduction to Financial Python/Tutorial07 Random Variables and Distributions.html
deleted file mode 100644
index 8b10dee..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial07 Random Variables and Distributions.html
+++ /dev/null
@@ -1,167 +0,0 @@
-
Introduction
-In the last chapter we learned the definition of mean and variance, which are kind of point estimation. Point estimation means using sample data to calculate a single value which is to serve as a 'best estimation' of an unknown population. However, this it not enough because point estimations can be deceiving. We need to use more rigorous methods to test our ideas. That's why we consider distribution and hypothesis testing. Random variable distribution is the basis for almost all quantitative finance topics: linear regression, CAPM, Black-Scholes, binomial tree pricing, etc.
-
Random Variables
-First let's start with the concept of random variable. A random variable can be thought of as a drawing from a distribution whose outcome prior to the draw is uncertain. Imaging rolling a dice, you know that your chance of getting each is 1/6, but you don't know what's the number of your next roll is. If we roll the dice N times and record the number of each roll, a collection of those numbers is called discrete random variable. A discrete variable can take on a finite number of values. For our example, we can only take numbers from{1,2,3,4,5,6}.
-The other kind of variable is continuous random variable. A continuous variable can take on any value in a given range. You can think the rate of return as a continuous variable, it theoretically can take any value from \((-\infty, +\infty)\).
-
Distributions
-Each random variable follows a probability distribution, which is a function that can be thought of as providing the probabilities of occurrence of different possible outcomes in an experiment. In our dice example, the probability distribution of each number is 1/6. We usually use \(P(X)\) to represents probability distribution function, where X is the outcome value. In our example, \(P(1) = P(2) = p(3) = 1/6\).
-However, we can't use this for a continuous distribution, because the the probability that draw a specific number from a continuous variable is 0, due to the infinity possible outcomes we have. Instead, we use probability density function(PDF) function to describe the probability that a value is in a specific range. We we cover this later.
-For each probability distribution function, we have a cumulative distribution function(CDF). It defines as \(P(X<x)\), which models the probability that the random variable X will take a value less than or equal to x. For discrete random variables, we just sum up the values less than or equal to x and then divide it with number of observations.
-
Uniform Distribution
-Uniform distribution is the simplest type of probability distribution. A discrete uniform distribution has equal weight assigned to all outcomes. Both rolling a dice and toss a fare coin are classical uniform distributions.
-Here we use python to simulate rolling a dice 10000 times.
-
import random
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-#define a function to simulate rolling a dice
-def dice():
- number= [1,2,3,4,5,6]
- return random.choice(number)
-
-series = np.array([dice() for x in range(10000)])
-print series
-
-We create a series of random variable here. We can plot the values on the x-axis and put their number of occurrences on the y-axis to have a direct view of the distribution:
-
-
-Let's say we want to know the frequency that the observations are less than or equal to 3. In other words we want to seek the value of \(P(X<3)\).
-
print len([x for x in series if x <= 3])/float(len(series))
-[out]: 0.4956
-print np.mean(series)
-[out]: 3.5103
-
-\(P(X<3)\) is very close to 0.5. This is not surprising because we rolled the dice 1000 times, and the frequency that the observations less than or equal to 3 should be close to the real probability, which is 0.5.
-For a given uniform distribution, it's straightforward to calculate it's mean: it's the center of the distribution because everyone outcome is equal weight. For our dice example, we can think it as
-\[\mu = (1+2+3+4+5+6)/6 = 3.5\]
-Or
-\[E(x) = 1*\frac{1}{6} + 2*\frac{1}{6}+...+6*\frac{1}{6} = 3.5\]
-More generally, if we a assume the minimum value in a uniform distribution is a and the maximum value is b, the mean can be given by:
-\[\bar{u} = \frac{a+b}{2}\]
-Usually we use \(\bar{u}\) to represents the population mean, or the 'real mean'. Here we create a sample with 1000 observations, the mean we calculated above is the sample mean. Sample mean usually doesn't equal to the theoretical population mean unless the number of observation approaches to infinity.
-The variance is given by:
-\[\sigma^2 = \frac{(b-a)^2}{12}\]
-Deducing the formula is out of our lecture scope. It's useful to realize for a given standard distribution, we can formularize its mean and variance.
-
Binomial Distribution
-A binomial distribution is a discrete probability distribution of the number of successes in a sequence of n independent experiments. Let's assume that the market has 50% probability goes up and 50% probability goes down, and we observe it in the next 10 days, what's the distribution of the number of days it goes up? This is a binomial distribution example.
-In general, if we carry out the experiment n times, and each outcome is independent, with the same probability of success p, the probability of getting exactly k successes is given by the function:
-\[P(X = K) = C_n^k p^k (1-p)^{n-k}\]
-Where
-\[C_n^k = \frac{n!}{(n-k)!k!}\]
-Under such circumstance we say X follows the binomial distribution \(X \sim B(n,p)\).
-Let's simulate a binomial experiment with success rate p = 0.7 and experiment times n = 10
-
def trial():
- number = [1,2,3,4,5,6,7,8,9,10]
- a = random.choice(number)
- if a<= 7:
- return 1
- else:
- return 0
-
-Each time we execute trial(), we did an experiment. If it succeed, it will return 1, otherwise it will return 0. Now we are going to do the experiment 10 times:
-
res = [trial() for x in range(10)]
-print sum(res)
-[out]: 7
-
-Now we did the experiment 10 times, and the number of success is sum(res). However, it just means during these 10 experiments we succeed sum(res) times. If we want to see the binomial distribution, we need experiment N times. When n is large enough, our frequency will approach the theoretical probability. Here we simulate each outcome 10000 times:
-
def binomial(number):
- l = []
- for i in range(10000):
- res = [trial() for x in range(10)]
- l.append(sum(res))
- return len([x for x in l if x == number])/float(len(l))
-
-print binomial(8)
-[out]: 0.2367
-
-The number printed above is the simulated probability that we succeed 8 times if we experiment 10 times.
-for each possible outcome, we simulate the probability:
-
-Here we got the simulated result of the binomial distribution. Now we are going to check if the simulated frequencies close enough to the theoretical probabilities. Let's take X = 7 and X = 8 as example:
-
-
-Another good property of binomial distribution is that its mean and variance are simple enough:
-\[\bar{u} = np\]
-\[\sigma^2 = np(1-P)\]
-We will not introduce the deduction here, but if you are interested in it, we encourage you to do it yourself, based on the probability functions we provided above.
-
Normal Distribution
-Before looking at normal distribution, let's first talk about continues distribution. As we mentioned above, we use a probability density function(PDF) to model the probability that our value is taken our a specific range. We define it as:
-\[P(a<X<b) = \int_{a}^{b}f_x(x)dx\]
-Now we can talk about the normal distribution. The normal distribution is most commonly used distribution in natural sciences, of course also in financial research. The PDF of normal distribution is given as follows:
-\[f(x) = \frac{1}{\sqrt{2\pi\sigma^2}}e^{-\frac{(x-\mu)^2}{2\sigma^2}}\]
-Where \(\mu\) is the mean of the normal distribution, and \(\sigma\) is the standard deviation.
-Generally, if a random variable X follows normal distribution, we represent it by \(X\sim N(\mu, \sigma^2)\).
-Specifically, if a normal distribution has a 0 mean and 1 standard deviation, we called it standard normal distribution.
-Now let's simulate a standard normal distribution using Python packages to see what it looks like:
-
-
-Financial data is highly disordered and is considered to has lots of noise. Most of the time we believe those noise follows normal distribution. It's also widely believed that the return on an asset over a short period of time follows normal distribution. Let's check it with the daily logarithm rates of return on SPY:
-
-we calculated the logarithm daily return of S&P 500 index from 2009 to present.
-Let's first have a look at the what the time-series return data looks like:
-
-
-If we observe the x-axis and y-axis carefully, we can see the return of asset is not a standard normal distribution. The peak of the standard normal distribution plot is around 0.4, while it's over 0.6 for this chart. This is because the standard deviation \(\sigma\) of the return is obviously not 1.
-We can demonstrate the normal distribution with different mean and variance by simulation:
-
-In this chapter we introduced random variable, the difference between discrete random distribution and continuous random distribution, and most importantly, normal distribution. In the next chapter we will introduce how to use these distributions to test our idea or generating trading signals.
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial08 Confidence Interval and Hypothesis Testing.html b/Tutorial Series/Introduction to Financial Python/Tutorial08 Confidence Interval and Hypothesis Testing.html
deleted file mode 100644
index c9c23cc..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial08 Confidence Interval and Hypothesis Testing.html
+++ /dev/null
@@ -1,134 +0,0 @@
-
Introduction
-In the last chapter we discussed random variables and random distributions. Now we are going to use the distributions we learned to test our hypothesis and also to model the financial data. When building a trading strategy, it's essential to do some research. However, you won't be able to test your idea using all the data, because it's infinity. You can only use a sample to do your experiment. That's why we need to understand the difference between population and sample, and then use confidence interval to test our hypothesis.
-
-As we mentioned before, both mean and standard deviation are point estimation, and they can be deceiving because sample means are different from population means. Financial data is generated every day now and in the future, thus even though we can use all the data available, it's still just a sample. This is why we need to use confidence interval to attempt to determine how accurate our sample mean estimation is.
-
Confidence Interval
-
Sample Error
-Let's use the daily return on S&P 500 index from Aug 2010 to present is our population. If we take the recent 10 daily returns to calculate the mean, will it be the same as the population mean? How about increasing the sample size to 1000?
-
import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import quandl
-quandl.ApiConfig.api_key = 'tAyfv1zpWnyhmDsp91yv'
-#get data from quandl
-spy_table = quandl.get('BCIW/_SPXT')
-spy_total = spy_table[['Open','Close']]
-#calculate log returns
-spy_log_return = np.log(spy_total.Close).diff().dropna()
-print 'Population mean:', np.mean(spy_log_return)
-[out]: Population mean: 0.000443353825615
-print 'Population standard deviation:',np.std(spy_log_return)
-[out]: Population standard deviation: 0.00784267293815
-
-Now let's check the recent 10 days sample and recent 1000 days sample:
-
-print '10 days sample returns:', np.mean(spy_log_return.tail(10))
-[out]: 10 days sample returns: 0.000845189915474
-print '10 days sample standard deviation:', np.std(spy_log_return.tail(10))
-[out]: 10 days sample standard deviation: 0.00313558001122
-print '1000 days sample returns:', np.mean(spy_log_return.tail(1000))
-[out]: 1000 days sample returns: 0.000462827047221
-print '1000 days sample standard deviation:', np.std(spy_log_return.tail(1000))
-[out]: 1000 days sample standard deviation: 0.00766589174299
-
-As we expected, the two samples has different means and variances.
-
Confidence Interval
-In order to estimate the range of population mean, we define standard error of the mean as follows:
-\[SE = \frac{\sigma}{\sqrt{n}}\]
-Where \(\sigma \) is the sample standard deviation and \(n\) is the sample size.
-Generally, if we want to estimate an interval of the population so that 95% of the time the interval will contain the population mean, the interval is calculated as:
-\[(\mu - 1.96*SE, \mu + 1.96*SE)\]
-Where \(\mu\) is the sample mean and SE is the standard error.
-This interval is called confidence interval. We usually use 1.96 to calculate a 95% confidence interval because we assume that the sample mean follows normal distribution. We will cover this in detail later.
-Let's try to calculate the confidence interval using the samples above:
-
-#apply the formula above to calculate confidence interval
-bottom_1 = np.mean(spy_log_return.tail(10))-1.96*np.std(spy_log_return.tail(10))/(np.sqrt(len((spy_log_return.tail(10)))))
-upper_1 = np.mean(spy_log_return.tail(10))+1.96*np.std(spy_log_return.tail(10))/(np.sqrt(len((spy_log_return.tail(10)))))
-bottom_2 = np.mean(spy_log_return.tail(1000))-1.96*np.std(spy_log_return.tail(1000))/(np.sqrt(len((spy_log_return.tail(1000)))))
-upper_2 = np.mean(spy_log_return.tail(1000))+1.96*np.std(spy_log_return.tail(1000))/(np.sqrt(len((spy_log_return.tail(1000)))))
-#print the outcomes
-print '10 days 95% confidence inverval:', (bottom_1,upper_1)
-[out]: 10 days 95% confidence inverval: (-0.0010982627102681939, 0.002788642541217079)
-print '1000 days 95% confidence inverval:', (bottom_2,upper_2)
-[out]: 1000 days 95% confidence inverval: (-1.230984558013321e-05, 0.00093796394002165957)
-
-As we can see, the 95% confidence interval became much narrower if we increase the sample size from 10 to 1000. Imagine that if N goes positive infinite, then we have \(\lim_{n\rightarrow \infty}\frac{\sigma}{\sqrt{n}} = 0\). The confidence interval would become a certain value, which is the sample mean!
-
Confidence Interval of Normal Distribution
-Normal Distribution is so commonly used that we should be able to remember some critical values of it. Specifically, we usually use 90%, 95% and 99% as the confidence level of a confidence interval. The critical values for these three confidence levels are 1.64, 1.96, and 2.32 respectively. in other words:
-\[\%90 upperabnd = \mu + 1.64*SE\]
-\[\%90 lowerband = \mu + 1.64*SE\]
-The same for other confidence intervals.
-It's also important to remember the famous 'Three sigma rule' or '68-95-99.7' rule associated with normal distribution. This is used to remember the confidence level of the intervals with a width of two, four and six standard deviation. Mathematically:
-\[P(\mu - \sigma \leq X \leq \mu+\sigma)\approx 0.6827\]
-\[P(\mu - 2\sigma \leq X \leq \mu+2\sigma)\approx 0.9545\]
-\[P(\mu - 3\sigma \leq X \leq \mu+3\sigma)\approx 0.9973\]
-This can also be remembered by using the chart:
-
-
Central Limit Theory
-As we mentioned, if we use the sample to estimate the confidence interval of the population, the 95% confidence interval is:
-\[(\mu - 1.96*SE, \mu + 1.96*SE)\]
-Now you may have some sense to the number 1.96. It's the 95% critical value of a normal distribution. Does this means we assume the mean of sample follows a normal distribution?
-The answer is yes. This assumption is supported by central limit theorem. This theorem tells us that given a sufficiently large sample size from a population with a finite level of variance, the mean of all samples from the same population will be approximately equal to the mean of the population, and the means of the samples will be approximately normal distributed.
-This is the foundation of population mean confidence interval estimation.
-
Hypothesis testing
-Now we can talk about hypothesis testing. Hypothesis test is essentially test your inference based on a sample. Let's use our dataset, the daily return of S&P 500 us our population. Assume that we don't know the mean of this population. I guess that the mean of this population is 0. Is my guess correct? I need to test this hypothesis with my sample.
-Let's start from observing our sample:
-
-We know how to calculate the confidence interval now. If I were right, i.e. the population mean is 0, then the 90% confidence interval of the sample with 1000 observations should be:
-
-Our mean of the sample is out of the 90% confidence interval. This means on a 90% confidence level, we can claim that the mean of our population is not 0. In other word, we rejected the hypothesis that the daily return on S&P500 from aug 2010 is zero.
-Can we claim that with 95% confidence level?
-
-This time the sample mean is within the confidence interval. Thus we can't reject my hypothesis. In other words, we can't claim with 95% confidence level that the mean return is positive. Even though we can claim it with 90% confidence level.
-We have actually already finished a hypothesis testing above! In general, we have null hypothesis \(H_0\) and alternative hypothesis. They are usually in the following forms:
-\[H_0:\bar{\mu} = 0\]
-\[H_0:\bar{\mu} \neq 0\]
-If the tested value is outside the confidence interval, we reject the null hypothesis, or accept the alternative hypothesis; If the tested value is within the confidence interval, we can't reject the null hypothesis.
-Although the hypothesis testing method we used above is straightforward, it's not so convenient to implement. Instead, we reverse the process to calculate the critical value, or Z-score. Z-score is defined as:
-\[Z = \frac{X - \mu}{\frac{\sigma}{\sqrt{n}}}\]
-Let's calculate the Z score from our sample:
-
-We know that the critical value for the 90% confidence level is 1.64 and that for the 95% confidence level is 95%. The higher the Z score is, the further the tested value is from the hypothesized value(which is 0 in this example). Thus with 90% confidence level, we are far away enough from zero and we reject the null hypothesis. However with 95% confidence level, we are not far away enough from zero, so we can't reject the null hypothesis.
-one reason of doing in this way is that we can know how wide our confidence interval is. In our example, the z-score is 1.8488. We can know the width is the confidence interval referring to a normal distribution table. Of course we can do this in Python:
-
import scipy.stats as st
-print (1 - st.norm.cdf(1.9488))
-[out]: 0.025659656888
-
-It's worth noting that st.norm.cdf will return the probability that a value take from the distribution is less than our tested value. In other words, 1 - st.norm.cdf(1.9488) will return the probability that the value is greater than our tested value, which is 0.025659 in this example. This calculated number is called p-value. If our confidence level our confidence interval is 95%, then we have 2.5% on the left side and 2.5% on the right side. This is called two-tail test. If our null hypothesis is \(\mu = 0\), we are conducting two-tail test because the tested sample mean can be either positive enough or negative enough to reject the null hypothesis. We can see it from the chart:
-
-If we use 95% confidence interval, we need a p-value less than 0.025 to reject the null hypothesis. However, now our p-value is 0.025659, which is greater than 0.025, thus we can't reject the null hypothesis. It's obviously less than 0.05, so we can still reject the null hypothesis with 90% confidence level.
-Now let's test the hypothesis that population mean = 0 again with a large sample, which has 1200 observations:
-
-Using the a larger sample, now we can reject the null hypothesis with a higher confidence interval! our p-value is 0.0105, and it's a two-tail test, so our confidence level of the interval is 1-(0.0105*2) = 0.979. We can say at most with 97.9% confidence interval, we can claim that the population mean is not zero. We already know that the population mean is not 0. As our sample size increasing, the accurate rate of our hypothesis goes up.
-
Summary
-In this chapter we introduced confidence interval, especially that for the normal distribution, and hypothesis test. Now we know how to test our idea rigorously. Normal distribution and it's confidence interval can be applied to many quantitative finance theories, we will see it frequently in our following tutorials.
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial09 Simple Linear Regression.html b/Tutorial Series/Introduction to Financial Python/Tutorial09 Simple Linear Regression.html
deleted file mode 100644
index d53dd0e..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial09 Simple Linear Regression.html
+++ /dev/null
@@ -1,126 +0,0 @@
-
Introduction
-In finance and economics filed, most of the models are linear ones. We can see linear regression everywhere, from the foundation of the model portfolio theory to the nowadays popular Fama-French asset pricing model. It's very important to understand how linear regression works in order to have a comprehensive understanding of those theories.
-
-If we are holding a stock, we must be curious about the relationship between our stock return and the market return. Let's say we hold Amazon stock on the first day of this year. In order to see the relation directly, we plot the daily return of our stock on the y-axis and plot the S&P 500 index daily return on the x-axis.
-
import numpy as np
-import pandas as pd
-import quandl
-quandl.ApiConfig.api_key = '_fgkxjSbt5389zGt4crC'
-#get data from quandl
-spy_table = quandl.get('BCIW/_SPXT')
-amzn_table = quandl.get('WIKI/AMZN')
-#fetch data from Jan 2017 to Jun 2017
-spy = spy_table.loc['2017':'2017-6',['Close']]
-amzn = amzn_table.loc['2017':'2017-6',['Close']]
-#calculate log return
-spy_log = np.log(spy.Close).diff().dropna()
-amzn_log = np.log(amzn.Close).diff().dropna()
-df = pd.concat([spy_log,amzn_log],axis = 1).dropna()
-df.columns = ['spx','amzn']
-print df.tail()
-
-
-
-
-
spy
-
amzn
-
-
-
2016-12-22
-
-0.004462
-
-0.005543
-
-
-
2016-12-23
-
0.001372
-
-0.007531
-
-
-
2016-12-23
-
0.000928
-
0.000946
-
-
-
2016-12-23
-
-0.005671
-
-0.009081
-
-
-
2016-12-23
-
0.002086
-
-0.020172
-
-
-
-We successfully create a DataFrame contains the daily logarithm return of Amazon stock and S&P500. Now let's plot it:
-
import matplotlib.pyplot as plt
-plt.figure(figsize = (15,10))
-plt.scatter(df.spy,df.amzn)
-plt.show()
-
-
-The plot is scattered, but we can see they are approximately correlated: generally the higher SPX's daily return is, the higher Amazon stock's return is. This is called positively correlated. We will cover it in the following tutorials.
-
Slope and Intercept
-It's natural that we want to model the relation between these two rates of return. Intuitively we use a straight line to model it, this is called Linear Regression. In order to find the best straight line, it's natural to think that the vertical distances between the points of the data set and the fitted line should be minimized. Those vertical distances are called residual. Our objective is to make the sum of squared residuals as small as possible. This method is called ordinary least square, or OLS method.
-We use x and y to represent the two variable, S&P 500 daily returns and AMZN daily returns. The linear relation is:
-\[Y = Y = \alpha + \beta*X + \epsilon\]
-Where \(\alpha\) is called intercept, \(\beta\) is called slope.
-Generally, if the scatter points can be represented by\(\left\{\right (x_1,y_1),(x_2, y_2),(x_3,y_3)...(x_n,y_n) \left\}\right\), then the intercept and slope are given by:
-\[\beta = \frac{\sum_{i=1}^{n}(x-\bar{x})(y-\bar{y})}{\sum_{i=1}^{n}(x-\bar{x})^2}\]
-\[\alpha = \bar{y} - \hat{\beta}\bar{x}\]
-Where \(\bar{x}\) is the mean of X, \(\bar{y}\) is the mean of Y.
-In python, we don't need to do the above calculation manually because we have package for it. But it still very important to understand the calculation process of \(\beta\) in order the understand the modern portfolio theory and CAPM, which we will cover in the future.
-
Python Implementation
-In python, we have a very power package for mathematical models, which is named 'statsmodels'.
-
import statsmodels.formula.api as sm
-model = sm.ols(formula = 'amzn~spy',data = df).fit()
-print model.summary()
-
-
-We built a simple linear regression model above by using the ols() function in statsmodels. The 'model' instance has lots of properties. The most commonly used one is parameters, or slope and intercept. We can access to them by:
-
-
-The red line is the fitted linear regression straight line.
-As we can see there are lot of statistical results in the summary table. Now let's talk about some important statistical parameters.
-
Parameter Significance
-From the summary table we can see 'std err'. This means standard errors of the intercept and slope. The null hypothesis here is \(H_0: \beta = 0\), and the alternative hypothesis is \(H_1: \beta \neq 0\). This hypothesis score is calculated by:
-\[t = \frac{\beta - 0}{SE}\]
-Where SE is given by:
-\[SE = \sqrt\frac{\frac{1}{n-2}\sum_{i = 1}^{n}\hat{\epsilon}^2}{\sum_{i = i}^{n}(x_i - \bar{x})^2}\]
-The distribution used here is 'Student's t-distribution'. It's different from normal distribution but used in the similar way. The column 't' in this table is the test score, and 'p>|t|' is the p-value. By observing the p-value, we can see that the significance level of spy, or the slope, is very high because the p-value is close to zero. In other words, we have 99.999 confidence to claim that the slope is not 0, and there exists linear relation between X and Y. However, regarding the intercept, the p-value is 0.923, which means we have only 7.7% confidence level that the value of intercept is not 0. We can also see from the plot that the line crosses the origin.
-The following 2 columns are the lower band and upper band of the parameters at 95% confidence interval. At 95% confidence level, we can claim that the true value of the parameter is within this range.
-
Model Significance
-
R-square
-Sum of Squared Errors, or SSE, is used to measure the difference between the fitted value and the actual value. It's given by:
-\[SSE = \sum_{i=1}^{n}(y_i - \hat{y_i})^2 = \sum_{i = 1}^{n}\hat{\epsilon_i}^2\]
-If the linear model perfectly fitted the sample, the SSE would be zero.
-The reason we use squared error here is that the positive and negative errors would offset each other if we simply summed them up.
-Another measurement of the dispersion of the sample is called total sum of squares, or SS.. it's given by:
-\[SS = \sum_{i = i}^{n}(y_i - \bar{y}_i)^2\]
-If you are familiar with variance, we can see that SS divided by the number of sample n is the sample variance.
-From SSE and SS, we can calculate the Coefficient of Determination, or r-square for short. R-square means the proportion of variation that 'explained' by the linear relationship between X and Y, it's calculated by:
-\[r^2 =1 = \frac{SSE}{SS} =1 - \frac{\sum_{i=1}^{n}(y_i - \hat{y_i})^2}{\sum_{i = i}^{n}(y_i - \bar{y}_i)^2}\]
-Let's assume that the model perfectly fitted the sample, which means all of the sample points lie on the straight line. Then the SSE would become zero, and the r-square would become 1. This means perfect fitness. The higher r-square is, the more parts of variation can be explained by the linear relation, the higher significance level the model is.
-Some other parameters, such as F-statistic, AIC and BIC, are related to multiple linear regression, with would be cover in the next chapter.
-
Summary
-In this chapter we introduced how to implement simple linear in python, and focused on how to read the summary table. In next chapter we will introduced multiple linear regression, which are commonly used to built models in finance and economics.
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial09 Simple Linear Regression.ipynb b/Tutorial Series/Introduction to Financial Python/Tutorial09 Simple Linear Regression.ipynb
deleted file mode 100644
index 345940d..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial09 Simple Linear Regression.ipynb
+++ /dev/null
@@ -1,245 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "import pandas as pd\n",
- "import quandl\n",
- "spy_table = quandl.get('LSE/SPY5')\n",
- "amzn_table = quandl.get('WIKI/AMZN')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [],
- "source": [
- "spy = spy_table.loc['2016',['Last Close']]\n",
- "amzn = amzn_table.loc['2016',['Close']]\n",
- "spy_log = np.log(spy['Last Close']).diff().dropna()\n",
- "amzn_log = np.log(amzn.Close).diff().dropna()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "
-
-In the last chapter we used the S&P 500 index to predict Amazon stock returns. Now we will add more variables to improve our model's predictions. In particular, we shall consider Amazon's competitors.
-
-
import numpy as np
-import pandas as pd
-import quandl
-import matplotlib.pyplot as plt
-import statsmodels.formula.api as sm
-
-# Get stock prices
-quandl.ApiConfig.api_key = 'tAyfv1zpWnyhmDsp91yv'
-spy_table = quandl.get('BCIW/_SPXT')
-amzn_table = quandl.get('WIKI/AMZN')
-ebay_table = quandl.get('WIKI/EBAY')
-wal_table = quandl.get('WIKI/WMT')
-aapl_table = quandl.get('WIKI/AAPL')
-
-Then we fetch closing prices starting from 2016:
-
-
-
-Similarly, we can build a multiple linear regression model:
-
-
model = sm.ols(formula = 'amzn ~ spy + ebay + wal', data = df).fit()
-print model.summary()
-
-
-
-
-
-
coef
-
std err
-
t
-
P>|t|
-
[0.025
-
0.975]
-
-
-
Intercept
-
0.0001
-
0.001
-
0.134
-
0.894
-
-0.002
-
0.002
-
-
-
spy
-
1.0468
-
0.170
-
6.155
-
0.000
-
0.712
-
1.382
-
-
-
ebay
-
-0.0795
-
0.058
-
-1.364
-
0.174
-
-0.194
-
0.035
-
-
-
wal
-
-0.0865
-
0.089
-
-0.976
-
0.330
-
-0.261
-
0.088
-
-
-
aapl
-
0.1529
-
0.084
-
1.831
-
0.068
-
-0.012
-
0.317
-
-
-
-As seen from the summary table, the p-values for Ebay, Walmart and Apple are 0.174, 0.330 and 0.068 respectively, so none of them are significant at a 95% confidence level.
-
-The multiple regression model has a higher \( R^2 \) than the simple one: 0.254 vs 0.234. Indeed, \( R^2 \) cannot decrease as the number of variables increases. Why? If an extra variable is added to our regression model, but it cannot account for variations in the response (amzn), then its estimated coefficient will simply be zero. It's as though that variable was never included in the model, so \( R^2 \) will not change.
-
-However, it is not always better to add hundreds of variables or we will overfit our model. We'll talk about this in a later chapter.
-
-Can we improve our model further? Here we try the Fama-French 5-factor model, which is an important model in asset pricing theory. We will cover it in the later tutorials.
-
-The data needed are publicly available on French's website.[ref]mba.tuck.dartmouth.edu/pages/faculty/ken.french/Data_Library/f-f_factors.html[/ref] We have saved a copy for convenience. The following code fetches the data.
-
-
-import urllib2
-from datetime import datetime
-
-url = 'https://www.quantconnect.com/tutorials/wp-content/uploads/2017/08/F-F_Research_Data_5_Factors_2x3_daily.csv'
-response = urllib2.urlopen(url)
-fama_table = pd.read_csv(response)
-
-# Convert time column into index
-fama_table.index = [datetime.strptime(str(x), "%Y%m%d")
- for x in fama_table.iloc[:,0]]
-# Remove time column
-fama_table = fama_table.iloc[:,1:]
-
-
-With the data, we can construct a Fama-French factor model:
-
-
-
-
-
-The Fama-French 5-factor model has a higher \( R^2 \) of 0.387. We can compare the predictions from simple linear regression and Fama-French multiple regression by plotting them together on one chart:
-
-
-
-
-
-Although it's hard to see from the chart above, the predicted return from multiple regression is closer to the actual return. Usually we don't plot the predictions to determine which model is better; we read the summary table.
-
-
Model Significance Test
-
-Instead of using \( R^2 \) to assess whether our regression model is a good fit to the data, we can perform a hypothesis test: the F test.
-
-The null and alternative hypotheses of an F test are:
-\[ H_0: \beta_1 = \beta_2 = \dots = \beta_p = 0 \]
-\[ H_1: \text{At least one coefficient is not 0} \]
-
-We won't explain F test procedure in detail here. You just need to understand the null and alternative hypotheses. In the summary table of an F test, the 'F-statistic' is the F score, while 'prob (F-statistic)' is the p-value. Performing this test on the Fama-French model, we get a p-value of `2.21e-24` so we are almost certain that at least one of the coefficient is not 0.
-
-If the p-value is larger than 0.05, you should consider rebuilding your model with other independent variables.
-
-In simple linear regression, an F test is equivalent to a t test on the slope, so their p-values will be the same.
-
-
Residual Analysis
-
-Linear regression requires that the predictors and response have a linear relationship. This assumption holds if the residuals are zero on average, no matter what values the predictors \( X_1, \dots, X_p \) take.
-
-Often it's also assumed that the residuals are independent and normally distributed with the same variance (homoskedasticity), so that we can contruct prediction intervals, for example.
-
-To check whether these assumptions hold, we need to analyse the residuals. In statistical arbitrage, residual analysis can also be used to generate signals.
-
-
Normality
-
-The residuals of a linear model usually has a normal distribution. We can plot the residual's density to check for normality:
-
-
plt.figure()
-#ols.fit().model is a method to access to the residual.
-fama_model.resid.plot.density()
-plt.show()
-
-
-
-
-As seen from the plot, the residual is normally distributed. By the way, the residual mean is always zero, up to machine precision:
-
-
-
-This word is difficult to pronounce but not difficult to understand. It means that the residuals have the same variance for all values of X. Otherwise we say that 'heteroskedasticity' is detected.
-
-
-
-
-
-As seen from the chart, the residuals' variance doesn't increase with X. The three outliers do not change our conclusion. Although we can plot the residuals for simple regression, we can't do this for multiple regression, so we use statsmodels to test for heteroskedasticity:
-
-
from statsmodels.stats import diagnostic as dia
-het = dia.het_breuschpagan(fama_model.resid,fama_df[['MKT','SMB','HML','RMW','CMA']][1:])
-print 'p-value: ', het[-1]
-[out]:p-value of Heteroskedasticity: 0.144075842844
-
-
-No heteroskedasticity is detected at the 95% significance level.
-
-
Summary
-
-In this chapter we have introduced multiple linear regression, F test and residual analysis, which are the fundamentals of linear models. In the next chapter we will introduce some linear algebra, which are used in modern portfolio theory and CAPM.
\ No newline at end of file
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial10 Multiple Linear Regression.ipynb b/Tutorial Series/Introduction to Financial Python/Tutorial10 Multiple Linear Regression.ipynb
deleted file mode 100644
index 8b76b24..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial10 Multiple Linear Regression.ipynb
+++ /dev/null
@@ -1,716 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "import pandas as pd\n",
- "import quandl\n",
- "import matplotlib.pyplot as plt\n",
- "import statsmodels.formula.api as sm"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "quandl.ApiConfig.api_key = 'tAyfv1zpWnyhmDsp91yv'\n",
- "spy_table = quandl.get('BCIW/_SPXT')\n",
- "amzn_table = quandl.get('WIKI/AMZN')\n",
- "ebay_table = quandl.get('WIKI/EBAY')\n",
- "wal_table = quandl.get('WIKI/WMT')\n",
- "aapl_table = quandl.get('WIKI/AAPL')"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "
-
-A vector can be thought of as an arrow pointing from the origin to a specific point. Any vector or point can be represented by its coordinates i.e. an array of numbers, such as \((x,y)\) for a 2-dimensional vector, or \((x,y,z)\) for a 3-dimensional one. We usually write a vector as a column:
-\[ \mathbf{v} = \begin{pmatrix}
-x \\ y \\ z
-\end{pmatrix} \]
-
-The scalar product of two vectors \( \mathbf{x} \) and \( \mathbf{y} \) in 2-dimensional space is defined as:
-\[ \mathbf{x}^T \mathbf{y} = \begin{pmatrix} x_1 & x_2 \end{pmatrix} \begin{pmatrix} y_1 \\ y_2 \end{pmatrix} = x_1 y_1 + x_2 y_2 \]
-
-This definition can be easily generalized to n dimensional space. Clearly, we cannot take the scalar product of two vectors with different dimensions.
-
-
Matrices
-
-If we have a few vectors \( \mathbf{v}_1, \mathbf{v}_2, \dots, \mathbf{v}_n \) with the same dimension, then we can put them side-by-side to form a matrix. For example, the vectors
-\[ v_1 = \begin{pmatrix} 1 \\ 2 \\ 3 \end{pmatrix} \qquad
- v_2 = \begin{pmatrix} 2 \\ 2 \\ 2 \end{pmatrix} \qquad
- v_3 = \begin{pmatrix} 3 \\ 1 \\ 1 \end{pmatrix} \]
-
-can be combined to produce a matrix:
-\[ m = \begin{pmatrix}
-1 & 2 & 3 \\
-2 & 2 & 2 \\
-3 & 1 & 1
-\end{pmatrix} \]
-
-m is a 3 × 3 matrix. We typically describe the dimensions of a matrix as \(m \times n\) where m = number of rows and n = number of columns.
-
-A square matrix is one with as many rows as columns.
-
-Notation: \(x_{ij}\) refers to a specific value in row \(i\) and column \(j\) of a matrix \(X\). For example, \(x_{23}\) is the number in the second row and third column of \(X\).
-
-
Python Implementation
-
-In Python, the NumPy package deals with linear algebra. The array we learned in the NumPy chapter can be deemed as a vector:
-
-
-
-It is worth noticing that we used column_stack() here to ensure that the vectors are vertical and placed side-by-side to form a matrix. Without the column_stack() function, the vectors will be made horizontal and stacked on top of one another:
-
-
-
-Since matrix multiplication is defined in terms of scalar products, the matrix product \(AB\) exists only if \(A\) has as many columns as \(B\) has rows. It's useful to remember this shorthand: (m × n) × (n × p) = (m × p) which means that an (m × n) matrix multiplied by an (n × p) matrix yields an (m × p) matrix.
-
-Reversing the order of multiplication results in an error since B does not have as many columns as A has rows:
-
-
x = np.dot(B,A)
-
-
-A natrual consequence of this fact is that matrix multiplication is not commutative. In other words, \(AB \neq BA\) in general.
-
-
Inverse
-
-An identity matrix is a square matrix with ones on the main diagonal and zeros elsewhere. Here is an \(n \times n\) identity matrix:
-
-\[ I_n = \begin{pmatrix}
- 1 & 0 & 0 & ... & 0 \\
- 0 & 1 & 0 & ... & 0 \\
- 0 & 0 & 1 & ... & 0 \\
- \vdots & \vdots & \vdots & \ddots & \vdots \\
- 0 & 0 & 0 & ... & 1
-\end{pmatrix} \]
-
-Multiplying any matrix by an identity matrix (of the correct shape) is like multiplying a number by 1. Concretely, if \(A\) is an \(m \times n\) matrix, then:
-\[ I_mA = AI_n = A \]
-
-\( A^{-1} \) is the inverse matrix of a square matrix \(A\) if:
-\[ AA^{-1} = I = A^{-1}A \]
-
-Some caveats:
-
-
A rectangular matrix will not have an inverse, but it may have a pseudoinverse (not covered in this tutorial).
-
A square matrix may not have an inverse i.e. it may be "singular".
-
If a square matrix has an inverse, then its inverse is unique.
-
-
-Inverse matrices are computed using the Gauss-Jordan method. In NumPy, we use the linalg.inv() function to do it:
-
-
-
-A common problem in linear algebra is solving linear equations. Consider the following linear equations:
-
-\[ 2x + y - z = 8 \]
-\[ -3x - y + 2z = -11 \]
-\[ -2x + y + 2z = -3 \]
-
-If we let:
-\[ A = \begin{pmatrix}
- 2 & 1 & -1 \\
- -3 & -1 & 2 \\
- -2 & 1 & 2
-\end{pmatrix} \qquad
-\mathbf{x} = \begin{pmatrix} x \\ y \\ z \end{pmatrix} \qquad
-\mathbf{b} = \begin{pmatrix} 8 \\ -11 \\ -3 \end{pmatrix} \]
-
-Then the linear equations above can be written as \( A\mathbf{x} = \mathbf{b} \)
-
-If A is invertible, then we can multiply \(A^{-1}\) on both sides of the equation to obtain the solution:
-\[ A^{-1}A \mathbf{x} = A^{-1}\mathbf{b} \]
-Hence
-\[ \mathbf{x} = A^{-1}\mathbf{b} \]
-
-As long as \(A^{-1}\) exists, we can compute it to solve the linear equations:
-
-
-
-The solution is x = 2, y = 3, z = −1. However, computing the inverse matrix is not recommended, since it is numerically unstable i.e. small rounding errors can dramatically affect the result.
-
-Instead, NumPy solves linear equations by LU decomposition:
-
-
-
-In portfolio theory, the riskiness of an asset is often measured by the variance (or standard deviation) of its returns. Risk-averse investors do not want their wealth to fluctuate wildly.
-
-Risk aversion can be illustrated with a simple example. Which of the following assets do you prefer?
-
-
Asset A pays $200 or $0 with 50% probability each.
-
Asset B pays $400 or −$200 (i.e. you lose $200) with 50% probability each.
-
-
-The expected payouts of A and B are:
-\[ \mathbb{E}(A) = 0.5 \times 200 + 0.5 \times 0 = 100 \]
-\[ \mathbb{E}(B) = 0.5 \times 400 + 0.5 \times (-200) = 100 \]
-
-The standard deviation of their payouts are:
-\[ \sigma_A = \sqrt{0.5(200-100)^2 + 0.5(0-100)^2} = 100 \]
-\[ \sigma_A = \sqrt{0.5(400-100)^2 + 0.5(-200-100)^2} = 300 \]
-
-If you are an risk seeker, you may choose asset B, because you can potentially get a higher payout. MPT assumes that investors prefer asset A since both assets have the same expected payout, but asset A has less risk.
-
-
Portfolio
-
-Suppose we invest some fraction \(w_1, w_2, \dots, w_n\) of our wealth in n risky assets (labelled 1 to n), and the remainder \(w_0\) in a riskless asset such as cash in a bank account.
-
-Clearly \(w_0 + w_1 + \dots + w_n = 1\) since our wealth comprises all those assets.
-
-Let \(R_0, R_1, \dots, R_n\) be the respective asset returns, then our portfolio return is
-\[ R_P = w_0 R_0 + w_1 R_1 + \dots + w_n R_n \]
-
-Alternatively, we can eliminate \(w_0\) to get
-\[ R_P - R_0 = w_1 (R_1 - R_0) + \dots + w_n (R_n - R_0) \]
-
-Our expected portfolio return is
-\[ \mathbb{E}(R_P) = w_0 R_0 + w_1 \mathbb{E}(R_1) + \dots + w_n \mathbb{E}(R_n) \]
-
-Note that \( \mathbb{E}(R_0) = R_0 \) since the riskless return is known with certainty, by definition.
-
-
Correlation
-
-Before computing portfolio risk, we need to first understand covariance and correlation. They measure the linear relationship between two random variables.
-
-The covariance of two random variables X and Y is defined as
-\[ \text{Cov}(X, Y) = \mathbb{E} \left[ (X-\mathbb{E}(X)) (Y-\mathbb{E}(Y)) \right] \]
-
-The correlation of X and Y, which is always between −1 and 1, is their covariance after being standardized:
-\[ \text{Corr}(X, Y) = \text{Cov} \left( \frac{X-\mathbb{E}(X)}{\sigma_X}, \frac{Y-\mathbb{E}(Y)}{\sigma_Y} \right) = \frac{\text{Cov}(X, Y)}{\sigma_X \sigma_Y} \]
-
-
Risk
-
-Now we are ready to compute portfolio risk, as measured by the variance of portfolio returns:
-\[ \text{Var}(R_P) = \text{Var}(w_0 R_0 + w_1 R_1 + \dots + w_n R_n) \]
-
-Recall that \( \text{Var}(X + c) = \text{Var}(X) \) if c is a known constant, so the term \( w_0 R_0 \) involving the riskless return can be omitted. It will be convenient to use sigma notation:
-
-\[ \text{Var}(R_P) = \text{Var} \left( \sum_{k=1}^n w_k R_k \right) \]
-\[ = \mathbb{E} \left[\left( \sum_{k=1}^n w_k R_k - \mathbb{E} \left( \sum_{k=1}^n w_k R_k \right) \right)^2\right] \]
-\[ = \mathbb{E} \left[\left( \sum_{k=1}^n w_k \, \left( R_k - \mathbb{E}(R_k) \right) \right)^2\right] \]
-
-So we have a squared sum of n terms. How do we expand it?
-\[ \left( \sum_{k=1}^n u_k \right)^2 = (u_1 + \dots + u_n) \, (u_1 + \dots + u_n) \]
-
-If we expand the brackets on the right hand side, every term has the form \( u_i u_j \) where i and j can be 1, 2, ... , or n.
-\[ \left( \sum_{k=1}^n u_k \right)^2 = \sum_{i=1}^n \sum_{j=1}^n u_i u_j \]
-
-Therefore
-\[ \text{Var}(R_P) = \mathbb{E} \left[ \sum_{i=1}^n \sum_{j=1}^n w_i \, w_j \, (R_i - \mathbb{E}(R_i)) (R_j - \mathbb{E}(R_j)) \right] \]
-\[ = \sum_{i=1}^n \sum_{j=1}^n w_i \, w_j \, \text{Cov}(R_i, R_j) \]
-
-The last step arises from the definition of covariance. The only thing left is to express portfolio risk in matrix notation:
-
-\[ \text{Var}(R_P) = \mathbf{w}^T \Sigma \mathbf{w} \]
-where
-\[ \mathbf{w} = \begin{pmatrix} w_1 \\ \vdots \\ w_n \end{pmatrix} \qquad
-\Sigma = \begin{bmatrix}
-\text{Cov}(R_1, R_1) & \text{Cov}(R_1, R_2) & ... & \text{Cov}(R_1, R_n) \\
-\text{Cov}(R_2, R_1) & \text{Cov}(R_2, R_2) & ... & \text{Cov}(R_2, R_n) \\
-\vdots & \vdots & \ddots & \vdots \\
-\text{Cov}(R_n, R_1) & \text{Cov}(R_n, R_2) & ... & \text{Cov}(R_n, R_n)
-\end{bmatrix} \]
-
-
Intuition
-
-How can we make sense of portfolio risk? Consider a simple case with a riskless asset and only n = 2 risky assets.
-
-\[ \text{Var}(R_P) = w_A^2 \text{Var}(R_A) + w_B^2 \text{Var}(R_B) + 2w_A w_B \text{Cov}(R_A, R_B) \]
-
-Portfolio risk can be reduced by choosing two assets that are negatively correlated. This is the benefit of diversification.
-
-
Mean-Variance Analysis
-
-We now try to find a portfolio \( \mathbf{w} = (w_1, ..., w_n) \) that minimizes risk and maximizes return.
-
-The chart below has risk (standard deviation of returns) on the horizontal axis and expected return on the vertical axis. The 10 black points represent individual stocks, while each green / blue point is a portfolio of stocks:
-
-
-
-Notice that all points (i.e. stocks and portfolios) are enclosed by a hyperbola, known as the efficient frontier.
-
-All portfolios on the efficient frontier have the maximum expected return for a given level of risk, if we only consider portfolios of risky stocks. Can we achieve higher returns by including a riskless asset? Yes.
-
-
Capital Market Line
-
-The black line on the chart is the Capital Market Line (CML). It is tangent to the efficient frontier and cuts the vertical axis at the riskfree return. The point of tangency represents the so-called market portfolio.
-
-Every point on the CML represents a portfolio comprising the market portfolio and riskless asset in some proportion. Why?
-
-Suppose some fraction w of a CML portfolio is the market portfolio, and the remainder (1 − w) is the riskless asset. Then its expected return is
-
-\[ \mathbb{E} (R_P) = w \mathbb{E} (R_{\text{market}}) + (1-w) R_0 \]
-
-Since there is only n = 1 risky asset, the variance of the CML portfolio return is
-
-\[ \text{Var} (R_P) = w^2 \text{Var} (R_{\text{market}}}) \]
-
-Taking square roots, we deduce that a CML portfolio's risk is proportional to the market portfolio's weight:
-
-\[ \sigma_P = w \sigma_{\text{market}} \]
-
-This equation can be used to eliminate w in the calculation of expected return:
-
-\[ \mathbb{E} (R_P) = R_0 + \frac{\mathbb{E} (R_{\text{market}}) - R_0}{\sigma_{\text{market}}} \sigma_P \]
-
-This proves that when \( \mathbb{E} (R_P) \) is plotted against \( \sigma_P \), we will obtain a straight line: the CML.
-
-
Portfolio Selection
-
-Why is the CML significant? For any given level of risk, CML portfolios have a higher return than those on the efficient frontier, so investors should select any of them according to their risk tolerance.
-
-Risk-averse investors may give the riskless asset a larger weight in their portfolio. Risk-seeking investors may borrow money (i.e. sell the riskless asset) to invest >100% of their wealth in the market portfolio.
-
-Regardless of their risk tolerances, all investors should hold the same stocks in the same proportion in the market portfolio. In other words, they should not pick stocks according to their risk tolerance.
-
-
Diversification
-
-What happens to the efficient frontier and hence the CML if we have only 3 stocks (IBM, GE, and PFE) instead of 10?
-
-
-
-Since we have fewer stocks to choose from, it's not too surprising that our maximum expected return is lower for any level of risk.
-
-This demonstrates why diversification is often said to be a "free lunch" in investing.
-
-
Summary
-
-In this chapter we have learnt about the modern portfolio theory. It recommends investors to spread their wealth across many asset classes to maximize returns while minimizing risk. In the next chapter, we will introduce the Capital Asset Pricing Model.
-
-
Algorithm:
-
-Mean-variance analysis is used to optimize portfolios with several strategies. Here we treat Dow 30 stocks as strategy and designed an algorithm to test mean-variance analysis:
-
-
\ No newline at end of file
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial13 Capital Asset Pricing Model.html b/Tutorial Series/Introduction to Financial Python/Tutorial13 Capital Asset Pricing Model.html
deleted file mode 100644
index 392b745..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial13 Capital Asset Pricing Model.html
+++ /dev/null
@@ -1,92 +0,0 @@
-In the financial literature, you may hear terms like the "beta" or "market risk" of an asset. This chapter will explain where these terms come from and how they can be useful.
-
-
Capital Asset Pricing Model (CAPM)
-
-As we shall see later, the name "Asset Pricing" is a bit misleading because the CAPM tells us the expected return, rather than the price, of an asset.
-
-In the last chapter, we introduced the Capital Market Line (CML) shown in black:
-
-
-
-All investors should hold a portfolio on the CML, which is constructed by investing some fraction w of our wealth in the market portfolio and the remainder (1 − w) in the riskless asset. So the return on a CML portfolio is
-\[ R = w R_{\text{market}} + (1-w) R_0 \]
-
-If we let β = w, then the equation above becomes
-\[ R - R_0 = \beta (R_{\text{market}} - R_0) \]
-
-Notice that β is a measure of how sensitive our CML portfolio return is to the market return. Taking expectation on both sides results in the CAPM:
-\[ \mathbb{E}(R) - R_0 = \beta (\mathbb{E} (R_{\text{market}}) - R_0) \]
-
-Taking covariance on both sides instead yields
-\[ \text{Cov} (R - R_0, R_{\text{market}}) = \beta \text{Cov} (R_{\text{market}} - R_0, R_{\text{market}}) \]
-
-Now apply two basic facts about covariance:
-
-
\( \text{Cov} (X + c, Y) = \text{Cov} (X, Y) \) where \( c \) is constant
-
-While the Capital Asset Pricing Model is straightforward, applying it may not be. We first need to choose the timeframe for computing returns: should we use daily, weekly or monthly returns? Then we need to consider the number of data points available for linear regression. For example, if we compute beta using monthly returns in the past 1 year, then we only have 12 data points which is too few.
-
-Furthermore, the β of an asset can change over time. The following plot is the daily rolling beta of GE stock with a 6-month rolling windows:
-
-
-
-The β of GE ranged from 0.1 to 0.5 approximately. This is why you need to be careful when using β. It makes no sense to talk about β without a timeframe in mind.
-
-The following graph is the rolling p-value of beta. The p-value stays close to zero most of the time. However, during some period it suddenly increased close to 0.1, which corresponds to a 90% confidence interval. This might be caused by some mispricing or market turmoil.
-
-
-
-
Market-Neutral
-
-A portfolio is market-neutral if its β is zero. In other words, the portfolio's returns are uncorrelated with market returns. We say that it has no "market risk". Some classical market-neutral strategies are pairs trading, beta-hedged equity portfolio and other derivatives strategies.
-
-We have daily returns of Dow 30 stocks from March 2012 to Jan 2015. For each stock, its β on any given day is computed using the past 6 months' returns. As this 6-month window moves forward in time, β will of course change.
-
-Once we know how each stock's β has changed over time, we can ask: which stocks' betas are correlated with each other? The table below shows the correlation between each stock's beta.
-
-
-
-How can we construct a market-neutral portfolio? Consider two stocks A and B:
-\[ R_A = R_0 + \beta_A (R_{\text{market}} - R_0) \]
-\[ R_B = R_0 + \beta_B (R_{\text{market}} - R_0) \]
-
-Let's allocate w on stock A and (1 − w) on stock B, then market neutrality means
-\[ w\beta_A + (1-w) \beta_B = 0 \qquad \Rightarrow \qquad
- w = \frac{\beta_B}{\beta_B - \beta_A} \]
-
-As mentioned earlier, \(\beta_A\) and \(\beta_B\) will change with time, so will \(w\) in a market-neutral portfolio. However we can achieve market neutrality with constant \(w\) so long as \(\beta_A\) and \(\beta_B\) have a linear relationship:
-\[ \beta_A = m\beta_B + c \]
-
-Then eliminate \(\beta_A\) to get
-\[ w = \frac{\beta_B}{(1-m) \beta_B - c} \]
-
-If c ≈ 0 then w is roughly constant:
-\[ w = \frac{1}{1-m} \]
-
-Note: If c is signficant, then we need 3 stocks to get zero net beta. Usually 2 stocks are sufficient to cancel out most of the market risk.
-
-
Example
-
-The 6-month rolling betas of PG and KO stocks have a correlation of 93%. The linear relationship between their betas is
-\[ \beta_{KO} = -0.0097 + 0.969 \beta_{PG} \]
-
-Therefore the market neutral weights are
-\[ w_{KO} = \frac{1}{1-0.969} = 32.3 \qquad w_{PG} = 1 - w_{KO} = -31.3 \]
-
-We tested this portfolio both in-sample (March 2012 to Jan 2015) and out-of-sample. It achieved a beta of 0.01 and -0.004 respectively. See the backtest below.
-
-
Summary
-
-This chapter has explained what market risk means in the context of CAPM, and how market risk can be reduced. In the next chapter we will generalize CAPM to multi-factor models, such as the Fama-French models.
-
-
Algorihtm
-
-
-
\ No newline at end of file
diff --git a/Tutorial Series/Introduction to Financial Python/Tutorial14 Fama-French Multi-Factor Models.html b/Tutorial Series/Introduction to Financial Python/Tutorial14 Fama-French Multi-Factor Models.html
deleted file mode 100644
index 9d818b1..0000000
--- a/Tutorial Series/Introduction to Financial Python/Tutorial14 Fama-French Multi-Factor Models.html
+++ /dev/null
@@ -1,96 +0,0 @@
-In previous chapters, we learnt that the Capital Asset Pricing Model (CAPM) treats the market return as the only factor affecting the return of any asset. This chapter will generalize CAPM to multi-factor models of the following form:
-\[ R = \alpha + \beta_1 f_1 + \beta_2 f_2 + \dots + \beta_n f_n \]
-where each \(f_i\) is a factor.
-
-
Fama-French Three-Factor Model
-
-This model was proposed in 1993 by Eugene Fama and Kenneth French to describe stock returns.[ref] Fama, E F; French, K R (1993). Common risk factors in the returns on stocks and bonds. Journal of Financial Economics. 33: 3. CiteSeerX 10.1.1.139.5892 Freely accessible. doi:10.1016/0304-405X(93)90023-5[/ref]
-
-The 3-factor model is
-\[ R = \alpha + \beta_m MKT + \beta_s SMB + \beta_h HML \]
-
-where
-
SMB (Small Minus Big) measures the excess return of stocks with small market cap over those with larger market cap.
-
HML (High Minus Low) measures the excess return of value stocks over growth stocks. Value stocks have high book to price ratio (B/P) than growth stocks.
-
-
-Data on these factors can be downloaded from French's website.
-
-
Model test
-
-To test the 3-factor model, we use it to predict returns on NASDAQ US Small Cap Index and NASDAQ US Large Cap Index. We estimate the model with daily returns in the past 6 years.
-
-Results for US Small Cap returns:
-
-
-The coefficient of SMB is positive, so when small caps outperform large caps, the Small Cap Index will have higher returns, which is not surprising. By comparing the t statistics of those factors, we know that MKT and SMB are more important factors driving the Small Cap Index.
-
-Results for US Large Cap returns:
-
-
-As expected, the coefficient of SMB is negative for the Large Cap Index. The coefficient of HML is quite low, which suggests that value and growth stocks take approximately the same weight in the Large Cap Index.
-
-
Factor Returns
-
-How do we find out the returns on a single factor? We can do so by constructing a tracking portfolio and computing its returns. For example, if we want a tracking portfolio of the HML factor, we only need to find 4 stocks to construct a portfolio that has MKT and SMB coefficients of 0 and HML coefficient of 1.
-
-Consider stocks A, B, C, and D whose returns can be explained by the 3-factor model:
-
-\[ R_A = \alpha_1 + \beta_{11} MKT + \beta_{12} SMB + \beta_{13} HML \]
-\[ R_B = \alpha_2 + \beta_{21} MKT + \beta_{22} SMB + \beta_{23} HML \]
-\[ \vdots \]
-
-Let their weights in the tracking portfolio be \(w_A,w_B,w_C,w_D\). We write the coefficients into a matrix:
-\[ \Sigma = \begin{pmatrix}
- \alpha_1 & \beta_{11} & \beta_{12} & \beta_{13} \\
- \alpha_2 & \beta_{21} & \beta_{22} & \beta_{23} \\
- \alpha_3 & \beta_{31} & \beta_{32} & \beta_{33} \\
- \alpha_4 & \beta_{41} & \beta_{42} & \beta_{43}
-\end{pmatrix} \]
-
-The tracking portfolio is determined by the solution to these linear equations:
-\[ w^T \Sigma = \begin{pmatrix} 0 \\ 0 \\ 0 \\ 1 \end{pmatrix} \]
-
-Economic interpretation: The 3 Fama-French factors represent "systematic risk" which cannot be reduced by diversification. Investors earn those factor returns for taking such risks. Any idiosyncratic risk, or firm-specific risk, can be diversified away and so investors are not paid to take such risks.
-
-
Other Factors
-
-The Fama-French 5-Factor model comprises two more factors:
-
-
RMW (Robust Minus Weak) measures the excess returns of firms with high operating profit margins over those with lower profits.
-
CMA (Conservative Minus Aggressive) measures the excess returns of firms investing less over those investing more.
-
-
-RMW was proposed by Novy-Marx (2013)[ref]Robert Novy-Marx (2013) The Other Side of Value: The Gross Profitability Premium Journal of Financial Economics 108 (1), 1-28. Retrieved from rnm.simon.rochester.edu/research/OSoV.pdf[/ref] who wrote that:
-
-
"Controlling for gross profitability explains most earnings related anomalies, and a wide range of seemingly unrelated profitable trading strategies."
"A five-factor model directed at capturing the size, value, profitability, and investment patterns in average stock returns is rejected on the GRS test, but for applied purposes it provides an acceptable description of average returns."
-
-Finally, momentum is another commonly used factor. It captures excess returns of stocks with highest returns over those with lowest returns
-
-
Summary
-
-In this chapter we expand Capital Asset Pricing Model (CAPM) into multi-factor models: the Fama-French factor models in particular. They are the most empirically successful multi-factor models by far, and are commonly used in practice.
-
-
Algorithm
-
-Multi-factor strategies are stock picking strategies. Here we try to implement a 2013 paper published by AQR Capital Management.[ref]AQR (2013). A New Core Equity Paradigm: Using Value, Momentum, and Quality to Outperform Markets. Retrieved from www.aqr.com/~/media/files/papers/aqr-a-new-core-equity-paradigm.pdf[/ref]
-
-The paper recommends picking stocks by their value, quality (profitability) and momentum.
-
-The empirically successful measure of value is book-to-price ratio (B/P), but other measures can be used simultaneously to form a more robust and reliable view of a stock's value. The paper uses 5 measures: book-to-price, earnings-to-price ratio (EPS), forecasted EPS, cash flow-to-enterprise value and sales-to-enterprise value.
-
-The paper suggested a few quality measures: total profit over assets, gross margin and free cash flow over assets.
-
-There are also various measures of momentum. 1-year momentum, fundamental momentum and returns around earnings announcement are good choices.
-
-In our backtested strategy, we used operating profit margin to measure quality, P/B value to measure value, and 1-month momentum. The portfolio was rebalanced every 2 months and our backtest period runs from Jan 2012 to Jan 2015.
-
-You can build your own version by changing the factor, the weight of each factor, and the rebalance period based on the backtested strategy.
-
-
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot1.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot1.png
deleted file mode 100644
index 8eb124f..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot1.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot2.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot2.png
deleted file mode 100644
index 4e921ed..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot2.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot3.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot3.png
deleted file mode 100644
index 3ba71b2..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot3.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot4.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot4.png
deleted file mode 100644
index 4e482e2..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot4.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot5.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot5.png
deleted file mode 100644
index f49da9e..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot5.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot6.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot6.png
deleted file mode 100644
index 0f1f6c4..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial07-plot6.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial10-compare.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial10-compare.png
deleted file mode 100644
index 2dbfe74..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial10-compare.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial10-fama.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial10-fama.png
deleted file mode 100644
index cc5025f..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial10-fama.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial10-residual.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial10-residual.png
deleted file mode 100644
index 2f603d3..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial10-residual.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial10-variance.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial10-variance.png
deleted file mode 100644
index 81786c2..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial10-variance.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial9-head.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial9-head.png
deleted file mode 100644
index 4d7356d..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial9-head.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial9-plot1.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial9-plot1.png
deleted file mode 100644
index 8be5acc..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial9-plot1.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial9-plot2.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial9-plot2.png
deleted file mode 100644
index b4c75c1..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial9-plot2.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Financial Python/images/Tutorial9-regression table.png b/Tutorial Series/Introduction to Financial Python/images/Tutorial9-regression table.png
deleted file mode 100644
index ea07f60..0000000
Binary files a/Tutorial Series/Introduction to Financial Python/images/Tutorial9-regression table.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Machine Learning/Tutorial07 Unsupervised Reinforcement Mechanism and Implementation of Q-Learning Algorithms.html b/Tutorial Series/Introduction to Machine Learning/Tutorial07 Unsupervised Reinforcement Mechanism and Implementation of Q-Learning Algorithms.html
deleted file mode 100644
index e69de29..0000000
diff --git a/Tutorial Series/Introduction to Machine Learning/Tutorial08 Association Rule and Market Trend Analysis with Apriori Algorithms.html b/Tutorial Series/Introduction to Machine Learning/Tutorial08 Association Rule and Market Trend Analysis with Apriori Algorithms.html
deleted file mode 100644
index e69de29..0000000
diff --git a/Tutorial Series/Introduction to Machine Learning/Tutorial09 Centroid Rebalance and Stock Classification with K-Nearest Neighbors.html b/Tutorial Series/Introduction to Machine Learning/Tutorial09 Centroid Rebalance and Stock Classification with K-Nearest Neighbors.html
deleted file mode 100644
index e69de29..0000000
diff --git a/Tutorial Series/Introduction to Machine Learning/Tutorial10 Optimizing Technical Indicators by Simulating Evolution Processes to Construct Genetic Algorithms.html b/Tutorial Series/Introduction to Machine Learning/Tutorial10 Optimizing Technical Indicators by Simulating Evolution Processes to Construct Genetic Algorithms.html
deleted file mode 100644
index e69de29..0000000
diff --git a/Tutorial Series/Introduction to Machine Learning/images/placeholder.txt b/Tutorial Series/Introduction to Machine Learning/images/placeholder.txt
deleted file mode 100644
index e69de29..0000000
diff --git a/Tutorial Series/Introduction to Options/Tutorial00 Introduction to Options.html b/Tutorial Series/Introduction to Options/Tutorial00 Introduction to Options.html
deleted file mode 100644
index 52f68c2..0000000
--- a/Tutorial Series/Introduction to Options/Tutorial00 Introduction to Options.html
+++ /dev/null
@@ -1,115 +0,0 @@
-
About
-
The goal of this series is to introduce options to those who are option novices and have basic knowledge of applied mathematics, statistics and financial markets. We will primarily talk about the fundamentals of options and cover topics such as what are options, key terms and concepts option traders need to be familiar with(exercise and assignment, The moneyness, Intrinsic and time value of options etc.) After knowing the basics of options, we will teach how to use QuantConnect API to conduct your options research with over 4000 underlying stock symbols.
-
The following few options tutorials were created to help you understand exactly how options are used as the investment and risk hedging tools. We will further discuss the pricing method of options like BSM model and Monte Carlo method. And then several metrics to gauge the options risks like the Greek letters, different kinds of volatilities used in options pricing and trading. At the end of some tutorials, we will apply the knowledge in that tutorial to demonstrate some simple algorithms developed with Python on Quantconnect attempting to help you gain an insight into options trading and learn more efficient API tools to better customize your own trading algorithms.
-
-
-
-
-
-
8 Tutorials
-
-
-
-
-
3 Backtests
-
-
-
-
-
65 Code Snippets
-
-
-
What Will I Learn?
-
-
General Features of Options
-
QuantConnect Options API
-
Options Pricing: Black-Sholes-Merton Model
-
Stochastic Process
-
Monte Carlo Method
-
The Greek Letters
-
Historical Volatility and Implied Volatility
-
Local Volatility and Stochastic Volatility
-
-
-
-
-
1
-
-
General Features of Options
-Options Contracts
-The Value of Options
-Option Moneyness
-Option Exercise and Assignment
- Read Tutorial
-
-
-
2
-
-
QuantConnect Option API
-Option Data Access
-Option Contracts filtration
-Properties of Contracts
-Order Placement
- Read Tutorial
diff --git a/Tutorial Series/Introduction to Options/Tutorial01 General Features of Options.html b/Tutorial Series/Introduction to Options/Tutorial01 General Features of Options.html
deleted file mode 100644
index c946c4a..0000000
--- a/Tutorial Series/Introduction to Options/Tutorial01 General Features of Options.html
+++ /dev/null
@@ -1,128 +0,0 @@
-
Introduction
-In this tutorial, we will discuss the basic features of options to help you gain insight on what the option is, how options markets are organized and how these contracts are traded. Then we will discuss the settlement rules of option contracts and the moneyness of options.
-
1. Definition
-
-
-
-
-An option is a type of financial derivative. Derivatives are financial contracts and its value is dependent on or derived from underlying assets. The underlying assets could be stocks, indices, commodities, currencies, exchange rates, or the interest rate. When you trade options contracts, it can help you generate profits by betting on the future value or just the moving direction of the underlying assets. So, their value is derived from that of the underlying asset. This is why options are called derivatives.
-
-Puts and calls are two basic classes of options. Call options give the buyer the right to buy the underlying asset at a certain price while put options endow the buyer the rights to sell them. For strict definition, a call/put option is a standardized contract that gives the buyer the right to buy/sell an agreed quantity n of underlying asset S, at a predetermined price K at maturity T. The seller of a call/put option is obliged to sell/buy the underlying assets if the buyer exercises the option.
-
-
-
-
-First, we give the building blocks of an option contract and will discuss them further.
-
-
-
-
Style
-
American Option: the holder of an option has the right to exercise his option at any time before the expiration date
-European Option: an option which can only be exercised on its expiration date
-
-
-
Type
-
Call option, Put option
-
-
-
Underlying Asset
-
The security on which the option is bound. The underlying could be stocks(stock option), stock indices(index option), exchange rate(Foreign exchange option) or even futures(Futures Options).
-Note: The options in the tutorial refer to the stock options.
-
-
-
Premium
-
The price of the option. (Premiums are quoted on a per share basis).
-The option premium depends on the strike price, volatility of the underlying, as well as the time remaining to expiration.
-
-
-
Strike Price
-
The specified price at which the stock can be bought or sold when the option is exercised.
-
-
-
Expiration Date
-
The last day that an options contract is valid. All options expire after a certain period of time. The right to exercise the option will no longer exist once the stock option expires.
-
-
-
Participants
-
Holder: People who buy the options(have long positions)
-Writer: People who sell the options(have short positions)
-
-
-
-
2. Options Contracts
-Stock options are traded in units. Each contract entitles the option buyer/owner 100 shares of the underlying stock upon expiration. Thus, if you buy five call option contracts, you are acquiring the right to purchase 500 shares at expiration. For any given asset at any given time, an option can be bought or sold with multiple expiration dates and strikes. Suppose there are three expiration dates and four strike prices for options on a particular stock, there are a total of 24 different contracts if we consider both put and call options. Currently, all equity options traded on U.S. options exchanges are American-style. But many index options are European-style.
-
-Let us use the example of Apple. You can buy and sell Apple shares (NASDAQ: AAPL), and you can also buy and sell Apple options. But not all stocks have options associated with them. This means that there may be no options available to buy or sell written on a certain stock. You can view the websites of the exchanges to find out which stocks do have options.
-
-In this case, the stock AAPL is known as the underlying asset. The share price of AAPL is the underlying price. And a series of options contracts written on Apple are derivatives. Option contracts have their own symbols. For example, AAPL170728C00143000 is one of the option contracts, it is a call option and the strike price is $143. The contract expires on July 28th. The premium for this contract is $10. If you spend $10 cost on buying one contract, then you get the right to buy 100 shares of AAPL for $143 per share at any time before the expiration date.
-
3. The Value of Options
-The option's premium consists of two parts: the intrinsic value and the time value.
-
-\[Intrinsic Value_{call} = max(Current Underlying Price-Strike Price,0)\]
-\[Intrinsic Value_{put} = max(Strike Price-Current Underlying Price,0)\]
-
-From the equations above, only in the money options have intrinsic value. After we know the intrinsic value, the time value is the difference between the options premium and the intrinsic value.
-
-\[Time Value= Premium-Intrinsic Value\]
-
-For example, an AAPL call option contract which expires after 10 days has strike $143 and premium $10. now the market price of GOOG is $160. The intrinsic value of this contact is 160-143=$17, the time value is 17-10=$7. Although the intrinsic value of OTM and ATM options is zero, they have time values if they still have a certain amount of time until the option expires so for OTM and ATM options, their premiums equal their time values.
-
-
-
-
4. Option Moneyness
-Option moneyness describes the relationship between an option's strike price and the underlying asset's price. It has important implications for options trading.
-
-
-
-
-
-
-
-
-
At the Money(ATM)
-
The strike price is the same as the current price of the underlying asset
-
-
-
In the Money(ITM)
-
Call Option: the strike price is below the current trading price of the underlying
-Put option: the strike price is above the spot price of the underlying
-
-
-
Out of the Money(OTM)
-
Call Option: the strike price is above the current trading price of the underlying
-Put Option: the strike price is below the current trading price of the underlying
-
-
-
-
-
For example, if the price of Apple stock is at $140, then all calls with a strike price below $140 are in the money calls, all puts with a strike price above $140 are in the money puts. All calls with a strike price above $140 are out of the money calls, all puts with a strike price below $140 are out of the money puts.
-
But why are they in the money or out of the money? For a call option as an example, it is ITM because it already has an intrinsic value. If you buy the call option and own the right to buy AAPL at strike price $143 and the current market price is $150, then this call option is in the money 150-143=$7. If you need to exercise it, you can buy shares of AAPL at $143 and sell them immediately for $150 and secure $7 profit.
-Likewise, for a call option, it is OTM because it doesn't have any intrinsic value. If you buy the call option and own the right to buy AAPL at strike price $143 and the current market price is $130, then this call option is out of the money 130-143=$13. If you need to exercise it, you can buy shares of AAPL at $143 and sell them immediately for $130 and then you will lose $13. In this case, you would not do that. But why this kind of OTM options still traded in the market and you need to pay for them? That because they still have time values and have time to expiration. There is probability or there is expectation from the OTM option holders that the apple price will go up and above the strike price before the expiration.
-
5. Option Exercise and Assignment
-When you are the buyer of an option you have three ways to deal with your options.
-
-
You can close out the position at any given point prior to expiration (For buyers, write options and for sellers, buy options);
-
Wait until expiration date and out-of-the-money options will become worthless;
-
Exercise the options which are in-the-money, resulting in a trade of the underlying stock (The seller will be assigned the obligation to sell or buy the underlying stocks)
-
-For all of those methods, closing out an option in the market is the most frequently used method. At the expiration, you need to deal with the option exercise if you long the options. If you short put or call options, you have to think about the assignment.
-
-
Exercise: Exercising option means that the option holder executes the right to buy or sell the underlying assets at the strike price.
-
Assignment: When an option is exercised by the option holder, the option writer will be assigned the obligation to deliver the terms of the options contract. This is called the option assignment.
-
-
-
-
-
-To be concrete, if you write a call option and the option holder decides to exercise, then you must sell the obligated quantity of the underlying security at the strike price to the option holder. Suppose you hold the underlying shares while writing the call option (covered call), those shares would be transferred from you to your counterpart. If you do not hold those shares in your account (naked call), you would then short those shares and deliver them to your counterpart. In another case, if you short a put and the holder decides to exercise, then you must buy those shares. You would now long shares in your account and don't hold options.
-
-
-
-
Summary
-
An option is a standardized contract between two parties to buy or sell an asset for a certain price. Options are pretty different from equity trading. Here we concerned primarily with the stock options. This chapter we present some introductory material on options market like the basic features of options contracts and the options trading mechanism. In addition, we explain how options markets are organized, how the contracts are traded. Next chapter we will take a close look at how to use QuantConnect API to start your options trading algorithm.
-
-
-
-
-
-
diff --git a/Tutorial Series/Introduction to Options/Tutorial03 Put-Call Parity and Arbitrage Strategies.html b/Tutorial Series/Introduction to Options/Tutorial03 Put-Call Parity and Arbitrage Strategies.html
deleted file mode 100644
index b802cc8..0000000
--- a/Tutorial Series/Introduction to Options/Tutorial03 Put-Call Parity and Arbitrage Strategies.html
+++ /dev/null
@@ -1,158 +0,0 @@
-
Introduction
-In this chapter, we will discuss the option's payoff if you long or short the options. Then we discuss the put call parity which is a relationship between the price of a European call option, the price of a European put option, and the underlying stock price. In addition, an application of put-call parity in arbitrage trading strategies was demonstrated.
-
Option Payoff
-Consider Google(NASDAQ: GOOG) is trading at $910 now and you are bullish on this stock and expect it to rise over the next three months. The minimum capital requirement to buy 100 shares of GOOG is $90000 but you only have limited capital for stock investors. You could buy 1 call option contract written on GOOG which expires after three months with a $900 strike price. If GOOG rises to $950 in three months, you can get ($950 - $900) *100 = $5000 by paying just a small amount of premium instead of a full cost of shares. Even if the share price of GOOG falls below $900, you lose only the premium. This is one of the biggest benefits of trading options and is also called the financial leverage. Without borrowing the capital, you can control a larger number of shares by investing in options other than purchasing the shares themselves.
-
-From the above example, [ref]Bouzoubaa M, Osseiran A. Exotic options and hybrids: A guide to structuring, pricing and trading[M]. John Wiley & Sons, 2010.[/ref] The investor will buy a European call if he has a bullish view on the market and believes the underlying stock price will be above the strike price at the expiry date. He will make money when the underlying price goes up and lose when it goes down. The payoff of a call option at T is
-
-\[Call_{payoff}=max[0,S_T-K]\]
-
-
-
-
-On the other hand, an investor will buy a European put if he is bearish about the market and believes that the underlying stock price will be below the strike at the expiry date. He will make money when the underlying price goes down and lose when it goes up. The European put payoff at T is
-
-\[Put_{payoff}=max[0,K-S_T]\]
-
-
-
-
-Where \(S_T\) is the price of underlying assets at maturity. K is the strike price.
-
-We use the GOOG option contract to show the call and put option payoff. The current share price of GOOG is $945 at 07/12/2017.
-
-
-
-
Contract Name
-
Type
-
Expire Date
-
Strike
-
Premium
-
-
-
-
-
GOOG170714C00940000
-
Call
-
07/14/2017
-
$ 940
-
$7.5
-
-
-
GOOG170714P00960000
-
Put
-
07/14/2017
-
$960
-
$19.5
-
-
-
-If you long these two options, the payoff at expire date would be as follows
-
import matplotlib.pyplot as plt
-%pylab inline
-price = np.arange(900,1000,1)
-strike = 940
-premium = 7.5
-payoff = [max(-premium, i - strike-premium) for i in price]
-plt.plot(price, payoff)
-plt.xlabel('Price at T S_T ($)')
-plt.ylabel('payoff')
-plt.title('Call option Payoff at Expiry')
-plt.grid(True)
-price = np.arange(900,1000,1)
-strike = 960
-premium = 19.5
-payoff = [max(-premium, strike - i -premium) for i in price]
-plt.plot(price, payoff)
-plt.xlabel('Price at T S_T ($)')
-plt.ylabel('payoff')
-plt.title('Put option Payoff at Expiry')
-plt.grid(True)
-
-
-
-The above payoff diagrams illustrate the cash payoff on an option at the expiration date. For a call option, the net payoff is negative if the price of the underlying asset is less than the strike price(The negative payoff comes from the premium). If the underlying price exceeds the strike price, the gross payoff is the price of the underlying asset minus the strike price and the premium. For a put option, the net payoff is positive if the underlying price is less than the strike price. If the price of the underlying asset exceeds the strike price, the gross payoff is negative because you pay premuim for purchasing the contracts.
-
2. Put-Call Parity
-Put-Call parity describes the relationship between the price of a European put and a call options with the identical strike price K, expiry T and their underlying stock's price. Next we will demonstrate how to derive the put-call parity according to John Hull's book.
-
-We consider two portfolios as follows,
-
-Portfolio A: buy one European call option (underlying non-dividend-paying stock S, strike K, expiring at T) plus a zero-coupon bond which pays K at T
-
-Portfolio B: sell one European put option (underlying non-dividend-paying stock S, strike K, expiring at T) plus one share of underlying stock S
-
-
-
-
Payoff
-
\(S_t > K\)
-
\(S_t < K\)
-
-
-
Portfolio A
-
\(S_t - K+K=S_t\)
-
\(0+K=K\)
-
-
-
Portfolio B
-
\(0+S_t =S_t\)
-
\(K-S_t+S_t=K\)
-
-
-
-From the above table we can see that in all states, Portfolio A has the same payoff at the options' expiration date as Portfolio B. Thus the present value of two portfolio must be the same. Otherwise, an investor can make risk-free profits by purchasing the undervalued portfolio and selling the overvalued portfolio and holding the position to maturity. Then we have the price equality(suppose the present price of stock S is \(S_0\) )
-
-\[Price_{call}+Ke^{-rT}=Price_{put}+S_0\]
-
-If the dividend is paid during the option holding period, the share holder of the stock would receive that additional amount, but the option owner would not. For a dividend-paying stock, the put–call parity relationship is(D is the present value of dividends):
-
-\[Price_{call}+D+Ke^{-rT}=Price_{put}+S_0\]
-
3. Synthetic Positions
-
-
-
-
-Through the put-call parity, we can find that there is a synthetic equivalent for all of the basic positions in an underlying assets and its corresponding options. In other words, the risk profile(the possible profit or loss) of any position can be exactly duplicated with a complex combination of the other basic positions. These equivalents are synthetic underlying and synthetic options.
-
-[ref]Put-Call Parity and Arbitrage Opportunity, Jim Graham, February 6, 2017 Online Copy[/ref]The rule for creating synthetics is that the strike price and expiration date, of the calls and puts, must be identical. For creating synthetics, with both the underlying stock and its options, the number of shares of stock must equal the number of shares represented by the options.
-
-There are many arbitrage strategies based on the idea of the synthetic position. Here we demonstrate two of the most common strategies: the conversion and the reversal.
-
-
-
-
Strategy
-
Content
-
-
-
Conversion
-
Synthetic Short Position: short call + long put
-The actual stock position: long the underlying stocks
-
-
-
Reversal
-
Synthetic Long Position: long call + short put
-The actual stock position: short the underlying stocks
-
-
-
-Traders use conversions when options are overpriced relative to the underlying stock and use reversals when options are relatively underpriced.
-
Algorithm
-
-
Summary
-
-
-
-
-In this chapter, we derived an important relationship between the prices of European put and call options that have the same strike price and time to maturity by constructing two portfolios. Then we described the synthetic positions, a common concept which is always used in arbitrage trading strategies. Finally two simple arbitrage strategies conversion and reversal are demonstrated on QC platform to help you get a better understanding of how to implement algorithms with simple option mechanism.
-
-Next chapter we will dig into the famous option pricing model-Black Sholes Merton Model and discuss how to apply BSM in European options pricing.
-
-
-
-
-
-
-
-
-
-
-
diff --git a/Tutorial Series/Introduction to Options/Tutorial04 Stochastic Processes and Monte Carlo Method.html b/Tutorial Series/Introduction to Options/Tutorial04 Stochastic Processes and Monte Carlo Method.html
deleted file mode 100644
index e247c0d..0000000
--- a/Tutorial Series/Introduction to Options/Tutorial04 Stochastic Processes and Monte Carlo Method.html
+++ /dev/null
@@ -1,180 +0,0 @@
-
Introduction
-Last few chapters we introduced about the basic principles and mechanism of options trading. We already knew what an option contract is and the basic relationship between call and put options' price. But how do these contracts traded in the exchange are being priced and where does the option premium come from? In the next few chapters, we will discuss the pricing of options.
-
Stochastic Process
-In order to value the derivatives like options, the most significant part is to find a model to represent the underlying stock price so that we can price the options based on the underlying price. We usually use the stochastic process to model the security price.
-
-First, you need to know what the stochastic process is. We say any variable that changes over time in an uncertain way follows a stochastic process. The price of a certain stock at a future time t is unknown at the present so it is a random variable \(S_t\). Then we can think of the movement path of the stock price is a stochastic process since\(S_t\) is a random variable at each time t in the future.
-
1. Brownian motion
-Markov process is a special case of the stochastic process. It means that only the current value of a random variable is relevant for future prediction. In general, we usually assume that the stock price follows a Markov stochastic process, which means only the current stock price is relevant for predicting the future price, it is not correlated with the past price.
-
-
-
-
-Brownian motion is a particular type of Markov stochastic process or we can think of it as a family of random variables {\(W_t\mid t\geq0} \)} indexed by time t. The one-dimensional Brownian motion is called Wiener Process. (Brownian motion is n-dimensional Wiener processes which mean each dimension is just a standard Wiener process). It has the following properties:
-
-
\({W_0=0\)
-
For \(t\geq0\) and \(\Delta t\geq0\), the increment \(W_{t+\Delta t}-W_t\) is normally distributed with mean 0 and standard deviation \(\sqrt{\Delta t}\) .
-
For any partitions \(0\leq t_1<t_2<\cdot\cdot\cdot <t_n\), the increments \(W_{t_1}- W_{t_0},W_{t_2}-W_{t_1},\cdot\cdot\cdot, W_{t_n}-W_{t_{n-1}}\) are independent random variables.
-
With probability 1, the function W(t) is continuous at t.
-
-Intuitively understanding of the definition, Wiener process has independent and normally distributed increments and has continuous sample path.
-
-Next, we simulate the Wiener process and plot the paths attempting to gain an intuitive understanding of a stochastic process. Each path is an independent Wiener process.
-
import numpy as np
-import matplotlib.pyplot as plt
-%pylab inline
-def wiener_process(T, N):
- """
- T: total time
- N: The total number of steps
- """
- W0 = 0
- dt = T/float(N)
- # simulate the increments by normal random variable generator
- increments = np.random.normal(0, 1*np.sqrt(dt), steps)
- W = [0] + list(np.cumsum(increments))
- return W
-t = np.linspace(0.0, N*dt, N+1)
-plt.figure(figsize=(15,10))
-for i in range(5):
- W = wiener_process(10, 1000)
- plt.plot(t, W)
- plt.xlabel('time')
- plt.ylabel('W')
- plt.grid(True)
-
-
-
-
-
-
-
-
-
-[ref]Hull J C. Options, futures, and other derivatives[M]. Pearson Education India, 2006.[/ref]In ordinary calculus,\(\text{d}x=a\ \text{d}t\) is used to indicate that\(\Delta x=a\Delta t\) as \( \Delta t\rightarrow0\). We use the similar notation here. The mean change per unit time for a stochastic process is known as the drift rate and the variance per unit time is known as the variance rate. We can write the derivative of Wiener process over time t in this form: \(dW_t\).A standard Wiener process has a drift rate (i.e. average change per unit time) of 0 and a variance rate of 1 per unit time. If we extend the concept of Wiener process to a generalized Wiener process in the form: \(\text d\ x_t=a\ \text d t+b\ \text dW_t\). The drift rate and the variance rate can be set equal to any chosen constant. If we write it as approximate discrete form as
-
-\[\Delta x=x_{t+\Delta t}-x_t=a\Delta t+b\epsilon\sqrt{\Delta t}\]
-
-Where ε follows the standard normal distribution N(0,1). Thus \(\Delta x\) has normal distribution with mean being \(a\Delta t\), variance being \(b^2\Delta t\). And because \(\Delta t\) is independent, from time 0 to time T, the change in the value of x is just the sum of \(\Delta x\) in each small time interval. It means that the change in the value of x follows the normal distribution \(N(aT,b^2T)\).
-
2. Stochastic process followed by stock price
-Then we go back to the stock price. If we use the generalized Wiener process to model the stock price, for example, the share price of a stock is $30 now, then the percentage change in price from now to say the end of this year is normally distributed with constant mean and variance. But there is a problem that for normal distribution assumption of return, there is the possibility that the stock price will be negative this is unrealistic for stock prices. For example, this percentage change could be -1.1, which means the stock price at the end of the year is -$3.
-
-On the other hand, if the spot price is small for a stock, then it tends to have small increments in price over a given time interval, on the contrary, stocks with high prices tend to have much larger increments in price on the same interval. But Wiener process has a variance which depends on just the time interval but not on the price itself. Thus it is not appropriate to assume that a stock price follows a generalized Wiener process with constant drift rate and variance rate.
-
-In order to characterize the dynamics of a stock price process and fix this problem, we model the proportional increase in the stock price as follows(This kind of equation is often called the stochastic differential equation (SDE)):
-
-
-
-
-
-
-
-
-\[\text dS_t=\mu S_t\ \text d t+\sigma S_t\ \text dW_t \cdot\cdot\cdot\cdot\cdot\cdot(1)\]
-
-Where \(dS_t\) is the change in the stock price over a short time period from t to\(t+\Delta t\). μ is the drift term and can be deemed as the annual expected level of the stock return, σ is the annual volatility of the stock. Here \(dS_t\) at different time t are independent, which means today's price change is independent with tomorrows change. \(W_t\) is a standard Wiener process (1) we discussed above.
-
-
-
-
-Now in the above equation, the drift and variance rate of stock price S is not only correlated with time t but also a function of both S itself and time t.
-
-
-
-
-The discrete approximation form of (1) is
-
-\[\Delta S=\mu S\Delta t+\sigma S\epsilon\sqrt{\Delta t}\]
-
-We can also derive the process that \(lnS_t\) follows is(Here we just give the result, the derivation should use the Ito Lemma):
-
-\[\text d\ ln(S_t)=(\mu-\frac{\sigma^2}{2}) \ \text d t+\sigma \ \text dW_t \cdot\cdot\cdot\cdot\cdot\cdot(2)\]
-
-Here ln S follows a generalized Wiener process as which has constant drift rate and variance rate. That means the change in ln S during time interval \(\Delta t\) is normally distributed. This is the lognormal property of stock prices.
-
-\[lnS_{t+\Delta t}-lnS_t\sim N\left[(\mu-\frac{\sigma^2}{2})\Delta t,\sigma^2\Delta t\right]\]
-
-\[lnS_{t+\Delta t}\sim N\left[\text ln{S_t}+(\mu-\frac{\sigma^2}{2})\Delta t,\sigma^2\Delta t\right]\]
-
-Now the logarithm stock price follows the normal distribution.We write (2) into discrete approximation form as:
-
-\[ln(S_{t+\Delta t})-ln(S_{t})=(\mu-\frac{\sigma^2}{2})\ \Delta t+\sigma \epsilon\sqrt{\Delta t}\]
-
-Equivalently
-
-\[S_{t+\Delta t}=S_{t}\exp\left[(\mu-\frac{\sigma^2}{2})\ \Delta t+\sigma \epsilon\sqrt{\Delta t}\right]\cdot\cdot\cdot\cdot\cdot\cdot(3)\]
-
-If we change t to 0 and change \(\Delta t\) to T, we get
-
-\[S_{T}=S_{0}\exp\left[(\mu-\frac{\sigma^2}{2})\ T+\sigma \epsilon\sqrt{T}\right]\]
-
-according to the above equation, we know the stock price at time T should always greater than 0, the problem for negative price is fixed. Thus we say stock price S is a Geometric Brownian motion because the logarithm of S follows a Brownian motion.
-
-
-
-
Monte Carlo Method
-Monte Carlo method divides a time interval into many small time steps and randomly sampling possible paths for the variable, then repeats this process many times attempting to predict all the possible future outcomes of random variables.
-
1. Monte Carlo Simulation of Stock Price
-We apply this technique to modeling stock prices in order to look at the potential evolution of stock prices over time and then demonstrate how to price the European options. Here we use Google as an example. Suppose today is 07/31/2017, the share price of GOOG is $930.5. We use the historical close price from 01/2015 to 07/2017 to compute the historical annual return and volatility as the mu and sigma parameters. (Note, we do not need to concern with the detailed determinants of \(\mu\) because the value of options written on a stock is, in general, independent of \(\mu\). In contrast, the stock price volatility \(\sigma\) is of crucial importance to the determination of the value of options). Consider GOOG that pays no-dividends, has an expected return 39.64% per annum with continuous compounding and a volatility of 23.44% per annum. Observe today’s price $903.5 per share and with ∆t = 0.001 yr. Then we apply Monte Carlo to simulate 500 price paths in the next three months.
-
-Monte Carlo simulation is a commonly used method for derivatives pricing where the payoff is dependent on the history of the underlying asset or where there are several underlying variables.
-
-The essence of using Monte Carlo method to price the options is to simulate the possible paths for stock prices then we can get all the possible value of stock price at expiration.
-
-
First, we need to divide the maturity T of options into N small time intervals, the length of each time interval is \(\Delta t\), N is the number of steps
-
Sample the possible random paths for the stock price according to equation (3) and get the stock price \(S_T\)at maturity T.
-
Calculate the payoff of options according to the \(S_T\)
-
Discount the payoff at the risk-free rate to get one estimate of options' price
-
Repeat the step 1 to 4 for a reasonable number of times and get many estimates of options price and then the average of these price estimates is the final options price.
-
-There is one thing you need to note that in option pricing, Monte Carlo simulations use the risk-neutral valuation result. More specifically, sample the paths to obtain the expected payoff in a risk-neutral world (The expected annual return rate and the risk-free annual rate should be the same in order to get the correct estimation of the option) and then discount this payoff at the risk-neutral rate.
-
-Suppose the risk-free rate is 1%. A European call option with strike price being $785 and expires in 100 days, the spot price is $927, the premium by using Monte Carlo method is $149.
-
Summary
-In this chapter, we modeled stock price with the stochastic process. The stochastic process usually assumed for a stock price is geometric Brownian motion.The Black–Scholes–Merton model, which we cover in the next chapter, is based on the geometric Brownian motion assumption. Under this process, the logarithm of stock return in a small period of time is normally distributed and the returns in two nonoverlapping periods are independent.
-
-In the second part of the tutorial, we applied Monte Carlo method to simulate the stock price in order to gain an intuitive understanding of the stochastic process followed by stock price. Then we discussed how to use Monte Carlo method to price the options based on the underlying prices paths.
-
-
-
-
diff --git a/Tutorial Series/Introduction to Options/Tutorial05 Options Pricing Black Scholes Merton Model.html b/Tutorial Series/Introduction to Options/Tutorial05 Options Pricing Black Scholes Merton Model.html
deleted file mode 100644
index 7cb5708..0000000
--- a/Tutorial Series/Introduction to Options/Tutorial05 Options Pricing Black Scholes Merton Model.html
+++ /dev/null
@@ -1,140 +0,0 @@
-
Introduction
-In the last chapter, we modeled the stock price with the Geometric Brownian motion. Then the logarithm of return \(\text{ln}(S_T/S_0)\) follows the normal distribution \(N\left[(\mu-\sigma^2/2)T,\sigma^2T\right]\). It means the logarithm of stock price\(\text{ln}(S_T)\)follows the normal distribution \(N\left[\text lnS_0+(\mu-\sigma^2/2)T,\sigma^2T\right]\). Based on this basic assumption, in this chapter, we will talk about a famous option pricing model: Black Scholes Merton Model.
-
Determinants of Option Price
-In different kinds of asset pricing model like bond pricing, enterprise valuation, the most commonly used valuation method is to calculate the present value of the expected cash flows of that asset. But options have some characteristics that are different from the common asset. For example, the options value depends on its underlying assets. In addition, the cash flows on options are not constant in each time period but depend on the occurrence of specific events which are not predictable. In fact, the value of the option is determined by lots of variables.
-
-
the underlying price: Change in the value of the underlying asset is the most important factor which affects the options price. For the call option, holders can earn profit from the price rising and put option holders earn profits from the price decline. Therefore, call options become more valuable as the underlying prices increase while the put options will become less valuable.
-
The volatility of the underlying asset: In tuition, volatility is a measure of the degree of fluctuation of the underlying stock price. It is a forward volatility, which means it is a prediction of how much the stock price of the underlying will move in the future over a certain period of time. The higher the predicted volatility is, the higher the probability that the underlying price will move a lot. Thus the greater will the value of the option is both for calls and puts. We will further discuss the different type of volatilities in the subsequent tutorials.
-
The strike price of the option: Call options gain profit when stock prices greater than the strike, it is easy to understand that the higher the strike price is for the call option, the fewer profits the holder can get, the less valuable of the call option. Thus for the put options, options with higher strike price are more valuable.
-
Time to expiration: If the current date is t, the expiration date of the option contract is T. Then the time to expiration is T-t. For v=both call and put options, the longer time to expiration means there are more changes for the function of stocks prices, and higher probability for the option holders to gain profits from price movement.
-
The risk-free interest rate: As interest rates increase, the expected return required by investors from the stock tends to increase. On the other hand, the present value of discounted cash flow will decrease. Thus the increase in interest rate will increase the call option price and will decrease the put option price.
-
The dividend yield: After the dividends paid, the share price of the stock will decrease. During the options holding period, the decline in underlying price is unfavorable for call options holder. Therefore, the increase in dividend yield will decrease the price of call options and increase the price of put options.
-
-
Factors in the BSM model
-After we get an intuition about affecting factors of options price. Now we will introduce the BSM option pricing model. The Black-Scholes model for pricing stock options was developed by Fischer Black, Myron Scholes and Robert Merton in the early 1970’s.
-
-First, we introduce the factors in the model. For all the factors listed below, only volatility is not known. There are many types of volatilities. Then which volatility should be used is a critical question in option pricing model. We will further discuss this part in the next few chapters.
-
-There are some details we need to pay attention to about the input of BSM model. Firstly, the model works in continuous time, rather than discrete time. Therefore the risk-free rate r has to be modified to the continuous form. Secondly, the time to expiration should be converted to year. The volatility is the annual volatlity.
-
Assumptions
-The market assumptions behind the Black–Scholes formula for pricing European options are as follows:
-
-
The volatility of the underlying assets is constant over time
-
The underlying asset price follows lognormal distribution, this means that the log-returns of stock prices are normally distributed
-
The underlying asset can be traded continuously
-
The underlying stock does not pay dividends during the option's life. But the basic Black-Scholes model was later adjusted for dividends, here we demonstrate the later version with dividend yields.
-
There are no transaction costs or taxes
-
All securities are perfectly divisible, meaning that it is possible to buy any fraction of a share
-
The risk-free rate of interest, r, is constant and the same for all maturities
-
-
-
Equations
-The derivation of the Black-Scholes model is far too complicated to present here, we only show the formula here. The basic principle is based on the idea of creating a portfolio of the underlying asset and the riskless asset with the same cash flows and hence the same cost as the option being valued. Then we get the Black–Scholes–Merton differential equation. The solutions to the differential equation are the Black-Scholes-Merton formulas for the price of European call and put options
-
-\[c = S_0N(d_1)-Ke^{-rT}N(d_2)\]
-
-\[p =Ke^{-rT}N(-d_2)- S_0N(-d_1)\]
-
-\[d_1=\frac{ln(S_0/K)+(r+\sigma^2/2)T}{\sigma\sqrt{T}}\]
-
-
-N(x) is the cumulative probability distribution function for a variable with a standard normal distribution. It can be calculated by the integral of the probability density function of standard normal distribution from 0 to x. In Python, you can use the norm.pdf(x) in spicy.stats library. For the following chart, we plot the probability density curve of the standard normal distribution. For example, N(-1) is the area of the left hand of the red line under the curve.
-
import scipy.stats as sp
-mu = 0
-variance = 1
-x = np.linspace(mu-3*variance,mu+3*variance, 100)
-y = [sp.norm.pdf(i) for i in x]
-plt.plot(x,y)
-d = [-1]
-plt.plot(d*100,np.linspace(0,sp.norm.pdf(d), 100))
-
-
-Then in our BSM model class, we will calculate the European call and put option prices by using BSM formula.
-
def n(self, d):
- # cumulative probability distribution function of standard normal distribution
- return norm.cdf(d)
-
-def dn(self, d):
- # the first order derivative of n(d)
- return norm.pdf(d)
-
-def d1(self):
- d1 = (log(self.s / self.k) + (self.r - self.q + self.sigma ** 2 * 0.5) * self.T) / (self.sigma * sqrt(self.T))
- return d1
-
-def d2(self):
- d2 = (log(self.s / self.k) + (self.r - self.q - self.sigma ** 2 * 0.5) * self.T) / (self.sigma * sqrt(self.T))
- return d2
-
-def bsm_price(self):
- d1 = self.d1()
- d2 = d1 - self.sigma * sqrt(self.T)
- if self.type == 'c':
- price = exp(-self.r*self.T) * (self.s * exp((self.r - self.q)*self.T) * self.n(d1) - self.k * self.n(d2))
- return price
- elif self.type == 'p':
- price = exp(-self.r*self.T) * (self.k * self.n(-d2) - (self.s * exp((self.r - self.q)*self.T) * self.n(-d1)))
- return price
- else:
- print "option type can only be c or p"
-
-a = BsmModel('c', 42, 35, 0.1, 90.0/365, 0.2)
-a.bsm_price()
-
-
-For a call option which expires in 90 days and no dividends paid, the underlying price is $42, the strike is $35, the risk-free rate is 0.1, the volatility is 0.2. The price of this option is $6.157.
-
-
-
-
-
-
Summary
-This tutorial discussed the factors affecting the options price and introduced a famous option pricing model including the input parameters, the assumptions and the formula.
-
-
diff --git a/Tutorial Series/Introduction to Options/Tutorial06 The Greek Letters.html b/Tutorial Series/Introduction to Options/Tutorial06 The Greek Letters.html
deleted file mode 100644
index a8e4c9c..0000000
--- a/Tutorial Series/Introduction to Options/Tutorial06 The Greek Letters.html
+++ /dev/null
@@ -1,229 +0,0 @@
-
-
-
-
Introduction
-Option Greeks measure the different factors such as the underlying price, time and volatility that affect the price of an option contract. In this tutorial we will discuss the various Greeks, their meanings and their implications on the pricing and how to use them to hedge risks.
-
1. Delta
-
Definition
-
-
-
-
-Delta is the rate of change of the option price with respect to the price of the underlying asset. It measures the first-order sensitivity of the price to a movement in stock price S. The option delta is 0.4 means that if the underlying moves by for example 1%, then the value of the option will move by 0.4 × 1%. For European options on an asset that provides a yield at rate q:
-\[delta(call)=\frac{\partial c}{\partial S}=e^{-q(T-t)}N(d1)\]
-\[delta(put)=\frac{\partial p}{\partial S}=e^{-q(T-t)}(N(d1)-1)\]
-
''' Greek letters for European options on an asset that provides a yield at rate q '''
-def delta(self):
- d1 = self.d1()
- if self.type == "c":
- return exp(-self.q * self.T) * self.n(d1)
- elif self.type == "p":
- return exp(-self.q * self.T) * (self.n(d1)-1)
-
Impact Factors
-Stock price, days remaining to expiration and implied volatility will impact the Delta.
-
-
Stock Price: Call option has a positive Delta range from 0 to 1. The Delta is positively correlated to underlying stock price change. While put option has a negative Delta ranges from -1 to 0, its Delta is negatively correlated with the underlying stock price change. At-the-money call options usually have a Delta near .50. At-the-money put options have a Delta near -.50.
-
Implied Volatility: Low implied volatility stocks will tend to have higher Delta for the in-the-money options and lower Delta for out-of-the-money options.
-
Days remaining to expiration: As expiration nears, in-the-money call Deltas increase toward 1.00, at-the-money call Deltas remain at around 0.5 and out-of-the-money call Deltas fall to 0 provided other inputs remain constant.
-
-As a general rule, in-the-money options will move more than out-of-the-money options, and short-term options will react more than longer-term options to the same price change in the stock.
-
-In order to demonstrate how those Greeks values change with the time to expiration and the underlying price, we choose 60*23 call options contracts with the stock price ranging from 10 to 70, time to expiration ranging from 0 to 1 year. The strikes of all the contracts are 40, the interest rates are 0.1, the volatilities are all 0.5. We construct the contracts data as a 23*60 matrix.
-
s = np.array([range(10,70,1) for i in range(23)])
-I = np.ones((shape(s)))
-time = arange(1,12.5,0.5)/12
-T = np.array([ele for ele in time for i in range(shape(s)[1])]).reshape(shape(s))
-
-contracts = []
-for i in range(shape(s)[0]):
- for j in range(shape(s)[1]):
- contracts.append(BsmModel('c',s[i,j],40*I[i,j],0.1*I[i,j], T[i,j],0.5*I[i,j]))
-delta = [x.theta() for x in contracts]
-gamma = [x.gamma() for x in contracts]
-delta = [x.delta() for x in contracts]
-vega = [x.vega() for x in contracts]
-rho = [x.rho() for x in contracts]
-
-gamma = np.array(gamma).reshape(shape(s))
-delta = np.array(delta).reshape(shape(s))
-theta = np.array(theta).reshape(shape(s))
-vega = np.array(vega).reshape(shape(s))
-rho = np.array(rho).reshape(shape(s))
-
-import numpy as np
-import matplotlib.pyplot as plt
-from mpl_toolkits.mplot3d import Axes3D
-from matplotlib import cm
-from matplotlib import animation
-
-z = delta
-fig = plt.figure(figsize=(20,11))
-ax = fig.add_subplot(111, projection='3d')
-ax.view_init(40,290)
-ax.plot_wireframe(s, T, z, rstride=1, cstride=1)
-ax.plot_surface(s, T, z, facecolors=cm.jet(delta),linewidth=0.001, rstride=1, cstride=1, alpha = 0.75)
-ax.set_zlim3d(0, z.max())
-ax.set_xlabel('stock price')
-ax.set_ylabel('Time to Expiration')
-ax.set_zlabel('delta')
-m = cm.ScalarMappable(cmap=cm.jet)
-m.set_array(z)
-cbar = plt.colorbar(m)
-
-
-
-The color of the graph above represents delta value.
-
2. Gamma
-Gamma is the rate of change of the portfolio's delta with respect to the underlying asset's price. It represents the second-order sensitivity of the option to a movement in the underlying asset’s price.
-
-Long options, either calls or puts, always yield positive Gamma. Gamma is higher for options that are at-the-money and closer to expiration because the Delta of the near term options move toward either 0 or 1.00 is imminent. Deeper-in-the-money or farther-out-of-the-money options have lower Gamma as their Deltas already approached 0 or 1.00 (or 0 or -1.00 for puts) and will not change as quickly with movement in the underlying. For European options:
-\[gamma(call)=gamma(put)=\frac{N^{'}(d_1)e^{-q(T-t)}}{S\sigma\sqrt{(T-t)}}\]
-
-
-
-The color of the graph above represents delta value.
-
3. Vega
-
-
-
-
-The Vega is the rate of change in the value of the option with respect to the volatility of the underlying asset.
-
-Vega is always positive for long positions and is the same value for both puts and calls. Hence the option price always increases as the volatility increases. Vega for the European options:
-\[vega(call)=vega(put)=S\sqrt{(T-t)}N^{'}(d_1)e^{-q(T-t)}\]
-
-
-
-The color of the graph above represents Vega.
-
-
4. Theta
-
-
-
-
-Theta is the rate of change of the value of the option with respect to the passage of time. It is also referred to as the time decay of the portfolio.
-
-The theta of holding long position of a call or a put option is usually negative. An option that loses 0.1% per day is said to have a Theta of −0.1%. For example, if we buy an OTM call option, the value of this call option decreases as time passes since the option has less time to expiry. If time passes with the price of the underlying asset and its volatility remaining the same, the passing of time will lower the value of the option. Theta for European Options
-\[Theta(call)=-SN^{'}(d_1)\sigma e^{-q(T-t)}/(2\sqrt{T-t})+qSN(d_1)e^{(-q(T-t))}-rKe^{-r(T-t)}N(d_2)\]
-\[Theta(put)=-SN^{'}(d_1)\sigma e^{-q(T-t)}/(2\sqrt{T-t})-qSN(-d_1)e^{(-q(T-t))}+rKe^{-r(T-t)}N(-d_2)\]
-
z = theta
-# facecolors aren't normalizing as might be expected
-# we need to normalize it to avoid all dark color for value under 0
-norm = matplotlib.colors.Normalize()
-fig = plt.figure(figsize=(20,11))
-ax = fig.add_subplot(111, projection='3d')
-ax.view_init(35,300)
-ax.plot_wireframe(s, T, z, rstride=1, cstride=1)
-ax.plot_surface(s, T, z, facecolors=cm.jet(norm(z)),linewidth=0.001, rstride=1, cstride=1, alpha = 0.9)
-ax.set_zlim3d(z.min(), z.max())
-ax.set_xlabel('stock price')
-ax.set_ylabel('Time to Expiration')
-ax.set_zlabel('rho')
-m = cm.ScalarMappable(cmap=cm.jet)
-m.set_array(z)
-cbar = plt.colorbar(m)
-
-
-
-
5. Rho
-Rho is the rate of change of the value of a derivative with respect to the interest rate. It is usually small and not a big issue in practice unless the option is deep in-the-money and has a long horizon. The interest rate would matter because we need to discount a larger cash flow over a longer horizon. Rho for the European options:
-\[Rho(call)=K(T-t)e^{-r(T-t)}N(d_2)\]
-\[Rho(put)=-K(T-t)e^{-r(T-t)}N(-d_2)\]
-
-The delta of the underlying asset is always 1.0, the trader can hedge his positions by buying or selling the number of shares of the underlying asset indicated by the total delta. However, underlying asset positions have Gamma 0 because their Delta is always 1.00 (long) or -1.00 (short) and will not change. In addition, Vega of the underlying asset is also zero because the underlying asset's payoff doesn't vary depending on how its price moves (payoff is not contingent). Therefore, its price is not affected by price volatility.
-
-As a result, in order to adjust Gamma and Vega, it is necessary to take a position in an option or other derivatives. However, if only one other derivative is added, either the Gamma risk or the Vega risk will be canceled out, but not both at the same time. Here we need to use 2 derivatives to make the portfolio delta, gamma, and vega neutral all at once. Note, Vega and Gamma for a portfolio is the sum of the vegas and Gammas of its constituents.
-
-
Summary
-
-
-
-In this chapter we discussed the various Greeks, their meanings and their implications on the pricing and hedging of derivatives. We also presented some useful formulas for calculating the Greeks value of European options and generated the plots to show how they changed with strikes and time to expirations. The Greeks letter is the sensitivity measure of options price to the market variables. Next chapter we will discuss another major risk measures: volatility.
-
-
-
-
-
-
diff --git a/Tutorial Series/Introduction to Options/Tutorial07 Historical Volatility and Implied Volatility.html b/Tutorial Series/Introduction to Options/Tutorial07 Historical Volatility and Implied Volatility.html
deleted file mode 100644
index 7488f06..0000000
--- a/Tutorial Series/Introduction to Options/Tutorial07 Historical Volatility and Implied Volatility.html
+++ /dev/null
@@ -1,192 +0,0 @@
-
Introduction
-The change of volatility can have a significant impact on any options trading strategies performance. In addition to the Vega we explained in Greeks letter chapter, this part of the volatility tutorial will discuss the concept of volatility, specifically, we discuss realized and implied volatility, their meanings, measurements, uses, and limitations.
-
-
Historical Volatility
-
-
1. Definition
-It is a measurement of how much the price of the asset has changed on average during the certain period of time. In common, volatility is said to be the standard deviation of the return of assets price.
-
2. Calculation
-Here we discuss how to estimate the historical volatility of the option written on specific underlying asset empirically.
-
-\[r_i=ln(\frac{S_i}{S_{i-1}})\quad for\ i=0,1,2,3,...,n\]
-
-Where (n+1) is the number of observations, \(S_i\) is the stock price at end of it time interval
-
-The standard deviation of the \(r_i\) is given by
-\[std=\sqrt{\frac{1}{n-1}\sum_{i=1}^n(r_i-\overline{r})^2}\]
-where \(\overline{r}\) is the mean of \(r_i\)
-
-If we assume there are n trading days per year. Then the estimate of historical volatility per annum is
-
-\[std\times\sqrt{n}\]
-
import pandas as pd
-from numpy import sqrt,mean,log,diff
-import quandl
-quandl.ApiConfig.api_key = 'NxTUTAQswbKs5ybBbwfK'
-goog_table = quandl.get('WIKI/GOOG')
-# use the daily data of Google(NASDAQ: GOOG) from 01/2016 to 08/2016
-close = goog_table['2016-01':'2016-08']['Adj. Close']
-r = diff(log(close))
-r_mean = mean(r)
-diff_square = [(r[i]-r_mean)**2 for i in range(0,len(r))]
-std = sqrt(sum(diff_square)*(1.0/(len(r)-1)))
-vol = std*sqrt(252)
-An asset has a historical volatility based on its past performance as described above, investors can gain insight on the fluctuations of the underlying price during the past period of time. But it does not tell us anything about the volatility in the market now and in the future. So here we introduce the implied volatility.
-
Implied Volatility
-In contrast to historical volatility, the implied volatility looks ahead. It is often interpreted as the market’s expectation for the future volatility of a stock and is implied by the price of the stock’s options. Here implied volatility means it is not observable in the market but can be derived from the price of an option.
-
1. Definition
-
-We use volatility as an input parameter in option pricing model. If we take a look at the BSM pricing, the theoretical price or the fair value of an option is P, where P is a function of historical volatility σ, stock price S, strike price K, risk-free rate r and the time to expiration T. That is \(P=f(\sigma,S,K,r,T)\). But the market price of options is not always the same with the theoretical price. Now in contrast, if we are given the market’s prices of calls and puts written on some asset and also the value of S, K, r, T. For each asset we can solve a new volatility that corresponds to the price of each option – the implied volatility. Then the implied volatility is \(\IV=f^{-1}(P,S,K,r,T)\).
-
2. Calculation
-Here we use the bisection method to solve the BSM pricing equation and find the root which is the implied volatility. We use Yahoo Finance Python API to get the real time option data.
-
-From the result above, the implied volatility of European call option (with premium c=0.3, S=3, K=3, r=0.032, T =30 days, d=0.01) is 0.87.
-
3. Factors Affecting Implied Volatility
-According to the time value description in the first tutorial, [ref]Options Pricing: Intrinsic Value And Time Value, Jean Folger, Online Copy[/ref]in general, the more time to expiration, the greater the time value of the option. Investors are willing to pay extra money for zero intrinsic value options which have more time to expiration because more time increases the likelihood of price movement and fluctuations, it is the options will become profitable. Implied volatility tends to be an increasing function of maturity. A short-dated option often has a low implied volatility, whereas a long-dated option tends to have a high implied volatility.
-
-
Volatility Skew
-For European options of the same maturity and the same underlying assets, the implied volatilities vary with the strikes. For a series of put options or call options, if we plot these implied volatilities for a series of options which have the same expiration date and the same underlying with the x axis being the different strikes, we would get a convex curve. The shape of this curve is like people's smiling, it is being called the volatility. The shape of volatility smile depends on the assets and the market conditions.
-
-Here we give an example how to plot the volatility smile by using the real time options data of SPDR S&P 500 ETF(NYSEARCA: SPY).
-
# download option data for all expiry months from Yahoo Finance
-# provide a formatted DataFrame with a hierarchical index
-opt = Options('spy', 'yahoo')
-opt.expiry_dates # list all the available expiration dates
-def IV_plot(opt,option_type,expiry_index):
- expiry = opt.expiry_dates[expiry_index]
- if option_type == 'c':
- data = opt.get_call_data(expiry=expiry)
- elif option_type == 'p':
- data = opt.get_put_data(expiry=expiry)
- r = 0.01 # risk free rate
- d = 0.01 # continuous devidend yield
- s = opt.underlying_price # data_call['Underlying_Price'] undelying price
- expiry = data.index.get_level_values('Expiry')[0] # get the expiry
- current_date = opt.quote_time # current_date = datetime.datetime.now() # get the current date
- time_to_expire = float((expiry - current_date).days)/365 # compute time to expiration
- premium = (data['Ask'] + data['Bid'])/2 # option premium
- strike = list(data.index.get_level_values('Strike')) # get the strike price
- IV = []
- for i in range(len(data)):
- IV.append(implied_vol(option_type, premium.values[i], s, strike[i], r, time_to_expire, d))
-
- plt.figure(figsize=(16, 7))
- a = plt.scatter(strike,IV, c='r', label="IV by solving BSM")
- b = plt.scatter(strike,data['IV'],c = 'b', label="IV from Yahoo Finance")
- plt.grid()
- plt.xlabel('strike')
- if option_type == 'c':
- plt.ylabel('Implied Volatility for call option')
- plt.legend((a,b), ("IV(call) by solving BSM", "IV(call) from Yahoo Finance"))
- elif option_type == 'p':
- plt.ylabel('Implied Volatility for put options')
- plt.legend((a,b), ("IV(put) by solving BSM", "IV(put) from Yahoo Finance"))
-
- return strike,IV
-k_call, IV_call = IV_plot(opt,'c',23)
-k_put, IV_put = IV_plot(opt,'p',23)
-plt.figure(figsize=(16, 7))
-e = plt.scatter(k_call,IV_call, c ='red', label="IV(call options)")
-f = plt.scatter(k_put,IV_put, c = 'black', label="IV(put options)")
-plt.xlabel('strike')
-plt.ylabel('Implied Volatility')
-plt.legend((e,f), ("IV (call options)", "IV (put options)"))
-
-The current date is 08/14/2017. We plot the implied volatilities for SPY options which expire on 12/21/2018.
-
-
-
-
-Plotting these implied volatilities across strikes gives us the implied volatility skew. For the shape of volatility smile, it should be a symmetry convex curve. But from the above chart, the implied volatility curve slope downward to the right. This is referred to the skew, which means that options with low strikes have higher implied volatilities than those with higher strikes. The smile is not symmetry. The skew of a distribution is a measure of its assymetry. Although the volatility skew is dynamic, in equity markets it is almost always a decreasing function of the strike. Other asset classes such as FX and commodities have differently shaped skews.
-If we plot the call and put options implied volatility smile in the same chart for the same expiration date:
-
-From the above chart, we can see the implied volatility for put options is higher than call options. Usually, put options trade for a higher price than call options, because traders place more risk in the short put positions, which raises the amount of reward they require to sell the position. Higher option prices signify an increase in risk and are represented by higher implied volatility levels derived from the option pricing model.
-Then we scattered all the implied volatilities of contracts across all the strikes.
-
opt = Options('spy', 'yahoo')
-r = 0.01 # risk free rate
-d = 0.01 # continuous devidend yield
-expiry_dates = [i for i in opt.expiry_dates if i > opt.quote_time.date()]
-current_date = opt.quote_time.date() ## get the current date
-s = opt.underlying_price # undelying price
-num_expiry = len(expiry_dates)
-IV = [] # (num_expiry * 3)-dimension list with each row being [time_to_expire, strike, implied_vol]
-
-for expiry_index in range(num_expiry):
- data = opt.get_put_data(expiry=expiry_dates[expiry_index])
- expiry = expiry_dates[expiry_index] # get the expiry
- time_to_expire = float((expiry - current_date).days)/365 # compute time to expiration
- premium = (data['Ask'] + data['Bid'])/2.0 # option premium
- strike = data.index.get_level_values('Strike') # get the strike price
- num_strike = len(data)
- for j in range(num_strike):
- IV.append([time_to_expire, strike[j], implied_vol('c', premium.values[j], s, strike[j], r, time_to_expire, d)])
-x= [IV[i][0] for i in range(len(IV))]
-y= [IV[i][1] for i in range(len(IV))]
-z= [IV[i][2] for i in range(len(IV))]
-fig = plt.figure(figsize=(20,11))
-ax = fig.add_subplot(111, projection='3d')
-ax.view_init(20,10)
-ax.scatter(x,y,z)
-
-
-
Volatility Surface
-By fixing a maturity and looking at the implied volatilities of European options on the same underlying but different strikes, we obtain the implied volatility skew or smile. The volatility surface is the three-dimensional surface obtained when we plots the market implied volatilities of European options with different strikes and different maturities.
-By using the interpolation method, we can generate the implied volatility surface of SPY options for both put and call options as follows:
-
-
-
The Reason for Volatility Skew
-The volatility skew shows that for Put options, implied volatility is higher for deep OTM options and then is decreasing as it moves towards ITM options. For call options, the implied volatility is higher for deep ITM options and then is decreasing as it moves towards OTM options. From the demand and supply degree, the skew reflects that investors are more willing to buy deep OTM puts and ITM calls. Why there is volatility skew in the market?
-First, the majority of the equity positions are long. Investors usually have two ways to hedge those long positions risks: Buying downside puts or selling upside calls. The increase in demand create increases in price of downside puts and decreases in price of upside calls. The volatility is a reflection of options price. Therefore the volatility of in-the-money put is higher and the volatility of in-the-money call is lower.
-The second reason for volatility skew is that the market moves down faster than it moves up. The downside market move is riskier than the upside move. Thus the price of OTM puts is higher than OTM calls.
-
Summary
-In this chapter, we discussed the historical volatility and the implied volatility. The historical volatility of an asset is the statistical measure we know as the standard deviation of the stock return series. The implied volatility of the same asset, on the other hand, is the volatility parameter that we can infer from the prices of traded options written on this asset. In contrast to historical volatility, which looks at fluctuations of asset prices in the past, implied volatility looks ahead. The two volatilities do not necessarily coincide, and although they may be close, they are typically not equal.
-Now we know the constant volatility assumption in Black-Sholes-Merton model is not applicable in the real market because there is volatility skew for most of the options. Then in next chapter we will introduce some volatility models to capture the volatility skew in options pricing.
-
diff --git a/Tutorial Series/Introduction to Options/Tutorial08 Local Volatility and Stochastic Volatility.html b/Tutorial Series/Introduction to Options/Tutorial08 Local Volatility and Stochastic Volatility.html
deleted file mode 100644
index 7a437db..0000000
--- a/Tutorial Series/Introduction to Options/Tutorial08 Local Volatility and Stochastic Volatility.html
+++ /dev/null
@@ -1,209 +0,0 @@
-
-
-
-
Introduction
-In the last chapter, we discussed two of the volatilities: historical volatility and the implied volatility. This chapter, we will further extend the concept of volatility and introduce the local volatility and the stochastic volatility.
-
Motivation
-We already knew that volatility is a measure of the fluctuation degree of the underlying assets price series. There are many types of volatilities. As we discussed in the last chapter, historical volatility is the standard deviation of the price series during a certain period. It is a constant and represents the price movement in the past. However, the implied volatility is not based on the historical pricing data of stocks. It is the value of volatility parameter derived from the market quote of options in BSM pricing model. In contrast to historical volatility, implied volatility is forward looking and varies with different options contracts.
-
-
-
-
-In the Black–Scholes model, the asset’s price is modeled as a log-normal random variable, which means that the asset’s log-returns are normally distributed. One of the most significant assumptions in BSM model is that the volatility is a constant term over time.
-
-\[\sigma=\sigma_{implied}\]
-
-But in the real world, it could be constant in a small time period but never constant in long term. As we discussed in the last chapter, there is volatility skew for most of the options, which means that the volatility is not constant across strikes.
-
-[ref]Bouzoubaa M, Osseiran A. Exotic options and hybrids: A guide to structuring, pricing and trading[M]. John Wiley & Sons, 2010.[/ref]One way to capture the volatility skew is to assume that that the volatility itself is a random variable, this is the stochastic volatility model we will discuss next. But on the other hand, the introduction of additional sources of randomness will increase the complexity of the model. The other way to capture the volatility skew but without introducing the additional source of randomness is the local volatility.
-
Local Volatility
-
1. Definition
-The constant volatility assumption in BSM model seems not reasonable in most of the options pricing. The volatility skew tells us that the stock’s log-returns are actually not normally distributed. That means there exist some other kinds of distributions of stock price so that if we use this distribution to price the options, it would give the accurate options' price as we see in the market. The local volatility is implied in this non-normal distribution. Let's look at the definition of local volatility.
-
-[ref]Bouzoubaa M, Osseiran A. Exotic options and hybrids: A guide to structuring, pricing and trading[M]. John Wiley & Sons, 2010.[/ref]The local volatility of the underlying assets is a deterministic function of assets price and the time t.
-
-\[\sigma=\sigma(S_t,t)\]
-
-Therefore under local volatility model, the stochastic process followed by the stock price is
-
-\[\text d S_t=\mu S_t\ \text d t+\sigma(S_t,t)\text d W_t\]
-
-If \(\sigma(S_t,t)=\sigmaS_t\), then this is the case of BSM model with constant volatility\(\sigma\). Here we are not assuming the volatility is constant but a function of the asset price so the stock’s log-returns are not normally distributed anymore. There is only one source of randomness fro m the stock price: \(W_t\).
-
2. Model Calibration
-How to obtain the function \(\sigma(S_t,t)\)? Finding the function \(\sigma(S_t,t)\) is known as the calibration of local volatility model. This is answered by the following Dupire's formula.
-
-\[\sigma_{Local}(K,T)=\sqrt{\frac{\frac{\partial C}{\partial T}}{\frac{1}{2}K^2\frac{\partial^2 C}{\partial K^2}}}\]
-
-If we assume that we know all the observed market price of European call options C(T, K) for every strike K and every maturity T. Local volatility model calculates volatilities for a set of options with the different combination of strike prices and expires. For a given date, time(t) and the underlying stock prices(St), a local volatility is derived from the equation that options prices calculated using local volatility equal the market options prices.
-
-But most of the time, we can only get a limited number of contracts with a few strikes and maturities, we can follow the steps below to get the local volatility estimation:
-
-
First, use the available quoted price to calculate the implied volatilities.
-
Appy interpolation method to produce a smooth implied volatility surface.
-
Plug implied the implied volatilities into BSM model to get all the market prices of European calls.
-
Calculate the local volatility according to Dupire formula. In order to avoid taking derivatives, we could use finite differences to approximate the derivatives.
-In stochastic volatility models, the asset price and its volatility are both assumed to be random processes and can change over time. There are many stochastic volatility models. Here we will present the most well-known and popular one: the Heston Model. In Heston model, the stock prices are log-normal distributed, the volatility process is a positive increasing function of a mean-reversion process. That is[ref]Gatheral J. The volatility surface: a practitioner's guide[M]. John Wiley & Sons, 2011[/ref]
-
-
-
-
-
-
-
-
-\[dS_t = \mu_tS_tdt+\sqrt{v_t}S_tdW_{1,t}\]
-
-\[dv_t=-\lambda(v_t-\overline{v})\ dt+\eta\sqrt{v_t}\ dW_{2,t}\]
-
-\[dW_{1,t},\ dW_{2,t}=\rho \ dt\]
-
-Where the instantaneous variance of the stock price \(v_t\) itself is a stochastic process.
-
-\(\lambda\) is the speed of reversion of \(v_t\) to its long-term mean \(\overline{v})\). We can think of\(\lambda\) as the rate at which the stock price variance reverts back to its long term average value.
-
-\(\eta\) is the volatility of the variance process \(v_t\) (often called the volatility of volatility)
-
-\(W_{1,t}\) and \(W_{2,t}\) are two dependent Wiener processes with correlation coefficient \(\rho\).
-
2. Simulation of the Heston Process
-We already discuss how to simulate the stock price process with Monte Carlo method in the introduction to stochastic process tutorial. In order to simulate the variance process, we need to write it into discrete form. The derivation can be found in paper Rouah F D. Euler and Milstein discretization[ref]Rouah F D. Euler and Milstein discretization[J]. Documento de Trabajo, Sapient Global Markets, Estados Unidos, 2011. Online Copy[/ref].
-
-\[v_{t+\Delta t}=\left(\sqrt{v_t}+\frac{1}{2}\eta\sqrt{\Delta t}W_1\right)^2-\lambda(v_t-\overline{v})\Delta t-\frac{\eta^2}{4}\Delta t\]
-
-Then, we take the following steps to simulate Heston process: Given the value of \(v_t\) at time t, we first update to \(v_{t+\Delta t}\) using the formula above (Here note that in options pricing, Monte Carlo method use risk neutral result, so here the expected return \(\mu\) should equal the risk free rate r):
-
-
Given the value of \(v_t\) at time t, we first update to \(v_{t+\Delta t}\) using the formula above
-
We obtain \(S_{t+\Delta t}\) using\[S_{t+\Delta t}=S_t\ \text {exp}\left[(r-\frac{1}{2}v_t)\Delta t+\sqrt{v_t\Delta t}W_2\right]\]
-
To generate \(W_1\) and \(W_2\) with correlation \(\rho\), we first generate two independent standard normal variables \(Z_1\) and \(Z_2\), set \(W_1=Z_1\), then \[W_2=\rho Z_1+\sqrt{1-\rho^2}Z_2\]
-
-
from numpy import sqrt, exp
-import numpy as np
-
-def mc_heston(option_type,S0,K,T,initial_var,long_term_var,rate_reversion,vol_of_vol,corr,r,num_reps,steps):
- """
- option_type: 'p' put option 'c' call option
- S0: the spot price of underlying stock
- K: the strike price
- T: the maturity of options
- initial_var: the initial value of variance
- long_term_var: the long term average of price variance
- rate_reversion: the mean reversion rate for the variance
- vol_of_vol: the volatility of volatility(the variance of the variance of stock price)
- corr: the correlation between the standard normal random variables W1 and W2
- r: the risk free rate
- reps: the number of repeat for monte carlo simulation
- steps: the number of steps in each simulation
- """
- delta_t = T/float(steps)
- payoff = 0
- for i in range(num_reps):
- vt = initial_var
- st = S0
- for j in range(steps):
- w1 = np.random.normal(0, 1)
- w2 = corr*w1+sqrt(1-corr**2)*np.random.normal(0, 1)
- vt = (sqrt(vt) + 0.5 * vol_of_vol * sqrt(delta_t) * w1)**2 \
- - rate_reversion * (vt - long_term_var) * delta_t \
- - 0.25 * vol_of_vol**2 * delta_t
- st = st * exp((r - 0.5*vt)*delta_t + sqrt(vt*delta_t) * w2)
- if option_type == 'c':
- payoff += max(st - K, 0)
- elif option_type == 'p':
- payoff += max(K - st, 0)
-
- return (payoff/float(num_reps)) * (exp(-r*T))
-
-
3. Calibration of Model Parameters
-The calibration of a model is the process of seeking the model parameters for which the model result best matches the market option data. This data usually consists of market quoted prices for European plain vanilla call options or of Black-Scholes implied volatilities derived from the prices. Calibrating the Heston model is equivalent to solving the non-linear constrained optimization problem: Minimize the error between the market quotes of options and the options price estimated by Heston model. The object function could be the absolute value of the error or the absolute squared error. You can refer to the paper Parameters recovery via calibration in the Heston model[ref]Escobar, Marcos, and Christoph Gschnaidtner. "Parameters recovery via calibration in the Heston model: A comprehensive review." Wilmott 2016.86 (2016): 60-81.[/ref] for details of different error measure.
-
-There are five parameters need to be estimated in Heston model:
-
-
\(v_t\) : the initial value of the variance (Bounds of 0 and 1)
-
\(\overline{v}\) : the long term average variance of stock price (Bounds of 0 and 1)
-
\(\lambda\) : the speed of reversion (non-negativity)
-
\(\eta\) : the volatility of the volatility (non-negativity)
-
\(\rho\) : the correlation coefficient between two Wiener process (Bounds of -1 and 1)
-
-Here we use QuantLib[ref]Modeling Volatility Smile and Heston Model Calibration Using QuantLib Python, Goutham Balaraman, online copy[/ref] Python library to calibrate the parameters.
-
-Let us look at how we can calibrate the Heston model to some market quotes. For example, let's say we are interested in trading SPDR S&P 500 ETF (SPY) options with 4-months maturity. Here we choose all the options contracts written on SPY expire in 4 months. We need the strikes and the market prices of those contracts and the underlying price as the input of our objective function to minimize.
-
-When you get the parameter estimation, you can plug the parameter values into the Heston Monte Carlo options pricing model and get the price estimation with stochastic volatility. But as we already discussed for Heston model, the introduction of randomness of volatility increases the complexity of the estimation. No matter which error measure is chosen, the objective function is highly non-linear and far from being convex and we have 5 parameters in the model. All these drawbacks of Heston models will make the estimated parameter values quite sensitive the initial guess of parameters. Therefore options prices generated by the Heston model are also parameter sensitive. From the above, we can get a sense of how computationally expensive it can be to get accurate values of options in a stochastic volatility model.
-
Summary
-
-
-
-
-In Black–Scholes, that volatility is assumed to be constant, it is not reasonable especially for some exotic options in which the option's payoff is based on the changing volatility. Therefore we introduced the two volatility models to capture the volatility skew.The first approach, local volatility, assumes that the volatility is a deterministic function of time and the underlying asset price. This function must be chosen as to match the observed market option prices. In another stochastic volatility models, the asset price and its volatility are both assumed to be random processes.
-
-The calibration of these models needs the market price of the Vanilla options. When we get the model estimation we can use these models to pricing the corresponding exotic options.
-
-
-
-
-
-
-
diff --git a/Tutorial Series/Introduction to Options/images/call-payoff.png b/Tutorial Series/Introduction to Options/images/call-payoff.png
deleted file mode 100644
index 663c94a..0000000
Binary files a/Tutorial Series/Introduction to Options/images/call-payoff.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/delta.png b/Tutorial Series/Introduction to Options/images/delta.png
deleted file mode 100644
index 0efb29e..0000000
Binary files a/Tutorial Series/Introduction to Options/images/delta.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/gamma.png b/Tutorial Series/Introduction to Options/images/gamma.png
deleted file mode 100644
index b1c8e8d..0000000
Binary files a/Tutorial Series/Introduction to Options/images/gamma.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/ivcall.png b/Tutorial Series/Introduction to Options/images/ivcall.png
deleted file mode 100644
index 3018f70..0000000
Binary files a/Tutorial Series/Introduction to Options/images/ivcall.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/ivput.png b/Tutorial Series/Introduction to Options/images/ivput.png
deleted file mode 100644
index 2c3f5a0..0000000
Binary files a/Tutorial Series/Introduction to Options/images/ivput.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/ivputcall.png b/Tutorial Series/Introduction to Options/images/ivputcall.png
deleted file mode 100644
index a1e258f..0000000
Binary files a/Tutorial Series/Introduction to Options/images/ivputcall.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/n(-1).png b/Tutorial Series/Introduction to Options/images/n(-1).png
deleted file mode 100644
index d8e01ba..0000000
Binary files a/Tutorial Series/Introduction to Options/images/n(-1).png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/put-payoff.png b/Tutorial Series/Introduction to Options/images/put-payoff.png
deleted file mode 100644
index 66af26e..0000000
Binary files a/Tutorial Series/Introduction to Options/images/put-payoff.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/rho.png b/Tutorial Series/Introduction to Options/images/rho.png
deleted file mode 100644
index 25138ce..0000000
Binary files a/Tutorial Series/Introduction to Options/images/rho.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/stock-price-path.png b/Tutorial Series/Introduction to Options/images/stock-price-path.png
deleted file mode 100644
index e14a8d1..0000000
Binary files a/Tutorial Series/Introduction to Options/images/stock-price-path.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/theta.png b/Tutorial Series/Introduction to Options/images/theta.png
deleted file mode 100644
index d5eb5bb..0000000
Binary files a/Tutorial Series/Introduction to Options/images/theta.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/vega.png b/Tutorial Series/Introduction to Options/images/vega.png
deleted file mode 100644
index 43ad2d3..0000000
Binary files a/Tutorial Series/Introduction to Options/images/vega.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/vol-surface-call.png b/Tutorial Series/Introduction to Options/images/vol-surface-call.png
deleted file mode 100644
index 89ff569..0000000
Binary files a/Tutorial Series/Introduction to Options/images/vol-surface-call.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/vol-surface-put.png b/Tutorial Series/Introduction to Options/images/vol-surface-put.png
deleted file mode 100644
index 03ec840..0000000
Binary files a/Tutorial Series/Introduction to Options/images/vol-surface-put.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/volsurface.png b/Tutorial Series/Introduction to Options/images/volsurface.png
deleted file mode 100644
index fd311f1..0000000
Binary files a/Tutorial Series/Introduction to Options/images/volsurface.png and /dev/null differ
diff --git a/Tutorial Series/Introduction to Options/images/wiener-process.png b/Tutorial Series/Introduction to Options/images/wiener-process.png
deleted file mode 100644
index 1a7135b..0000000
Binary files a/Tutorial Series/Introduction to Options/images/wiener-process.png and /dev/null differ
diff --git a/Tutorial Series/README.md b/Tutorial Series/README.md
deleted file mode 100644
index c8e32ec..0000000
--- a/Tutorial Series/README.md
+++ /dev/null
@@ -1,124 +0,0 @@
-
-# QuantConnect Tutorial Series
-----------
-
-This repository is a collection of WordPress and Jupyter notebook tutorials for LEAN demonstrating basic financial concepts, Python usage and introduction to Options and Machine Learning. Tutorials are categorized into 3 folders with each Category. The Jupyter notebook and the associated HTML webpage must use matching file names. The HTML is generated and displayed with wordpress.
-
-## Introduction to Financial Python ##
-This tutorial series starts from basic Python and finance concepts. If you have great investment ideas but don’t know how to build, or you think you need to learn some basic skills in quantitative finance, here is a good start point. These series include four parts: Python, basic math and statistics, basic finance regarding investment, and financial time series analysis, which is an advanced curriculum in quantitative finance.
-
-We not only introduce the concepts but also show you how to apply the introduced technique step by step using Python code snippets. We use real financial datasets as examples, and show you what those charts in text book look like with real-world financial data. After each chapter, we also design a QC algorithm applying what we learned. We do this in order to let you have a more comprehensive understanding and see the differences between the theories and the practice — sometimes it can be hard to apply a simple concept.
-
-
-## Tutorial Series ##
-
-
-
-## Introduction to Options ##
-The goal of this series is to introduce options to those who are option novices and have basic knowledge of applied mathematics, statistics and financial markets. We will primarily talk about the fundamentals of options and cover topics such as what are options, key terms and concepts option traders need to be familiar with(exercise and assignment,The moneyness, Intrinsic and time value of options etc.) After knowing the basics of options, we will teach how to use QuantConnect API to conduct your options research with over 4000 underlying stock symbols.
-
-The following few options tutorials was created to help you understand exactly how options are used as investment and risk hedging tools. We will further discuss the pricing method of options like BSM model and monte carlo method. And then several metrics to gauge the options risks like the Greek lettters, different kinds of volatilities used in options pricing and trading. At the end of some tutorials, we will apply the knowledge in that tutorial to demonstrate some simple algorithms developed with Python on Quantconnect attempting to help you gain an insight into options trading and learn more efficient API tools to better customize your own trading algorithms.
-
-
-
-
-## Introduction to Machine Learning ##
-This tutotial series aims to give you a general idea of what are machine learning algorithms and how could they be applied to your trading strategies. We start from supervised learning algorithms like the well-known neural network, support vehicle machine, etc. and then go to cover tree-based classifiers such as decision trees, random forest, etc. Next, we reach out to reinforcement learning and association rules. And in the end of this tutotial series, we introduce unsupervised learning, as well as heuristic algorithm. All of them play important roles in financial decisions.
-
-Unlike most teachings in textbooks, our tutorials keep from going deep into math which dampens readers' enthusiasm. Instead, we use simple and easy-to-understand examples to illustrate the complex logic behind each machine learning algorithm. We the display the APIs in Python to make these tools handy for you. Finally, we end each tutorial with a trading algorithm combining and applying what you've learned with real market data.
-
-
+ 
+ 
+ 
+ 
+ 
\ No newline at end of file
diff --git a/03 Open Source/01 Debugging Python/01 Introduction.html b/03 Open Source/01 Debugging Python/01 Introduction.html
new file mode 100644
index 0000000..ea57f4a
--- /dev/null
+++ b/03 Open Source/01 Debugging Python/01 Introduction.html
@@ -0,0 +1,7 @@
+
+
+
diff --git a/03 Open Source/01 Debugging Python/03 Method 1 - PTVSD.html b/03 Open Source/01 Debugging Python/03 Method 1 - PTVSD.html
new file mode 100644
index 0000000..4407bf1
--- /dev/null
+++ b/03 Open Source/01 Debugging Python/03 Method 1 - PTVSD.html
@@ -0,0 +1,57 @@
+
\ No newline at end of file
diff --git a/03 Open Source/01 Debugging Python/04 Method 2 - PDB.html b/03 Open Source/01 Debugging Python/04 Method 2 - PDB.html
new file mode 100644
index 0000000..a0d48d6
--- /dev/null
+++ b/03 Open Source/01 Debugging Python/04 Method 2 - PDB.html
@@ -0,0 +1,25 @@
+
diff --git a/03 Open Source/01 Debugging Python/05 Method 3 - VisualStudio Debugger.html b/03 Open Source/01 Debugging Python/05 Method 3 - VisualStudio Debugger.html
new file mode 100644
index 0000000..7767d5e
--- /dev/null
+++ b/03 Open Source/01 Debugging Python/05 Method 3 - VisualStudio Debugger.html
@@ -0,0 +1,25 @@
+
diff --git a/03 Open Source/01 Debugging Python/06 Limitations.html b/03 Open Source/01 Debugging Python/06 Limitations.html
new file mode 100644
index 0000000..f126eb5
--- /dev/null
+++ b/03 Open Source/01 Debugging Python/06 Limitations.html
@@ -0,0 +1,3 @@
+
+
\ No newline at end of file
diff --git a/03 Open Source/04 Lean Report Creator/01 Introduction.html b/03 Open Source/04 Lean Report Creator/01 Introduction.html
new file mode 100644
index 0000000..f5f8f98
--- /dev/null
+++ b/03 Open Source/04 Lean Report Creator/01 Introduction.html
@@ -0,0 +1,14 @@
+
+
diff --git a/03 Open Source/04 Lean Report Creator/02 Creating a Report.html b/03 Open Source/04 Lean Report Creator/02 Creating a Report.html
new file mode 100644
index 0000000..a2ea27a
--- /dev/null
+++ b/03 Open Source/04 Lean Report Creator/02 Creating a Report.html
@@ -0,0 +1,50 @@
+
+
+
\ No newline at end of file
diff --git a/03 Open Source/04 Lean Report Creator/04 Customizing Report Contents.html b/03 Open Source/04 Lean Report Creator/04 Customizing Report Contents.html
new file mode 100644
index 0000000..7c86acc
--- /dev/null
+++ b/03 Open Source/04 Lean Report Creator/04 Customizing Report Contents.html
@@ -0,0 +1,24 @@
+
+
+
+
+
+
+
+
diff --git a/03 Open Source/06 Generating Random Backtest Data/01 Introduction.html b/03 Open Source/06 Generating Random Backtest Data/01 Introduction.html
new file mode 100644
index 0000000..51fc885
--- /dev/null
+++ b/03 Open Source/06 Generating Random Backtest Data/01 Introduction.html
@@ -0,0 +1,2 @@
+
+
+
diff --git a/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/05 Summary.html b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/05 Summary.html
new file mode 100755
index 0000000..cfa134a
--- /dev/null
+++ b/04 Strategy Library/02 Combining Mean Reversion and Momentum in Forex Market/05 Summary.html
@@ -0,0 +1,3 @@
+
+
+
+
+
+
+
+
+
diff --git "a/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/04 \347\273\223\346\236\234.cn.html" "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/04 \347\273\223\346\236\234.cn.html"
new file mode 100644
index 0000000..9361eda
--- /dev/null
+++ "b/04 Strategy Library/07 Intraday Dynamic Pairs Trading using Correlation and Cointegration Approach/04 \347\273\223\346\236\234.cn.html"
@@ -0,0 +1,20 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/03 Method.html b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/03 Method.html
new file mode 100644
index 0000000..ecac338
--- /dev/null
+++ b/04 Strategy Library/1023 Intraday Arbitrage Between Index ETFs/03 Method.html
@@ -0,0 +1,129 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
diff --git a/05 Introduction to Financial Python[]/07 Random Variables and Distributions/05 Summary.html b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/05 Summary.html
new file mode 100755
index 0000000..1b84d06
--- /dev/null
+++ b/05 Introduction to Financial Python[]/07 Random Variables and Distributions/05 Summary.html
@@ -0,0 +1,3 @@
+
+
+
+
+
+
diff --git a/05 Introduction to Financial Python[]/09 Simple Linear Regression/04 Parameter Significance.html b/05 Introduction to Financial Python[]/09 Simple Linear Regression/04 Parameter Significance.html
new file mode 100755
index 0000000..5f85774
--- /dev/null
+++ b/05 Introduction to Financial Python[]/09 Simple Linear Regression/04 Parameter Significance.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/05 Introduction to Financial Python[]/13 Market Risk/04 Market-Neutral.html b/05 Introduction to Financial Python[]/13 Market Risk/04 Market-Neutral.html
new file mode 100755
index 0000000..286f056
--- /dev/null
+++ b/05 Introduction to Financial Python[]/13 Market Risk/04 Market-Neutral.html
@@ -0,0 +1,53 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/Tutorial Series/Introduction to Options/Tutorial04 Stochastic Processes and Monte Carlo Method.ipynb b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/04 Stochastic Processes and Monte Carlo Method.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Options/Tutorial04 Stochastic Processes and Monte Carlo Method.ipynb
rename to 06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/04 Stochastic Processes and Monte Carlo Method.ipynb
diff --git a/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/05 Monte Carlo Simulation of European Options.html b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/05 Monte Carlo Simulation of European Options.html
new file mode 100755
index 0000000..5a438a9
--- /dev/null
+++ b/06 Introduction to Options[]/04 Stochastic Processes and Monte Carlo Method/05 Monte Carlo Simulation of European Options.html
@@ -0,0 +1,37 @@
+
+
+
+
+
+
diff --git a/06 Introduction to Options[]/06 The Greek Letters/06 Rho.html b/06 Introduction to Options[]/06 The Greek Letters/06 Rho.html
new file mode 100755
index 0000000..85c4d45
--- /dev/null
+++ b/06 Introduction to Options[]/06 The Greek Letters/06 Rho.html
@@ -0,0 +1,37 @@
+
diff --git a/Tutorial Series/Introduction to Options/Tutorial06 The Greek Letters.ipynb b/06 Introduction to Options[]/06 The Greek Letters/06 The Greek Letters.ipynb
old mode 100644
new mode 100755
similarity index 100%
rename from Tutorial Series/Introduction to Options/Tutorial06 The Greek Letters.ipynb
rename to 06 Introduction to Options[]/06 The Greek Letters/06 The Greek Letters.ipynb
diff --git a/06 Introduction to Options[]/06 The Greek Letters/07 Delta, Gamma and Vega Hedging.html b/06 Introduction to Options[]/06 The Greek Letters/07 Delta, Gamma and Vega Hedging.html
new file mode 100644
index 0000000..d087dfa
--- /dev/null
+++ b/06 Introduction to Options[]/06 The Greek Letters/07 Delta, Gamma and Vega Hedging.html
@@ -0,0 +1,6 @@
+
+
+
+
diff --git a/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/05 Volatility Surface.html b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/05 Volatility Surface.html
new file mode 100755
index 0000000..057ec70
--- /dev/null
+++ b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/05 Volatility Surface.html
@@ -0,0 +1,8 @@
+
+
diff --git a/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/06 The Reason for Volatility Skew.html b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/06 The Reason for Volatility Skew.html
new file mode 100755
index 0000000..3312b4b
--- /dev/null
+++ b/06 Introduction to Options[]/07 Historical Volatility and Implied Volatility/06 The Reason for Volatility Skew.html
@@ -0,0 +1,5 @@
+
diff --git a/07 Applied Options[]/01 Covered Call/02 Implementation.html b/07 Applied Options[]/01 Covered Call/02 Implementation.html
new file mode 100755
index 0000000..a4bcc62
--- /dev/null
+++ b/07 Applied Options[]/01 Covered Call/02 Implementation.html
@@ -0,0 +1,57 @@
+
+
+
+
diff --git a/07 Applied Options[]/05 Butterfly Spread/02 Implementation.html b/07 Applied Options[]/05 Butterfly Spread/02 Implementation.html
new file mode 100755
index 0000000..99e677e
--- /dev/null
+++ b/07 Applied Options[]/05 Butterfly Spread/02 Implementation.html
@@ -0,0 +1,57 @@
+
+
+
+
+
+
+
+
+Tasks start their contents divided by subtitle using the 
-
-Each data file has a unique URL to download the data for the day which will get a LEAN formatted CSV zip. By using the API File Downloader we check if you have the file in your data-folder; and if not we attempt to download it from the API. This assumes you have already added the data to your repository through the web interface.
-
-This requires 2 key changes to the config.json file in the QuantConnect.Lean.Launcher Project:
-
-
-From these results we can say the limited sample size does not impair the feasibility of this model. The t-stats of the coefficients are -4.074 and 1.417 for the reversal factor and momentum factor respectively. The p-value of the reversal factor is very small which means this factor has a very high significance level.
-
-The compound annual returns are quite stable, however, the paper claimed that the average return is 27.5% vs our 11% achieved. This difference can be accounted for by the data time span and currency pairs.
-![dual thrust price range”/>
-
-In order to calculate the range, each trading day we need the close, high and low price data over the most recent N days. In addition, the open price of the current day is required in order to generate the signals. QuantConnect provides History(Symbol, TimeSpan, Resolution) method to get the history data like open, close, high and low for all configured securities over the requested N-days time span. Then the range is calculated by \[range = max(HH-LC, HC-LL)\]. In this implementation we choose N=4. It is less than one week and the range would reflect the recent price change.
-<pre class=](images/dual thrust price range.png)
history = self.History([self.syl.Value], 4, Resolution.Daily)
- self.high = history.loc[self.syl.Value]['high']
- self.low = history.loc[self.syl.Value]['low']
- self.close = history.loc[self.syl.Value]['close']
-
-
holdings = self.Portfolio[self.syl].Quantity
- if self.Portfolio[self.syl].Price >= self.selltrig:
- if holdings >= 0:
- self.SetHoldings(self.syl, 1)
- else:
- self.Liquidate(self.syl)
- self.SetHoldings(self.syl, 1)
- elif self.Portfolio[self.syl].Price < self.selltrig: if holdings >= 0:
- self.Liquidate(self.syl)
- self.SetHoldings(self.syl, -1)
- else:
- self.SetHoldings(self.syl, -1)
-
-
-The upper part of the following chart plots the stock prices of pair ING vs TCB. The lower part plots by how many times standard deviation the residual deviate from its mean. There are 5 trading opportunities if we set the opening threshold to be 2.32.
-
-
-
-The following chart is the density plot of the residual error. From the shape we can see the error is approximately normal distributed.
-
-
-
-Backtesting Result
-
-The strategy is considered to be market neutral strategy because it a long/short strategy betting on price convergence. Out backtested beta is -0.112, which is within our expectation.
-
-Theoretically, the higher resolution we use, the higher win rate is because on one hand the higher resolution would increase the number of datapoint in our training period, which would make it's harder to past the two-stage test; on the other hand the higher resolution data would let us capture minor profit more accurately. However, there is a trade off between performance and backtesting time. The higher resolution will lead backtesting time to increase drastically.
-
-The number of stocks in the initialize step would also affect our performance. Theoretically, the more stock we have, we better pairs we are likely to pick. But too many stocks would also be time consuming.
-
-what's worth mentioning is that the optimized parameters are different for each sector. It depends on the features of the price patterns in the specific industry. Plotting the pairs prices and the residual to observe is good option to adjust the thresholds.
-
Out-of-sample EUR/USD Trend Estimation
-
-![out-of-sample-trend-estimation”/> Step 2: Setting up the Moving Average Rule</h3>
-
-Moving average (MA) rules are very commonly used to generate buy and sell signals from data on the spot exchange rate. The MA rule compares a short-run moving average of the current and lagged exchange rate with a long-run moving average.
-
-\[MA(m,n)=\frac{1}{m}\sum_{i=0}^{m-1}S_{t-i}-\frac{1}{n}\sum_{i=0}^{n-1}S_{t-i}\]
-
-
-For HP filter, the non-linear trend is estimated recursively as the paper did. The initial estimation was undertaken using 3 years history data before 2011. The estimation period is then rolled forward each day through the trading period from January 2011 to May 2017.
-
-<h3>Step 3: Generating the Trading Signals</h3>
-We generate buy and sell signals by applying an MA(1, 2) rule to the estimated low-frequency component. For MA(m,n), m must be 1 which denotes the current value of low-frequency component. n should be small since large n would generate large time lag, the judgment of turning points is not accurate.
-
-A buy signal is generated when the current day’s low-frequency trend is higher than the last day’s low-frequency trend and a sell signal is generated when it is lower.
-<pre class=](images/out-of-sample-trend-estimation.jpg)
def OnData(self,data):
- self.close.append(self.Portfolio[self.syl].Price)
- self.hpfilter(self.close[-self.numdays:len(self.close)+1], 100)
- self.MA_rules_today = (np.mean(self.trend[-self.m : len(self.trend)]) - np.mean(self.trend[-self.n : len(self.trend)]))
- self.MA_rules_yesterday = (np.mean(self.trend[-self.m-1: len(self.trend)-1]) - np.mean(self.trend[-self.n-1 : len(self.trend)-1]))
- holdings = self.Portfolio[self.syl].Quantity
-
- if self.MA_rules_today > 0 and self.MA_rules_yesterday < 0:
- self.SetHoldings(self.syl, 1)
- elif self.MA_rules_today < 0 and self.MA_rules_yesterday > 0:
- self.SetHoldings(self.syl, -1)
-
-
Trading Signals when λ=100
-
-
-The above charts are the in-sample trading signals after applying MA rules on the low-frequency component. The trend curve is more smooth with larger λ. Thus when we applied MA rules, a less smooth trend will trigger more trading opportunities.
-
-
-
-From the payoff plot we can see, the maximum profit of the strategy is the difference between call option strike price sold and call option strike price purchased minus the difference between buying lower strike call premium and selling higher strike call premium.
-
-Given this plot, if the stock price moves sharply at the expiration either up or down, the Long Straddle will collect positive profit. the potential profit is unlimited on the upside because the stock price can rise indefinitely. On the downside, the potential profit is substantial, because the stock price can fall to zero. The potential loss is limited to the premium of both call and put options. The maximum loss will be reached if the stock price is exactly equal to the strike price at expiration. Both options will expire worthless.
-
-
-
-Here the strike price is A(750), B(760), C(850) and D(860). From the payoff plot, the maximum profit all come from the options premium because the deeper OTM options are cheaper than the less deep ones. It is reached when the stock price is between higher put strike and lower call strike. They are two short positions. In this condition, all the options expire worthless. The maximum loss of Iron Condor is reached when the stock price is lower than the lowest strike A, then the two call options become worthless, the two puts are in the money. For the other condition, the stock price is higher than the highest strike D.Consequently, The two call options are in the money but the two puts expire worthless.
-
-From the payoff plot, the maximum gain is simply the net credit you received when you buy and sell 4 options. This occurs if the stock price is exactly the same as the strike price of ATM options. In this condition, all options expire worthless and you keep all premiums received. We can see the Iron Butterfly has more narrow structures than the Iron Condor. However, the profit can be higher than with the Iron Condor as you receive more premium by selling ATM options than OTM options.
-
-The maximum loss occurs if the underlying price is either below the OTM put strike or above the OTM call strike. In these two conditions, two puts or two calls are exercised and the other two options expire worthless.
-
-
-According to the payoff plot, the maximum profit is the strike price of short call minus the purchase price of the underlying asset add the net credit from the premium. It occurs when the stock price is beyond the strike price of the short call option. The maximum loss is the purchase price of the underlying asset minus the strike price of the long put minus the net credit from the premium. It occurs when the stock price is below the strike price of the long put. It is a strategy with limit risk and limit profit.
-
-Let's say we want to know the frequency that the observations are less than or equal to 3. In other words we want to seek the value of \(P(X<3)\).
-
-Another good property of binomial distribution is that its mean and variance are simple enough:
-\[\bar{u} = np\]
-\[\sigma^2 = np(1-P)\]
-We will not introduce the deduction here, but if you are interested in it, we encourage you to do it yourself, based on the probability functions we provided above.
-
-Financial data is highly disordered and is considered to has lots of noise. Most of the time we believe those noise follows normal distribution. It's also widely believed that the return on an asset over a short period of time follows normal distribution. Let's check it with the daily logarithm rates of return on SPY:
-
-This is a classic daily return chart. Let's now plot the density chart of the returns:
-
-If we observe the x-axis and y-axis carefully, we can see the return of asset is not a standard normal distribution. The peak of the standard normal distribution plot is around 0.4, while it's over 0.6 for this chart. This is because the standard deviation \(\sigma\) of the return is obviously not 1.
-We can demonstrate the normal distribution with different mean and variance by simulation:
-
-
-
-If we use 95% confidence interval, we need a p-value less than 0.025 to reject the null hypothesis. However, now our p-value is 0.025659, which is greater than 0.025, thus we can't reject the null hypothesis. It's obviously less than 0.05, so we can still reject the null hypothesis with 90% confidence level.
-Now let's test the hypothesis that population mean = 0 again with a large sample, which has 1200 observations:
-
-The plot is scattered, but we can see they are approximately correlated: generally the higher SPX's daily return is, the higher Amazon stock's return is. This is called positively correlated. We will cover it in the following tutorials.
-
-We built a simple linear regression model above by using the ols() function in statsmodels. The 'model' instance has lots of properties. The most commonly used one is parameters, or slope and intercept. We can access to them by:
-
-The red line is the fitted linear regression straight line.
-As we can see there are lot of statistical results in the summary table. Now let's talk about some important statistical parameters.
-
-
-The Fama-French 5-factor model has a higher \( R^2 \) of 0.387. We can compare the predictions from simple linear regression and Fama-French multiple regression by plotting them together on one chart:
-
-
-
-Although it's hard to see from the chart above, the predicted return from multiple regression is closer to the actual return. Usually we don't plot the predictions to determine which model is better; we read the summary table.
-
-
-
-As seen from the plot, the residual is normally distributed. By the way, the residual mean is always zero, up to machine precision:
-
-
-
-As seen from the chart, the residuals' variance doesn't increase with X. The three outliers do not change our conclusion. Although we can plot the residuals for simple regression, we can't do this for multiple regression, so we use statsmodels to test for heteroskedasticity:
-
-
-
-Notice that all points (i.e. stocks and portfolios) are enclosed by a hyperbola, known as the efficient frontier.
-
-All portfolios on the efficient frontier have the maximum expected return for a given level of risk, if we only consider portfolios of risky stocks. Can we achieve higher returns by including a riskless asset? Yes.
-
-
-
-Since we have fewer stocks to choose from, it's not too surprising that our maximum expected return is lower for any level of risk.
-
-This demonstrates why diversification is often said to be a "free lunch" in investing.
-
-
-
-The β of GE ranged from 0.1 to 0.5 approximately. This is why you need to be careful when using β. It makes no sense to talk about β without a timeframe in mind.
-
-The following graph is the rolling p-value of beta. The p-value stays close to zero most of the time. However, during some period it suddenly increased close to 0.1, which corresponds to a 90% confidence interval. This might be caused by some mispricing or market turmoil.
-
-
-
-
-
-How can we construct a market-neutral portfolio? Consider two stocks A and B:
-\[ R_A = R_0 + \beta_A (R_{\text{market}} - R_0) \]
-\[ R_B = R_0 + \beta_B (R_{\text{market}} - R_0) \]
-
-Let's allocate w on stock A and (1 − w) on stock B, then market neutrality means
-\[ w\beta_A + (1-w) \beta_B = 0 \qquad \Rightarrow \qquad
- w = \frac{\beta_B}{\beta_B - \beta_A} \]
-
-As mentioned earlier, \(\beta_A\) and \(\beta_B\) will change with time, so will \(w\) in a market-neutral portfolio. However we can achieve market neutrality with constant \(w\) so long as \(\beta_A\) and \(\beta_B\) have a linear relationship:
-\[ \beta_A = m\beta_B + c \]
-
-Then eliminate \(\beta_A\) to get
-\[ w = \frac{\beta_B}{(1-m) \beta_B - c} \]
-
-If c ≈ 0 then w is roughly constant:
-\[ w = \frac{1}{1-m} \]
-
-Note: If c is signficant, then we need 3 stocks to get zero net beta. Usually 2 stocks are sufficient to cancel out most of the market risk.
-
-
-
-The coefficient of SMB is positive, so when small caps outperform large caps, the Small Cap Index will have higher returns, which is not surprising. By comparing the t statistics of those factors, we know that MKT and SMB are more important factors driving the Small Cap Index.
-
-Results for US Large Cap returns:
-
-
-As expected, the coefficient of SMB is negative for the Large Cap Index. The coefficient of HML is quite low, which suggests that value and growth stocks take approximately the same weight in the Large Cap Index.
-
-
-
-The above payoff diagrams illustrate the cash payoff on an option at the expiration date. For a call option, the net payoff is negative if the price of the underlying asset is less than the strike price(The negative payoff comes from the premium). If the underlying price exceeds the strike price, the gross payoff is the price of the underlying asset minus the strike price and the premium. For a put option, the net payoff is positive if the underlying price is less than the strike price. If the price of the underlying asset exceeds the strike price, the gross payoff is negative because you pay premuim for purchasing the contracts.
-
-
-
-Then in our BSM model class, we will calculate the European call and put option prices by using BSM formula.
-
-
-The color of the graph above represents delta value.
-
-
-The color of the graph above represents delta value.
-
-The color of the graph above represents Vega.
-
-
-
-
-
-Plotting these implied volatilities across strikes gives us the implied volatility skew. For the shape of volatility smile, it should be a symmetry convex curve. But from the above chart, the implied volatility curve slope downward to the right. This is referred to the skew, which means that options with low strikes have higher implied volatilities than those with higher strikes. The smile is not symmetry. The skew of a distribution is a measure of its assymetry. Although the volatility skew is dynamic, in equity markets it is almost always a decreasing function of the strike. Other asset classes such as FX and commodities have differently shaped skews.
-If we plot the call and put options implied volatility smile in the same chart for the same expiration date:
-
-From the above chart, we can see the implied volatility for put options is higher than call options. Usually, put options trade for a higher price than call options, because traders place more risk in the short put positions, which raises the amount of reward they require to sell the position. Higher option prices signify an increase in risk and are represented by higher implied volatility levels derived from the option pricing model.
-Then we scattered all the implied volatilities of contracts across all the strikes.
-
-
-
-