In [1]:
%matplotlib inline
In [2]:
import numpy as np
import pandas as pd
# 統計用ツール
import statsmodels.api as sm
import statsmodels.tsa.api as tsa
from patsy import dmatrices
#描画
import matplotlib.pyplot as plt
from pandas.tools.plotting import autocorrelation_plot
#株価
import pandas as pd
import pandas.io.data as web
#深層学習
import chainer
from chainer import cuda, Function, gradient_check, Variable, optimizers, serializers, utils
from chainer import Link, Chain, ChainList
import chainer.functions as F
import chainer.links as L
#k平均法
from sklearn.cluster import KMeans
In [3]:
import datetime
import numpy as np
import pandas as pd
import pandas.io.data as web
import quandl
def setdata(s, e, t='Adj Close'):
start = datetime.datetime(s[0], s[1], s[2])
end = datetime.datetime(e[0], e[1], e[2])
N225 = web.DataReader('^N225', 'yahoo', start, end)[t]
DJI = web.DataReader('^DJI', 'yahoo', start, end)[t]
IXIC = web.DataReader('^IXIC', 'yahoo', start, end)[t]
jpy = web.DataReader('DEXJPUS', 'fred')
jpy = jpy.ix[start:end]
usdjpy = quandl.get("BOE/XUDLJYD", start_date=start, end_date=end).assign(
USDJPY_roc = lambda df: df["Value"].pct_change()
).rename(columns={
"Value" : "USDJPY"
})
eurjpy = quandl.get("BOE/XUDLBK63", start_date=start, end_date=end).assign(
EURJPY_roc = lambda df: df["Value"].pct_change()
).rename(columns={
"Value" : "EURJPY"
})
gbpjpy = quandl.get("BOE/XUDLJYS", start_date=start, end_date=end).assign(
EURJPY_roc = lambda df: df["Value"].pct_change()
).rename(columns={
"Value" : "GBPJPY"
})
usdjpy = usdjpy["USDJPY"]
eurjpy = eurjpy["EURJPY"]
gbpjpy = gbpjpy["GBPJPY"]
dataframe = pd.concat([N225, DJI, IXIC, usdjpy, eurjpy, gbpjpy], axis=1).dropna()
datas = np.array(dataframe)
target = datas.T[0]
return datas, target
In [4]:
s = (1990, 1, 1)
e = (2015, 9, 30)
t = 'Adj Close'
start = datetime.datetime(s[0], s[1], s[2])
end = datetime.datetime(e[0], e[1], e[2])
SaP = web.DataReader('GSPC', 'yahoo', start, end)[t]
N225 = web.DataReader('^N225', 'yahoo', start, end)[t]
DJI = web.DataReader('^DJI', 'yahoo', start, end)[t]
IXIC = web.DataReader('^IXIC', 'yahoo', start, end)[t]
In [5]:
SaP = np.array([SaP[1:].values - SaP[:-1].values]).T*100
In [6]:
kms = KMeans(n_clusters=3).fit_predict(SaP)
mean1 = SaP[kms == 0].mean()
var1 = SaP[kms == 0].var()
mean2 = SaP[kms == 1].mean()
var2 = SaP[kms == 1].var()
mean3 = SaP[kms == 2].mean()
var3 = SaP[kms == 2].var()
for t in range(100):
f = SaP[t:t+20]
v = np.array([])
for i in range(20):
v1 = np.round(np.exp(-1*(f[i] - mean1)**2/var1), 5)
v2 = np.round(np.exp(-1*(f[i] - mean2)**2/var2), 5)
v3 = np.round(np.exp(-1*(f[i] - mean3)**2/var3), 5)
v = np.append(v, v1)
v = np.append(v, v2)
v = np.append(v, v3)
if t != 0:
fs = np.c_[fs, v]
else:
fs = np.array([v]).T
In [7]:
class AE(Chain):
def __init__(self):
super(AE, self).__init__(
l1 = L.Linear(60, 20),
l2 = L.Linear(20, 60),
)
def __call__(self, x):
bv, fv = self.fwd(x)
loss = F.mean_squared_error(bv, x)
return loss
def fwd(self, x):
fv = F.sigmoid(self.l1(x))
bv = self.l2(fv)
return bv, fv
In [8]:
for i in range(1000):
ft = np.array([fs[:,0]], dtype='float32')
model = AE()
optimizer = optimizers.SGD()
optimizer.setup(model)
n = 60
bs = 5
for j in range(10):
x = Variable(ft)
model.zerograds()
loss = model(x)
loss.backward()
optimizer.weight_decay(0.0005)
optimizer.update()
if i != 0:
Ft = model.fwd(x)[1].data
Fs = np.append(Fs, Ft, axis=0)
else:
Fs = model.fwd(x)[1].data
In [9]:
class CAR(Chain):
def __init__(self, unit1, unit2, unit3, col_num):
super(CAR, self).__init__(
l1 = L.Linear(col_num, unit1),
l2 = L.Linear(self.unit1, self.unit1),
l3 = L.Linear(self.unit1, self.unit2),
l4 = L.Linear(self.unit2, self.unit3),
l5 = L.Linear(self.unit3, self.unit3),
l6 = L.Linear(self.unit3, 1),
)
def __call__(self, x, y):
fv = self.fwd(x, y)
loss = F.mean_squared_error(fv, y)
return loss
def fwd(self, x, y):
h1 = F.sigmoid(self.l1(x))
h2 = F.sigmoid(self.l2(h1))
h3 = F.sigmoid(self.l3(h2))
h4 = F.sigmoid(self.l4(h3))
h5 = F.sigmoid(self.l5(h4))
h6 = self.l6(h5)
return h6
In [71]:
class RNN(chainer.Chain):
def __init__(self):
super(RNN, self).__init__(
w = L.Linear(20, 1),
b = L.Linear(1, 1),
u = L.Linear(1, 1),
)
def __call__(self, Fs):
dUt = 0
d_1 = Variable(np.zeros((1, 1), dtype=np.float32))
old_grad = np.array([np.zeros(21)], dtype='float32')
one = Variable(np.array([[1]], dtype=np.float32))
zero = Variable(np.array([[0]], dtype=np.float32))
U = Variable(np.array([[0]], dtype=np.float32))
for i in range(len(Fs[:, 0])):
x_k = Variable(np.array([Farray[i]], dtype=np.float32))
d = F.tanh(self.w(x_k) + self.b(one) + self.u(d_1))
z = Variable(np.array([[Farray[i][-1]]], dtype=np.float32))
R = F.forget(f, d, d_1, z)
R.data = [[0]] if R.data[0][0] == 'nan' else R.data
self.g = R
U = U.__radd__(R)
d_1 = d
loss = F.mean_squared_error(U.__pow__(1/2), zero)
return loss
In [72]:
def f(d, d_1, z):
c = 100
R = d_1.__rmatmul__(z) - c*(d - d_1).__abs__()
return R
In [73]:
model = RNN()
optimizer = optimizers.SGD()
optimizer.setup(model)
Farray = Fs
c = 1
c0 = 10
dU = 0
rho = 1
while True:
rho_c = min(rho, rho**(c0/c))
x = Variable(Fs)
loss = model(x)
loss.backward()
optimizer.update()
c += 1
if c == 10:
break
In [92]:
nan
Out[92]:
In [79]:
nan = model.g.data[0][0]
In [96]:
model.g.data
Out[96]:
In [87]:
type(nan)
Out[87]:
In [ ]:
loss.data = np.array(10.0, dtype=np.float32)
In [ ]:
loss.__pow__(1/2).data
In [ ]:
while True:
rho_c = min(rho, rho**(c0/c))
x = Variable(Fs)
dU = model(x, rho_c)
c += 1
if c == 1000:
break
if sum(abs(dU[0]) > 0.1) == 0:
break
In [ ]:
dU
In [ ]:
for i in range(100):
x = Variable(Fs)
loss = model(x)
In [ ]:
loss
In [ ]:
s = Variable(np.array([[1]], dtype=np.float32))
t = Variable(np.array([[1]], dtype=np.float32).T)
j = Variable(np.array([[0.46143287]], dtype=np.float32).T)
R = F.forget(f, s, t, j)
R.backward()
s.grad
In [ ]:
t.grad
In [ ]:
j.grad
In [ ]:
h = t.__rmatmul__(s)
In [ ]:
h.data
In [ ]:
np.array([np.zeros(21)], dtype='float32')
In [ ]:
np.append(h.W.grad, h.b.grad)
In [ ]:
loss.grad
In [ ]:
x = Variable(np.array([-1, 0, 1], dtype=np.float32))
z = F.sin(x)
z.grad = np.ones(3, dtype=np.float32)
z.backward()
x.grad
In [ ]:
for i in range(100):
Farray = Fs
x = Variable(Fs)
model.zerograds()
loss = model(x)
loss.backward()
optimizer.update()
print('epoch:', i)
print('train mean loss={}'.format(loss_val))
print(' - - - - - - - - - ')
In [ ]:
d = [0]
one = Variable(np.ones((1, 1), dtype=np.float32))
for i in range(1000):
X = Variable(np.array([Farray[i]], dtype=np.float32))
delta = np.tanh(model.W.data*X.data + model.u.data*d[-1] + model.b.data)
d.append(delta[0][0])
In [ ]:
d
In [ ]: