仮想通貨って儲かるの？投資効率の最大化にチャレンジした話

#import libraries
from pandas_datareader import data
import pandas as pd
from pylab import mpl, plt
import numpy as np
import datetime
plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'serif'
get_ipython().run_line_magic('matplotlib', 'inline')

#make a DataFrame
df = pd.DataFrame()

#get price data from yahoo finance
def price_df(crypto, start, end):
    file = data.DataReader(crypto, 'yahoo', start, end)
    df['%s' % crypto] = file['Close']

#symbols of cryptocurrency
symbols = ['BTC-USD', 'ETH-USD', 'XRP-USD', 'BCH-USD', 'LTC-USD']

#date
start = '2019-01-01'
end = datetime.date.today()

#run to get price data
for sym in symbols:
    price_df(sym, start, end)

#check df as table
df.head()
df.tail()

#show a price chart
df.dropna().plot(figsize=(10, 6))
plt.legend(loc=0)
plt.xlabel('year')
plt.ylabel('price(USD)')
plt.savefig("crypto1.png")

#calculate 
rets = np.log(df / df.shift(1))

#show a return chart
rets.cumsum().apply(np.exp).plot(figsize=(10, 6))
plt.legend(loc=0)
plt.xlabel('year')
plt.ylabel('return')
plt.savefig("cypto2.png")

#show a return chart from 2019-01-01
rets.cumsum().apply(np.exp).loc['2019-01-01':].plot(figsize=(10, 6))
plt.legend(loc=0)
plt.xlabel('year')
plt.ylabel('return')
plt.savefig("cypto3.png")

import libraries
import math
import scipy.stats as scs
import statsmodels.api as sm

#calculate returns
log_returns = np.log(df / df.shift(1))
log_returns.head()

#show a qq plot
sm.qqplot(log_returns['BTC-USD'].dropna(), line='s')
plt.title('BTC-USD')
plt.xlabel('theoretical quantiles')
plt.ylabel('sample quantiles');
plt.savefig("cypto4.png")

#symbols of cryptocurrency
symbols = ['BTC-USD', 'ETH-USD', 'XRP-USD']
noa = len(symbols)

#get price data
data = df[symbols]
rets = np.log(data / data.shift(1))

#calculate return in a year
def port_ret(weights):
    return np.sum(rets.mean() * weights) * 252

#calculate volatility in a year
def port_vol(weights):
    return np.sqrt(np.dot(weights.T, np.dot(rets.cov() * 252, weights)))

#make plotting data
prets = []
pvols = []
for p in range(2500):
    weights = np.random.random(noa)
    weights /= np.sum(weights)
    prets.append(port_ret(weights))
    pvols.append(port_vol(weights))
prets = np.array(prets)
pvols = np.array(pvols)

#make a risk-return chart
plt.figure(figsize=(10, 6))
plt.scatter(pvols, prets, c=prets / pvols,
           marker='o', cmap='coolwarm')
plt.xlabel('expected volatility')
plt.ylabel('expected return')
plt.colorbar(label='Sharpe ratio');
plt.savefig("cypto5.png")

#import libraries
import scipy.optimize as sco

#calculate a sharpe ratio
def min_func_sharpe(weights):
    return -port_ret(weights) / port_vol(weights)

#restriction
cons = ({'type':'eq', 'fun':lambda x: np.sum(x) - 1})
bnds = tuple((0, 1) for x in range(noa))

#start point
eweights = np.array(noa * [1. / noa,])
eweights
min_func_sharpe(eweights)

#calculate a maximum sharp ratio
opts = sco.minimize(min_func_sharpe, eweights,
                   method='SLSQP', bounds=bnds,
                   constraints=cons)

#show the result
opts

#show the portfolio
opts['x'].round(3)

#show the return
port_ret(opts['x']).round(3)

#show the volatility
port_vol(opts['x']).round(3)

#show the sharpe ratio
port_ret(opts['x']) / port_vol(opts['x'])

#calculate the minimum volatility
optv = sco.minimize(port_vol, eweights,
                   method='SLSQP', bounds=bnds,
                   constraints=cons)
#show the result
optv

#show the portfolio
optv['x'].round(3)

#show the volatility
port_vol(optv['x']).round(3)

#show the return
port_ret(optv['x']).round(3)

#show the sharpe ratio
port_ret(optv['x']) / port_vol(optv['x'])

#restriction
cons = ({'type':'eq', 'fun':lambda x: port_ret(x) - tret},
       {'type':'eq', 'fun': lambda x: np.sum(x) - 1})
bnds = tuple((0, 1) for x in weights)

#claculate efficient frontier
trets = np.linspace(0.2, 0.58, 50)
tvols = []
for tret in trets:
    res = sco.minimize(port_vol, eweights, method='SLSQP',
                     bounds=bnds, constraints=cons)
    tvols.append(res['fun'])
tvols = np.array(tvols)")

#show a efficient frontier chart
plt.figure(figsize=(10, 6))
plt.scatter(pvols, prets, c=prets / pvols,
           marker='.', alpha=0.8, cmap='coolwarm')
plt.plot(tvols, trets, 'b', lw=4.0)
plt.plot(port_vol(opts['x']), port_ret(opts['x']),
        'y*', markersize=15.0)
plt.plot(port_vol(optv['x']), port_ret(optv['x']),
        'r*', markersize=15.0)
plt.xlabel('expected volatility')
plt.ylabel('expected return')
plt.colorbar(label='Sharpe ratio')
plt.savefig("cypto6.png");