update

Author: gsamarakoon

Bollinger bands yahoo finance.ipynb

@@ -0,0 +1,33 @@
+import pandas_datareader as pdr
+from pandas_datareader import data, wb
+from datetime import date
+import numpy as np
+import pandas as pd
+from scipy import log,exp,sqrt,stats
+
+def blackscholes_call(S,E,T,rf,sigma):
+	#first we have to calculate d1 and d2 parameters
+	d1=(log(S/E)+(rf+sigma*sigma/2.0)*T)/(sigma*sqrt(T))
+	d2 = d1-sigma*sqrt(T)
+	print(d1)
+	print(d2)
+	#we need N(x) normal distribution function
+	return S*stats.norm.cdf(d1)-E*exp(-rf*T)*stats.norm.cdf(d2)
+
+def blackscholes_put(S,E,T,rf,sigma):
+	#first we have to calculate d1 and d2 parameters
+	d1=(log(S/E)+(rf+sigma*sigma/2.0)*T)/(sigma*sqrt(T))
+	d2 = d1-sigma*sqrt(T)
+	#we need N(x) normal distribution function
+	return -S*stats.norm.cdf(-d1)+E*exp(-rf*T)*stats.norm.cdf(-d2)
+	
+if __name__ == "__main__":
+	
+	S0=100      #underlying stock price at t=0
+	E=100		#strike price
+	T = 1		#expiry 1=1year=365days
+	rf = 0.05 	#risk-free rate
+	sigma=0.2	#volatility of the underlying stock
+	
+	print("Call option price according to Black-Scholes model: ",blackscholes_call(S0,E,T,rf,sigma))
+	print("Put option price according to Black-Scholes model: ",blackscholes_put(S0,E,T,rf,sigma))

Quant Finance and Algo Trading/blackscholes.py

@@ -0,0 +1,70 @@
+import numpy as np
+import math
+import time
+ 
+class OptionPricing:
+    
+	def __init__(self,S0,E,T,rf,sigma,iterations):
+		self.S0 = S0
+		self.E = E
+		self.T = T
+		self.rf = rf
+		self.sigma = sigma     
+		self.iterations = iterations 
+ 
+	def call_option_simulation(self):
+		
+		#we have 2 columns: first with 0s the second column will store the payoff
+		#we need the first column of 0s: payoff function is max(0,S-E) for call option
+		option_data = np.zeros([self.iterations, 2])
+		
+		#dimensions: 1 dimensional array with as many items as the itrations
+		rand = np.random.normal(0, 1, [1, self.iterations])
+		
+		#equation for the S(t) stock price
+		stock_price = self.S0*np.exp(self.T*(self.rf - 0.5*self.sigma**2)+self.sigma*np.sqrt(self.T)*rand)
+ 
+		#we need S-E because we have to calculate the max(S-E,0)
+		option_data[:,1] = stock_price - self.E   
+        
+		#average for the Monte-Carlo method
+		#np.amax() returns the max(0,S-E) according to the formula
+		average = np.sum(np.amax(option_data, axis=1))/float(self.iterations)
+ 
+		#have to use the exp(-rT) discount factor
+		return np.exp(-1.0*self.rf*self.T)*average
+		
+	def put_option_simulation(self):
+	
+		#we have 2 columns: first with 0s the second column will store the payoff
+		#we need the first column of 0s: payoff function is max(0,E-S) for put option
+		option_data = np.zeros([self.iterations, 2])
+		
+		#dimensions: 1 dimensional array with as many items as the itrations
+		rand = np.random.normal(0, 1, [1, self.iterations])
+		
+		#equation for the S(t) stock price
+		stock_price = self.S0*np.exp(self.T*(self.rf - 0.5*self.sigma**2)+self.sigma*np.sqrt(self.T)*rand)
+ 
+		#we need E-S because we have to calculate the max(E-S,0)
+		option_data[:,1] = self.E - stock_price  
+        
+		#average for the Monte-Carlo method
+		#np.amax() returns the max(0,E-S) according to the formula
+		average = np.sum(np.amax(option_data, axis=1))/float(self.iterations)
+ 
+		#have to use the exp(-rT) discount factor
+		return np.exp(-1.0*self.rf*self.T)*average
+
+if __name__ == "__main__":
+	
+	S0=100					#underlying stock price at t=0
+	E=100					#strike price
+	T = 1					#expiry
+	rf = 0.05				#risk-free rate
+	sigma=0.2				#volatility of the underlying stock
+	iterations = 1000000	#number of iterations in the Monte-Carlo simulation	
+	
+	model = OptionPricing(S0,E,T,rf,sigma,iterations)
+	print("Call option price with Monte-Carlo approach: ", model.call_option_simulation()) 
+	print("Put option price with Monte-Carlo approach: ", model.put_option_simulation())

