def testFewPoints(self):
# check sanity of paths with less than 3 points
path1=[[4.3,0.8]]
path2=numpy.array([[1,2],[2,4]])
m=4
d=2
s=iisignature.prepare(d,m,"cosx")
s_a=iisignature.prepare(d,2,"cosx")
length=iisignature.siglength(d,m)
loglength=iisignature.logsiglength(d,m)
loglength_a=iisignature.logsiglength(d,2)
blankLogSig=numpy.zeros(loglength)
blankLogSig_a=numpy.zeros(loglength_a)
blankSig=numpy.zeros(length)
self.assertLess(diff(iisignature.sig(path1,m),blankSig),0.000000001)
self.assertTrue(numpy.array_equal(iisignature.sig(path1,m,2),numpy.zeros([0,length])))
self.assertLess(diff(iisignature.logsig(path1,s,"C"),blankLogSig),0.000000001)
self.assertLess(diff(iisignature.logsig(path1,s,"O"),blankLogSig),0.000000001)
self.assertLess(diff(iisignature.logsig(path1,s,"S"),blankLogSig),0.000000001)
self.assertLess(diff(iisignature.logsig(path1,s,"X"),blankSig),0.000000001)
self.assertLess(diff(iisignature.logsig(path1,s_a,"A"),blankLogSig_a),0.000000001)
blankLogSig[:d]=path2[1]-path2[0]
blankLogSig_a[:d]=path2[1]-path2[0]
blankSig[:d]=path2[1]-path2[0]
self.assertLess(diff(iisignature.logsig(path2,s,"C"),blankLogSig),0.000001)
self.assertLess(diff(iisignature.logsig(path2,s,"O"),blankLogSig),0.000001)
self.assertLess(diff(iisignature.logsig(path2,s,"S"),blankLogSig),0.000001)
self.assertLess(diff(iisignature.logsig(path2,s,"X"),blankSig),0.000001)
self.assertLess(diff(iisignature.logsig(path2,s_a,"A"),blankLogSig_a),0.000001)
def testFewPoints(self):
# check sanity of paths with less than 3 points
path1=[[4.3,0.8]]
path2=numpy.array([[1,2],[2,4]])
m=4
d=2
s=iisignature.prepare(d,m,"cosx")
s_a=iisignature.prepare(d,2,"cosx")
length=iisignature.siglength(d,m)
loglength=iisignature.logsiglength(d,m)
loglength_a=iisignature.logsiglength(d,2)
blankLogSig=numpy.zeros(loglength)
blankLogSig_a=numpy.zeros(loglength_a)
blankSig=numpy.zeros(length)
self.assertLess(diff(iisignature.sig(path1,m),blankSig),0.000000001)
self.assertTrue(numpy.array_equal(iisignature.sig(path1,m,2),numpy.zeros([0,length])))
self.assertLess(diff(iisignature.logsig(path1,s,"C"),blankLogSig),0.000000001)
self.assertLess(diff(iisignature.logsig(path1,s,"O"),blankLogSig),0.000000001)
self.assertLess(diff(iisignature.logsig(path1,s,"S"),blankLogSig),0.000000001)
self.assertLess(diff(iisignature.logsig(path1,s,"X"),blankSig),0.000000001)
self.assertLess(diff(iisignature.logsig(path1,s_a,"A"),blankLogSig_a),0.000000001)
blankLogSig[:d]=path2[1]-path2[0]
blankLogSig_a[:d]=path2[1]-path2[0]
blankSig[:d]=path2[1]-path2[0]
self.assertLess(diff(iisignature.logsig(path2,s,"C"),blankLogSig),0.000001)
self.assertLess(diff(iisignature.logsig(path2,s,"O"),blankLogSig),0.000001)
self.assertLess(diff(iisignature.logsig(path2,s,"S"),blankLogSig),0.000001)
self.assertLess(diff(iisignature.logsig(path2,s,"X"),blankSig),0.000001)
self.assertLess(diff(iisignature.logsig(path2,s_a,"A"),blankLogSig_a),0.000001)
def doplot(n_samples=100, m=5, d=3, nplot=None):
x = vanilla_data(n_samples=n_samples, d=d)
# do something to make it interesting: if last coord ever hist 1, then zero out the rest
hitting_event = np.maximum.accumulate(np.abs(x[:, -1])) > 3
x[hitting_event, :-1] = 3
# x[:,:-1] = np.where(cumulative_maximum > 1, 0, x[:,:-1])
# x = x - x.mean(axis=0)
# x = x / x.std(axis=0)
# x = np.exp(x)
# x = x / x.sum(axis=0)
s = iis.prepare(d, m)
if nplot is None:
nplot = n_samples
ii = n_samples // nplot
figure(1)
clf()
ax = subplot(2, 1, 1)
plot(x, alpha=0.5)
ylabel('path')
t = list()
data = list()
for i in range(ii, n_samples, ii):
t.append(i)
temp = iis.logsig(x[:i], s)
data.append(temp)
data = np.array(data)
assert data.shape[1] == iis.logsiglength(d, m), 'not match!'
t = np.array(t)
ax = subplot(2, 1, 2)
plot(t, (data.T / (t**0)).T, alpha=0.5)
# plot(t, (data[:,-1].T / (t ** 0)).T, alpha=0.5)
ylabel('logsig')
xlabel('t')
show()
return locals()
def ComputeLogsigFeatures(path, number_of_segment, deg_of_logsig):
"""
The implementation of computing the log-signature of segments of path.
path: dimension (sample_size,n, d)
number_of_segment: the number of segments
deg_of_logsig: the degree of the log-signature
"""
nT = int(np.shape(path)[1])
dim_path = int(np.shape(path)[-1])
t_vec = np.linspace(1, nT, number_of_segment + 1)
t_vec = [int(round(x)) for x in t_vec]
s = iisignature.prepare(dim_path, deg_of_logsig)
MultiLevelLogSig = []
for k in range(int(np.shape(path)[0])):
tmpMultiLevelLogSig = np.zeros(
(number_of_segment,
iisignature.logsiglength(dim_path, deg_of_logsig)))
for i in range(number_of_segment):
temp_path = path[k][t_vec[i] - 1:t_vec[i + 1], :]
temp_start = temp_path[0]
tmpMultiLevelLogSig[i, :] = iisignature.logsig(temp_path, s)
MultiLevelLogSig.append(tmpMultiLevelLogSig)
return np.float32(np.array(MultiLevelLogSig))
def doplot(n_samples=100, m=5, d=3, nplot=None):
x = vanilla_data(n_samples=n_samples, d=d)
# do something to make it interesting: if last coord ever hist 1, then zero out the rest
hitting_event = np.maximum.accumulate(np.abs(x[:,-1])) > 3
x[hitting_event,:-1] = 3
# x[:,:-1] = np.where(cumulative_maximum > 1, 0, x[:,:-1])
# x = x - x.mean(axis=0)
# x = x / x.std(axis=0)
# x = np.exp(x)
# x = x / x.sum(axis=0)
s = iis.prepare(d, m)
if nplot is None:
nplot = n_samples
ii = n_samples // nplot
figure(1)
clf()
ax = subplot(2,1,1)
plot(x, alpha=0.5)
ylabel('path')
t = list()
data = list()
for i in range(ii, n_samples, ii):
t.append(i)
temp = iis.logsig(x[:i], s)
data.append(temp)
data = np.array(data)
assert data.shape[1] == iis.logsiglength(d, m), 'not match!'
t = np.array(t)
ax = subplot(2,1,2)
plot(t, (data.T / (t ** 0)).T, alpha=0.5)
# plot(t, (data[:,-1].T / (t ** 0)).T, alpha=0.5)
ylabel('logsig')
xlabel('t')
show()
return locals()
def ComputeMultiLevelLogsig1dBM(BM_paths, number_of_segment, depth_of_tensors, T):
"""
Compute the log-signature of all samples
"""
no_of_samples = np.shape(BM_paths)[0]
if depth_of_tensors == 1:
MultiLevelLogSigs = np.zeros(
[no_of_samples, 2 * number_of_segment], dtype=float)
else:
MultiLevelLogSigs = np.zeros([no_of_samples, iisignature.logsiglength(
2, depth_of_tensors) * number_of_segment], dtype=float)
MultiStart = np.zeros([no_of_samples, number_of_segment], dtype=float)
s = iisignature.prepare(2, depth_of_tensors)
print('start computing the logsigs of degree %d:' % depth_of_tensors)
for j in tqdm(range(0, no_of_samples, 1), total=no_of_samples):
BM = TimeJointPath(BM_paths[j, :], T)
result2 = ComputeMultiLevelSig(
BM, number_of_segment, depth_of_tensors, s)
#MultiLevelSigs[j] = result2['MultiLevelSig']
# print(result2)
MultiLevelLogSigs[j] = result2['MultiLevelLogSig']
MultiStart[j] = result2['MultiStart']
n_input = int(np.shape(MultiLevelLogSigs)[1] / number_of_segment)
X_logsig_start = MultiLevelLogSigs.reshape(
(np.shape(MultiLevelLogSigs)[0], number_of_segment, n_input))
batch_x0 = MultiStart.reshape(
(np.shape(MultiLevelLogSigs)[0], number_of_segment, 1))
X_logsig_start = np.concatenate((X_logsig_start, batch_x0), axis=2)
return X_logsig_start
def consistency(self, coropa, dim, level):
#numpy.random.seed(21)
s = iisignature.prepare(dim,level,"coshx" if coropa else "cosx")
myinfo = {"level":level, "dimension":dim,
"methods": ("COSAX" if level <= 2 else "COSX"),
"basis":("Standard Hall" if coropa else "Lyndon")}
self.assertEqual(iisignature.info(s),myinfo)
path = numpy.random.uniform(size=(10,dim))
basis = iisignature.basis(s)
logsig = iisignature.logsig(path,s)
sig = iisignature.sig(path,level)
#check lengths
self.assertEqual(len(basis),iisignature.logsiglength(dim,level))
self.assertEqual((len(basis),),logsig.shape)
self.assertEqual(sig.shape,(iisignature.siglength(dim,level),))
#calculate a signature from logsig
expanded_logsig = [numpy.zeros(dim ** m) for m in range(1,level + 1)]
for coeff, expression in zip(logsig,basis):
values, depth = valueOfBracket(expression,dim)
expanded_logsig[depth - 1]+=values * coeff
calculated_sig = numpy.concatenate(exponentiateTensor(expanded_logsig))
self.assertLess(diff(sig,calculated_sig),0.00001)
#calculate a log signature from sig
fullLogSig = numpy.concatenate(logTensor(splitConcatenatedTensor(sig,dim,level)))
fullLogSigLib = iisignature.logsig(path,s,"x")
diff1 = numpy.max(numpy.abs(fullLogSigLib - fullLogSig))
#print
#(numpy.vstack([fullLogSig,fullLogSigLib,numpy.abs(fullLogSigLib-fullLogSig)]).transpose())
self.assertLess(diff1,0.00001)
basisMatrix = []
zeros = [numpy.zeros(dim ** m) for m in range(1,level + 1)]
for expression in basis:
values, depth = valueOfBracket(expression, dim)
temp = zeros[depth - 1]
zeros[depth - 1] = values
basisMatrix.append(numpy.concatenate(zeros))
zeros[depth - 1] = temp
calculatedLogSig = lstsq(numpy.transpose(basisMatrix),fullLogSig)[0]
diff2 = numpy.max(numpy.abs(logsig - calculatedLogSig))
self.assertLess(diff2,0.00001)
#check consistency of methods
slowLogSig = iisignature.logsig(path,s,"o")
diffs = numpy.max(numpy.abs(slowLogSig - calculatedLogSig))
self.assertLess(diffs,0.00001)
sigLogSig = iisignature.logsig(path,s,"s")
diffs = numpy.max(numpy.abs(sigLogSig - calculatedLogSig))
self.assertLess(diffs,0.00001)
if level < 3:
areaLogSig = iisignature.logsig(path,s,"a")
diffs = numpy.max(numpy.abs(areaLogSig - calculatedLogSig))
self.assertLess(diffs,0.00001)
def build_lin_Logsig_rnn_model(input_shape, n_hidden_neurons, output_shape,
no_of_segments, deg_of_logsig, learning_rate,
drop_rate_1, drop_rate_2, filter_size):
"""
The LP_logsig_rnn model
"""
logsiglen = iisignature.logsiglength(filter_size, deg_of_logsig)
input_layer = Input(shape=input_shape)
# Convolutional layer
lin_projection_layer = Conv2D(32, (1, 1),
strides=(1, 1),
data_format='channels_last')(input_layer)
lin_projection_layer = Conv2D(
16, (5, 1), strides=(1, 1),
data_format='channels_last')(lin_projection_layer)
reshape = Reshape((input_shape[0] - 4, 16 * 25))(lin_projection_layer)
lin_projection_layer = Conv1D(filter_size, 1)(reshape)
mid_output = Lambda(lambda x: SP(x, no_of_segments),
output_shape=(no_of_segments, filter_size),
name='start_position')(lin_projection_layer)
# Computing Logsig layer
hidden_layer = Lambda(lambda x:CLF(x, no_of_segments, deg_of_logsig), \
output_shape=(no_of_segments,logsiglen),name='logsig')(lin_projection_layer)
hidden_layer = Reshape((no_of_segments, logsiglen))(hidden_layer)
# Batchnormalization
BN_layer = BatchNormalization()(hidden_layer)
mid_input = layers.concatenate([mid_output, BN_layer], axis=-1)
# LSTM
lstm_layer = LSTM(units=n_hidden_neurons, return_sequences=True)(mid_input)
# Dropout
drop_layer = Dropout(drop_rate_2)(lstm_layer)
output_layer = Flatten()(drop_layer)
output_layer = Dense(output_shape, activation='softmax')(output_layer)
model = Model(inputs=input_layer, outputs=output_layer)
model.summary()
adam = Adam(lr=learning_rate,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False)
# sgd = SGD(lr=learning_rate, decay=0.95,momentum=0.9)
model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['accuracy'])
return model
def consistency(self, coropa, dim, level):
#numpy.random.seed(21)
s = iisignature.prepare(dim,level,"coshx" if coropa else "cosx")
myinfo = {"level":level, "dimension":dim,
"methods": ("COSAX" if level <= 2 else "COSX"),
"basis":("Standard Hall" if coropa else "Lyndon")}
self.assertEqual(iisignature.info(s),myinfo)
path = numpy.random.uniform(size=(10,dim))
basis = iisignature.basis(s)
logsig = iisignature.logsig(path,s)
sig = iisignature.sig(path,level)
#check lengths
self.assertEqual(len(basis),iisignature.logsiglength(dim,level))
self.assertEqual((len(basis),),logsig.shape)
self.assertEqual(sig.shape,(iisignature.siglength(dim,level),))
#calculate a signature from logsig
expanded_logsig = [numpy.zeros(dim ** m) for m in range(1,level + 1)]
for coeff, expression in zip(logsig,basis):
values, depth = valueOfBracket(expression,dim)
expanded_logsig[depth - 1]+=values * coeff
calculated_sig = numpy.concatenate(exponentiateTensor(expanded_logsig))
self.assertLess(diff(sig,calculated_sig),0.00001)
#calculate a log signature from sig
fullLogSig = numpy.concatenate(logTensor(splitConcatenatedTensor(sig,dim,level)))
fullLogSigLib = iisignature.logsig(path,s,"x")
diff1 = numpy.max(numpy.abs(fullLogSigLib - fullLogSig))
#print
#(numpy.vstack([fullLogSig,fullLogSigLib,numpy.abs(fullLogSigLib-fullLogSig)]).transpose())
self.assertLess(diff1,0.00001)
basisMatrix = []
zeros = [numpy.zeros(dim ** m) for m in range(1,level + 1)]
for expression in basis:
values, depth = valueOfBracket(expression, dim)
temp = zeros[depth - 1]
zeros[depth - 1] = values
basisMatrix.append(numpy.concatenate(zeros))
zeros[depth - 1] = temp
calculatedLogSig = lstsq(numpy.transpose(basisMatrix),fullLogSig)[0]
diff2 = numpy.max(numpy.abs(logsig - calculatedLogSig))
self.assertLess(diff2,0.00001)
#check consistency of methods
slowLogSig = iisignature.logsig(path,s,"o")
diffs = numpy.max(numpy.abs(slowLogSig - calculatedLogSig))
self.assertLess(diffs,0.00001)
sigLogSig = iisignature.logsig(path,s,"s")
diffs = numpy.max(numpy.abs(sigLogSig - calculatedLogSig))
self.assertLess(diffs,0.00001)
if level < 3:
areaLogSig = iisignature.logsig(path,s,"a")
diffs = numpy.max(numpy.abs(areaLogSig - calculatedLogSig))
self.assertLess(diffs,0.00001)
def infer_shape(self,node,shapes):
#d=shapes[0][-1]
s,method=_prepared_obeject_store[node.inputs[1].get_value()]
m=iisignature.info(s)["level"]
d=iisignature.info(s)["dimension"]
if "x" in method or "X" in method:
length=iisignature.siglength(d,m)
else:
length=iisignature.logsiglength(d,m)
return [shapes[0][:-2]+(length,)]
def build_lin_Logsig_rnn_model(input_shape, n_hidden_neurons, output_shape,
no_of_segments, deg_of_logsig, learning_rate,
drop_rate_1, drop_rate_2, filter_size):
logsiglen = iisignature.logsiglength(filter_size + 1, deg_of_logsig)
input_layer = Input(shape=input_shape)
lin_projection_layer = Conv2D(32, (1, 1),
strides=(1, 1),
data_format='channels_last')(input_layer)
lin_projection_layer = Conv2D(
16, (3, 1),
strides=(1, 1),
padding='same',
data_format='channels_last')(lin_projection_layer)
reshape = Reshape((input_shape[0], 16 * 19))(lin_projection_layer)
lin_projection_layer = Conv1D(filter_size, 1, activation='relu')(reshape)
drop_layer_1 = Dropout(drop_rate_1)(lin_projection_layer)
ps_layer = Lambda(lambda x: PS(x),
output_shape=(input_shape[0], filter_size),
name='partial_sum')(drop_layer_1)
cat_layer = Lambda(lambda x: Cat_T(x, input_shape[0]),
output_shape=(input_shape[0], filter_size + 1),
name='add_time')(ps_layer)
mid_output = Lambda(lambda x: SP(x, no_of_segments),
output_shape=(no_of_segments, filter_size + 1),
name='start_position')(cat_layer)
hidden_layer_1 = Lambda(lambda x:CLF(x, no_of_segments, deg_of_logsig), \
output_shape=(no_of_segments,logsiglen), name='logsig_layer')(cat_layer)
hidden_layer_2 = Reshape((no_of_segments, logsiglen))(hidden_layer_1)
BN_layer_1 = BatchNormalization()(hidden_layer_2)
mid_input = layers.concatenate([mid_output, BN_layer_1], axis=-1)
lstm_layer = LSTM(units=n_hidden_neurons, return_sequences=True)(mid_input)
# hidden_layer_3 = Dense(512, activation='relu')(lstm_layer)
# BN_layer_2 = BatchNormalization()(lstm_layer)
drop_layer_2 = Dropout(drop_rate_2)(lstm_layer)
output_layer = Flatten()(drop_layer_2)
output_layer = Dense(output_shape, activation='softmax')(output_layer)
model = Model(inputs=input_layer, outputs=output_layer)
model.summary()
adam = Adam(lr=learning_rate,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False)
model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['accuracy'])
return model
def test_logsigbackwards_can_augment_s(self):
numpy.random.seed(291)
d=2
m=7
pathLength=3
path = numpy.random.uniform(size=(pathLength,d))
increment = 0.1*numpy.random.uniform(size=(pathLength,d))
dFdlogSig = numpy.ones(iisignature.logsiglength(d,m))
for types in (("x","o","s"),("xh","oh","sh")):
ss=[iisignature.prepare(d,m,t) for t in types]
backs=[iisignature.logsigbackprop(dFdlogSig,path,s) for s in ss]
self.assertTrue(numpy.allclose(backs[0],backs[2]),types[0])
self.assertTrue(numpy.allclose(backs[1],backs[2]),types[1])
fwds=[iisignature.logsig(path,s,"s") for s in ss]
self.assertTrue(numpy.allclose(fwds[0],fwds[2]),types[0])
self.assertTrue(numpy.allclose(fwds[1],fwds[2]),types[1])
def logSig(self, type, m=5):
numpy.random.seed(291)
d=2
pathLength=10
s=iisignature.prepare(d,m,type)
path = numpy.random.uniform(size=(pathLength,d))
path = numpy.cumsum(2 * (path - 0.5),0)#makes it more random-walk-ish, less like a scribble
increment = 0.01*path
increment = 0.1*numpy.random.uniform(size=(pathLength,d))
manualChange = fdDeriv(lambda x:iisignature.logsig(x,s,type),path,increment,4)
dFdlogSig = numpy.ones(iisignature.siglength(d,m) if "X"==type else iisignature.logsiglength(d,m))
calculatedChange = numpy.sum(increment*iisignature.logsigbackprop(dFdlogSig,path,s,type))
#print(manualChange, calculatedChange)
self.assertLess(numpy.abs(manualChange-calculatedChange),0.0001)
def test_logsigbackwards_can_augment_s(self):
numpy.random.seed(291)
d=2
m=7
pathLength=3
path = numpy.random.uniform(size=(pathLength,d))
increment = 0.1*numpy.random.uniform(size=(pathLength,d))
dFdlogSig = numpy.ones(iisignature.logsiglength(d,m))
for types in (("x","o","s"),("xh","oh","sh")):
ss=[iisignature.prepare(d,m,t) for t in types]
backs=[iisignature.logsigbackprop(dFdlogSig,path,s) for s in ss]
self.assertTrue(numpy.allclose(backs[0],backs[2]),types[0])
self.assertTrue(numpy.allclose(backs[1],backs[2]),types[1])
fwds=[iisignature.logsig(path,s,"s") for s in ss]
self.assertTrue(numpy.allclose(fwds[0],fwds[2]),types[0])
self.assertTrue(numpy.allclose(fwds[1],fwds[2]),types[1])
def logSig(self, type, m=5):
numpy.random.seed(291)
d=2
pathLength=10
s=iisignature.prepare(d,m,type)
path = numpy.random.uniform(size=(pathLength,d))
path = numpy.cumsum(2 * (path - 0.5),0)#makes it more random-walk-ish, less like a scribble
increment = 0.01*path
increment = 0.1*numpy.random.uniform(size=(pathLength,d))
manualChange = fdDeriv(lambda x:iisignature.logsig(x,s,type),path,increment,4)
dFdlogSig = numpy.ones(iisignature.siglength(d,m) if "X"==type else iisignature.logsiglength(d,m))
calculatedChange = numpy.sum(increment*iisignature.logsigbackprop(dFdlogSig,path,s,type))
#print(manualChange, calculatedChange)
self.assertLess(numpy.abs(manualChange-calculatedChange),0.0001)
def build_lin_Logsig_rnn_model(input_shape, n_hidden_neurons, output_shape,
no_of_segments, deg_of_logsig, learning_rate,
drop_rate1, drop_rate2, filter_size):
"""
Construct the LP_logsig_rnn model using the customized operations CLF, Cat_T and PS from cus_layers.py
"""
logsiglen = iisignature.logsiglength(filter_size, deg_of_logsig)
input_layer = Input(shape=input_shape)
# Time path concatenation
cat_layer = Lambda(lambda x: Cat_T(x, input_shape[0]),
output_shape=(input_shape[0],
input_shape[1] + 1))(input_layer)
# Convolutional layer
lin_projection_layer = Conv1D(filter_size, 1)(cat_layer)
# Dropout
drop_layer_1 = Dropout(drop_rate1)(lin_projection_layer)
# Cumulative sum
ps_layer = Lambda(lambda x: PS(x),
output_shape=(input_shape[0], filter_size))(drop_layer_1)
# BN_layer_0 = BatchNormalization()(lin_projection_layer)
# Computing Logsig layer
hidden_layer_1 = Lambda(lambda x:CLF(x, no_of_segments, deg_of_logsig), \
output_shape=(no_of_segments,logsiglen))(ps_layer)
hidden_layer_2 = Reshape((no_of_segments, logsiglen))(hidden_layer_1)
# Batchnormalization
BN_layer_1 = BatchNormalization()(hidden_layer_2)
# LSTM
lstm_layer = LSTM(units=n_hidden_neurons)(BN_layer_1)
# BN_layer_2 = BatchNormalization()(lstm_layer)
# Dropout
drop_layer_2 = Dropout(drop_rate2)(lstm_layer)
output_layer = Dense(output_shape, activation='softmax')(drop_layer_2)
model = Model(inputs=input_layer, outputs=output_layer)
model.summary()
adam = Adam(lr=learning_rate,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False)
model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['accuracy'])
return model
batch_size = bs[dataset_name]
test_size = data_len // 10
train_batches = np.ceil((data_len - test_size) / batch_size).astype(int)
print('number of batches = ', train_batches, ' batch size = ', batch_size)
torch.manual_seed(0)
rng_state = torch.get_rng_state(
) #seed init to ensure same initial conditions for each training
### eigenvalue path signature ####
if xtra_feat:
pslevel = 4
sig_prep = iisignature.prepare(2, pslevel)
#xtra_feat_length = iisignature.logsiglength(2, pslevel)
siglength = iisignature.logsiglength(2, pslevel)
xtra_feat_length = siglength
if xxtra: xtra_feat_length += 7
else:
xtra_feat_length = 0
###### preprocess #####
data = []
label = []
mx, mn = -np.inf, np.inf
Alist = None
Aker = None
smax = []
for i in range(len(graph_list)):
def perform(self,node,inp,out):
out[0][0]=np.array(iisignature.logsiglength(inp[0],inp[1]),dtype="int32")
def setup(obj):
obj.path = torch.rand(obj.size, dtype=torch.float).numpy()
shape = obj.size[-3], iisignature.logsiglength(obj.size[-1], obj.depth)
obj.grad = torch.rand(shape).numpy()
obj.prepare = iisignature.prepare(obj.path.shape[-1], obj.depth)