Quant Finance and Algo Trading/blackscholes_montecarlo.py

@@ -0,0 +1,19 @@
+from math import exp
+
+def zero_bond_price(par_value,market_rate,n):
+	return par_value/(1+market_rate)**n
+	
+def bond_price(par_value,coupon, market_rate,n):
+	c = par_value*coupon
+	return c/market_rate*(1-(1/(1+market_rate)**n))+par_value/(1+market_rate)**n
+	
+if __name__ == "__main__":
+    
+	par_value=1000   #par value of the bond
+	coupon=0.05		 #bond yield - coupon 
+	n=3	 			 #years
+	market_rate=0.04 #market rate of return
+	
+	print("Price of the zero-coupon bond: $%0.2f" % zero_bond_price(par_value,market_rate,n))
+	print("Price of the coupon bond: $%0.2f" % bond_price(par_value,coupon,market_rate,n))
+	

Quant Finance and Algo Trading/bond_pricing.py

@@ -0,0 +1,59 @@
+import pandas_datareader as pdr
+from pandas_datareader import data, wb
+from datetime import date
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+
+risk_free_rate = 0.05
+
+def capm(start_date, end_date, ticker1, ticker2):
+
+	#get the data from Yahoo Finance
+	stock1 = pdr.get_data_yahoo(ticker1, start_date, end_date)
+	stock2 = pdr.get_data_yahoo(ticker2, start_date, end_date)
+    
+	#we prefer monthly returns instead of daily returns
+	return_stock1 = stock1.resample('M').last()
+	return_stock2 = stock2.resample('M').last()
+
+	#creating a dataFrame from the data - Adjusted Closing Price is used as usual
+	data = pd.DataFrame({'s_adjclose' : return_stock1['Adj Close'], 'm_adjclose' : return_stock2['Adj Close']}, index=return_stock1.index)
+	#natural logarithm of the returns
+	data[['s_returns', 'm_returns']] = np.log(data[['s_adjclose','m_adjclose']]/data[['s_adjclose','m_adjclose']].shift(1))
+	#no need for NaN/missing values values so let's get rid of them
+	data = data.dropna()
+
+	#covariance matrix: the diagonal items are the vairances - off diagonals are the covariances
+	#the matrix is symmetric: cov[0,1] = cov[1,0] !!!
+	covmat = np.cov(data["s_returns"], data["m_returns"])
+	print(covmat)
+	
+	#calculating beta according to the formula
+	beta = covmat[0,1]/covmat[1,1]
+	print("Beta from formula:", beta)
+
+	#using linear regression to fit a line to the data [stock_returns, market_returns] - slope is the beta
+	beta,alpha = np.polyfit(data["m_returns"], data['s_returns'], deg=1)
+	print("Beta from regression:", beta)
+	
+	#plot
+	fig,axis = plt.subplots(1,figsize=(20,10))
+	axis.scatter(data["m_returns"], data['s_returns'], label="Data points")
+	axis.plot(data["m_returns"], beta*data["m_returns"] + alpha, color='red', label="CAPM Line")
+	plt.title('Capital Asset Pricing Model, finding alphas and betas')
+	plt.xlabel('Market return $R_m$', fontsize=18)
+	plt.ylabel('Stock return $R_a$')
+	plt.text(0.08, 0.05, r'$R_a = \beta * R_m + \alpha$', fontsize=18)
+	plt.legend()
+	plt.grid(True)
+	plt.show()
+	
+	#calculate the expected return according to the CAPM formula
+	expected_return = risk_free_rate + beta*(data["m_returns"].mean()*12-risk_free_rate)
+	print("Expected return:", expected_return)
+
+if __name__ == "__main__":
+	#using historical data 2010-2017: the market is the S&P500 !!!
+	capm('2010-01-01', '2017-01-01','IBM', '^GSPC')
+	

Quant Finance and Algo Trading/capm.py

@@ -0,0 +1,15 @@
+import numpy as np
+import pandas_datareader.data as web
+import matplotlib.pyplot as plt
+
+stocks = ['AAPL']
+
+start_date='01/01/2001'
+end_date='01/01/2017'
+
+data = web.DataReader(stocks, data_source='yahoo', start=start_date, end=end_date)['Adj Close']
+
+daily_returns = (data/data.shift(1))-1
+
+daily_returns.hist(bins=100)
+plt.show()

Quant Finance and Algo Trading/fetch_data_normal.py

@@ -0,0 +1,115 @@
+from __future__ import print_function
+
+import datetime
+import numpy as np
+import pandas as pd
+import sklearn
+import pandas_datareader.data as web
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import confusion_matrix
+from sklearn.svm import LinearSVC, SVC
+
+
+def create_lagged_series(symbol, start_date, end_date, lags=5):
+    """
+    This creates a pandas DataFrame that stores the 
+    percentage returns of the adjusted closing value of 
+    a stock obtained from Yahoo Finance, along with a 
+    number of lagged returns from the prior trading days 
+    (lags defaults to 5 days). Trading volume, as well as 
+    the Direction from the previous day, are also included.
+    """
+
+    # Obtain stock information from Yahoo Finance
+    ts = web.DataReader(
+    	symbol, "yahoo", 
+    	start_date-datetime.timedelta(days=365), 
+    	end_date
+    )
+
+    # Create the new lagged DataFrame
+    tslag = pd.DataFrame(index=ts.index)
+    tslag["Today"] = ts["Adj Close"]
+    tslag["Volume"] = ts["Volume"]
+
+    # Create the shifted lag series of prior trading period close values
+    for i in range(0, lags):
+        tslag["Lag%s" % str(i+1)] = ts["Adj Close"].shift(i+1)
+
+    # Create the returns DataFrame
+    tsret = pd.DataFrame(index=tslag.index)
+    tsret["Volume"] = tslag["Volume"]
+    tsret["Today"] = tslag["Today"].pct_change()*100.0
+
+    # If any of the values of percentage returns equal zero, set them to
+    # a small number (stops issues with QDA model in scikit-learn)
+    for i,x in enumerate(tsret["Today"]):
+        if (abs(x) < 0.0001):
+            tsret["Today"][i] = 0.0001
+
+    # Create the lagged percentage returns columns
+    for i in range(0, lags):
+        tsret["Lag%s" % str(i+1)] = \
+        tslag["Lag%s" % str(i+1)].pct_change()*100.0
+
+    # Create the "Direction" column (+1 or -1) indicating an up/down day
+    tsret["Direction"] = np.sign(tsret["Today"])
+    tsret = tsret[tsret.index >= start_date]
+
+    print(tsret)
+	
+    return tsret
+
+
+if __name__ == "__main__":
+    # Create a lagged series of the S&P500 US stock market index
+    snpret = create_lagged_series(
+    	"^GSPC", datetime.datetime(2001,1,10), 
+    	datetime.datetime(2005,12,31), lags=5
+    )
+
+    # Use the prior two days of returns as predictor 
+    # values, with direction as the response
+    X = snpret[["Lag1","Lag2"]]
+    y = snpret["Direction"]
+
+    # The test data is split into two parts: Before and after 1st Jan 2005.
+    start_test = datetime.datetime(2005,1,1)
+
+    # Create training and test sets
+    X_train = X[X.index < start_test]
+    X_test = X[X.index >= start_test]
+    y_train = y[y.index < start_test]
+    y_test = y[y.index >= start_test]
+   
+    # Create the (parametrised) models
+    print("Hit Rates/Confusion Matrices:\n")
+    models = [("LR", LogisticRegression()),                    
+              ("LSVC", LinearSVC()),
+              ("RSVM", SVC(
+              	C=1000000.0, cache_size=200, class_weight=None,
+                coef0=0.0, degree=3, gamma=0.0001, kernel='rbf',
+                max_iter=-1, probability=False, random_state=None,
+                shrinking=True, tol=0.001, verbose=False)
+              ),
+              ("RF", RandomForestClassifier(
+              	n_estimators=1000, criterion='gini', 
+                max_depth=None, min_samples_split=2, 
+                min_samples_leaf=1, max_features='auto', 
+                bootstrap=True, oob_score=False, n_jobs=1, 
+                random_state=None, verbose=0)
+              )]
+
+    # Iterate through the models
+    for m in models:
+        
+        # Train each of the models on the training set
+        m[1].fit(X_train, y_train)
+
+        # Make an array of predictions on the test set
+        pred = m[1].predict(X_test)
+
+        # Output the hit-rate and the confusion matrix for each model
+        print("%s:\n%0.3f" % (m[0], m[1].score(X_test, y_test)))
+        print("%s\n" % confusion_matrix(pred, y_test))