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 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 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 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 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 ComputeMultiLevelSig(path, number_of_segment, deg_of_sig, s, sig='False'):
"""
compute the signature and log-signature of segments of one path of dimension (n, d)
"""
n_t = path.shape[0]
n_Path = path.shape[1]
t_vec = np.arange(1, n_t, int(n_t / number_of_segment))
t_vec = np.append(t_vec, n_t)
MultiLevelSig = np.empty
MultiLevelLogSig = np.empty
for i in range(1, number_of_segment + 1, 1):
temp_path = path[t_vec[i - 1] - 1:t_vec[i], 0:2]
if deg_of_sig == 1:
temp = iisignature.sig(temp_path, 1)
else:
if sig == 'False':
templog = iisignature.logsig(temp_path, s)
else:
templog = iisignature.sig(temp_path, deg_of_sig)
tempStart = (temp_path[0, 1])
# print(temp)
if (i == 1):
#MultiLevelSig = temp
MultiLevelLogSig = templog
MultiStart = np.array([tempStart])
else:
#MultiLevelSig = np.concatenate((MultiLevelSig,temp), axis = 0)
MultiLevelLogSig = np.concatenate(
(MultiLevelLogSig, templog), axis=0)
MultiStart = np.append(MultiStart, [tempStart])
return {'MultiLevelSig': MultiLevelSig, 'MultiLevelLogSig': MultiLevelLogSig, 'MultiStart': MultiStart}
def doneStroke(event):
#scaled_points = points / np.array([canvas.winfo_width(), canvas.winfo_height()])
scaled_points = points / np.array(max(canvas.winfo_width(), canvas.winfo_height()))
#print(iisignature.sig(points,m))
#print(iisignature.logsig(points,s))
#print(iisignature.sig(scaled_points,m))
print(iisignature.logsig(scaled_points,s))
def testLevel1(self):
m = 1
d = 2
path = numpy.random.uniform(size=(10, d))
rightSig = path[-1, :] - path[0, :]
s = iisignature.prepare(d, m, "cosx2")
self.assertLess(diff(iisignature.sig(path, m), rightSig), 0.0000001)
for type_ in ("C", "O", "S", "X", "A"):
self.assertLess(diff(iisignature.logsig(path, s, type_), rightSig),
0.0000001, type_)
self.assertLess(diff(rightSig, iisignature.logsigtosig(rightSig, s)),
0.000001)
derivs = numpy.array([2.1, 3.2])
pathderivs = numpy.zeros_like(path)
pathderivs[-1] = derivs
pathderivs[0] = -derivs
self.assertLess(
diff(iisignature.logsigbackprop(derivs, path, s), pathderivs),
0.00001)
self.assertLess(
diff(iisignature.logsigbackprop(derivs, path, s, "X"), pathderivs),
0.00001)
self.assertLess(
diff(iisignature.sigbackprop(derivs, path, m), pathderivs),
0.00001)
def doneStroke(event):
#scaled_points = points / np.array([canvas.winfo_width(), canvas.winfo_height()])
scaled_points = points / np.array(
max(canvas.winfo_width(), canvas.winfo_height()))
#print(iisignature.sig(points,m))
#print(iisignature.logsig(points,s))
#print(iisignature.sig(scaled_points,m))
print(iisignature.logsig(scaled_points, s))
def demo():
#1. generate some dummy data
d=3
m=6
path1=np.random.uniform(size=(20,d))
path2=np.random.uniform(size=(20,d))
paths = (path1,path2)
s=iisignature.prepare(d,m)
#2. print the dot product of the log signatures in tensor space
#(The "x" means that the log signature is returned in tensor space.)
expandedLogSig1,expandedLogSig2=(iisignature.logsig(i,s,"x") for i in paths)
target = np.inner(expandedLogSig1,expandedLogSig2)
print_ ("Target:", float(target))
#3. use getMatrices to act on the log signatures expressed in a basis
# and get the same answer.
matrices=getMatrices(s)
logsig1,logsig2=(iisignature.logsig(i,s) for i in paths)
adjustment=scipy.linalg.block_diag(*matrices)
#print(np.dot(adjustment,logsig2).shape)
print_ ("We get:", float(np.inner(logsig1,np.dot(adjustment,logsig2))))
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 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 testLevel1(self):
m=1
d=2
path=numpy.random.uniform(size=(10,d))
rightSig = path[-1,:]-path[0,:]
s=iisignature.prepare(d,m,"cosx")
self.assertLess(diff(iisignature.sig(path,m),rightSig),0.0000001)
for type_ in ("C","O","S","X","A"):
self.assertLess(diff(iisignature.logsig(path,s,type_),rightSig),0.0000001,type_)
derivs=numpy.array([2.1,3.2])
pathderivs=numpy.zeros_like(path)
pathderivs[-1]=derivs
pathderivs[0]=-derivs
self.assertLess(diff(iisignature.logsigbackprop(derivs,path,s),pathderivs),0.00001)
self.assertLess(diff(iisignature.logsigbackprop(derivs,path,s,"X"),pathderivs),0.00001)
self.assertLess(diff(iisignature.sigbackprop(derivs,path,m),pathderivs),0.00001)
def _iisignature_logsignature(path, depth, mode):
result = _iisignatureLogsignatureFunction.apply(path, depth)
if mode != h.expand_mode:
result = torch.index_select(result, -1, _lyndon_indices(path.size(-1), depth).to(path.device))
if mode != h.words_mode:
for transform_class in _lyndon_words_to_basis_transform(path.size(-1), depth):
for source, target, coefficient in transform_class:
result[..., target] -= coefficient * result[..., source]
# We can't use this directly because we can't backprop through it. (iisignature has a bug in logsigbackprop
# for this one)
# But we do test that the forward result is correct.
direct_iisignature_logsignature = iisignature.logsig(path.detach().cpu(),
h.iisignature_prepare(path.size(-1), depth))
assert result.allclose(torch.tensor(direct_iisignature_logsignature, dtype=path.dtype, device=path.device))
return result
def Ito_map_iisig(x):
if isinstance(x, list):
xx = x[0]
x_eps = x[1]
X = np.stack([xx.reshape(-1), x_eps[:len(xx)]]).T
else:
X = x
N = len(X)
Y = np.zeros((N, 3))
if X.shape[1] == 2:
Y[:, 0] = X[:, 0]
Y[:, 1] = X[:, 1]
Y[:, 2] = np.array(
[iisignature.logsig(X[:i, :], p)[-1] for i in range(1, N + 1)])
else:
Y[:, 0] = X[:, 0]
Y[:, 1] = X[:, 1]
Y[:, 2] = 0.5 * (X[:, 3] - X[:, 4])
return Y
def doL2S(self, coropa):
numpy.random.seed(212)
d = 3
m = 6
path = numpy.random.uniform(size=(12, d))
sig = iisignature.sig(path, m)
s = iisignature.prepare(d, m, "S2H" if coropa else "S2")
self.assertTrue(iisignature.info(s)["logsigtosig_supported"])
logsig = iisignature.logsig(path, s)
sig_ = iisignature.logsigtosig(logsig, s)
self.assertEqual(sig.shape, sig_.shape)
self.assertTrue(numpy.allclose(sig, sig_))
#Like the other iisig functions, we check that derivatives
#of logsigtosig allow sum(logsigtosig) to be backproped correctly
#This is a boring thing to calculate, because after the first level
#each of the log signature elements is a lie bracket and so
#contributes a net total of 0 to the signature
derivsOfSum = numpy.ones((sig.shape[0], ), dtype="float64")
bumpedLogSig = 1.01 * logsig
calculated = iisignature.logsigtosigbackprop(derivsOfSum, logsig, s)
#wantedbackprop = allSensitivities(logsig, lambda l: iisignature.logsigtosig(l,s).sum())
manualChange = fdDeriv(lambda x: iisignature.logsigtosig(x, s), logsig,
bumpedLogSig - logsig, 6)
calculatedChange = numpy.sum((bumpedLogSig - logsig) * calculated)
self.assertLess(numpy.abs(manualChange - calculatedChange), 0.00001)
#beyond the first level, all zero
if m > 1:
self.assertLess(numpy.max(numpy.abs(calculated[d:])), 0.00001)
self.assertEqual(calculated.shape, logsig.shape)
#Now for a better test, we backprop sum(random*logsigtosig)
#specifically calculate the change in it caused by bump two ways
random = numpy.random.uniform(size=sig.shape[0], )
derivsOfSum = random
calculated = iisignature.logsigtosigbackprop(derivsOfSum, logsig, s)
manualChange = fdDeriv(
lambda x: iisignature.logsigtosig(x, s) * random, logsig,
bumpedLogSig - logsig, 4)
calculatedChange = numpy.sum((bumpedLogSig - logsig) * calculated)
self.assertLess(numpy.abs(manualChange - calculatedChange), 0.00001)
self.assertEqual(calculated.shape, logsig.shape)
def save_plot_sig_logsig_handwritten_data():
for truncation_order in range(1, 16):
fig_sig, axs_sig = plt.subplots(10)
fig_sig.suptitle(
f"Sig of handwritten digits (0 top and 9 bottom); k={truncation_order}"
)
fig_logsig, axs_logsig = plt.subplots(10)
fig_logsig.suptitle(
f"Log_sig of handwritten digits (0 top and 9 bottom); k={truncation_order}"
)
for i in range(10):
# 1. logsig
s = iisignature.prepare(2, truncation_order)
log_sig = iisignature.logsig(handwritting_ds.training_X_ordered[i],
s)
log_sig_df = pd.DataFrame(log_sig) # signatures are rows
log_sig_df = log_sig_df.transpose(
) # ; we move them into columns so that time series format
axs_logsig[i].plot(log_sig_df.values)
fig_logsig.savefig(
f"/home/raymess-lin/git/auto-sig-encoder/plots/handwritten_log_sig_k_{truncation_order}.png"
)
# 2. sig
sig = iisignature.sig(handwritting_ds.training_X_ordered[i],
truncation_order)
sig_df = pd.DataFrame(sig) # signatures are rows
sig_df = sig_df.transpose(
) # ; we move them into columns so that time series format
axs_sig[i].plot(sig_df.values)
fig_sig.savefig(
f"/home/raymess-lin/git/auto-sig-encoder/plots/handwritten_sig_k_{truncation_order}.png"
)
def __call__(self,x):
return iisignature.logsig(x,self.s,self.method)
def perform(self,node,inputs_storage,outputs_storage):
x=inputs_storage[0]
s,method=_prepared_obeject_store[inputs_storage[1]]
outputs_storage[0][0]=iisignature.logsig(x,s,method)
def on_touch_up(self, touch):
path=np.reshape(touch.ud['line'].points,(-1,2))
print(iisignature.logsig(path,s))
def curve_concat_log_metric(x, y, s):
return np_norm(logsig(concatenate(x, y), s))
def testHighDim(self):
for m in [1]:
d=1000
path = numpy.random.rand(10,d)
s=iisignature.prepare(d,m)
iisignature.logsig(path,s,"A")
def test_batch(self):
numpy.random.seed(734)
d=2
m=2
n=15
paths = [numpy.random.uniform(-1,1,size=(6,d)) for i in range(n)]
pathArray15=stack(paths)
pathArray1315=numpy.reshape(pathArray15,(1,3,1,5,6,d))
sigs = [iisignature.sig(i,m) for i in paths]
sigArray=stack(sigs)
sigArray15=iisignature.sig(pathArray15,m)
sigArray1315=iisignature.sig(pathArray1315,m)
siglength=iisignature.siglength(d,m)
self.assertEqual(sigArray1315.shape,(1,3,1,5,siglength))
self.assertTrue(numpy.allclose(sigArray1315.reshape(n,siglength),sigs))
self.assertEqual(sigArray15.shape,(15,siglength))
self.assertTrue(numpy.allclose(sigArray15,sigs))
backsigs=[iisignature.sigbackprop(i,j,m) for i,j in zip(sigs,paths)]
backsigArray = stack(backsigs)
backsigs1315=iisignature.sigbackprop(sigArray1315,pathArray1315,m)
self.assertEqual(backsigs1315.shape,(1,3,1,5,6,d))
self.assertTrue(numpy.allclose(backsigs1315.reshape(n,6,2),backsigArray))
data=[numpy.random.uniform(size=(d,)) for i in range(n)]
dataArray1315=stack(data).reshape((1,3,1,5,d))
joined=[iisignature.sigjoin(i,j,m) for i,j in zip(sigs,data)]
joined1315=iisignature.sigjoin(sigArray1315,dataArray1315,m)
self.assertEqual(joined1315.shape,(1,3,1,5,siglength))
self.assertTrue(numpy.allclose(joined1315.reshape(n,-1),stack(joined)))
backjoined=[iisignature.sigjoinbackprop(i,j,k,m) for i,j,k in zip(joined,sigs,data)]
backjoinedArrays=[stack([i[j] for i in backjoined]) for j in range(2)]
backjoined1315=iisignature.sigjoinbackprop(joined1315,sigArray1315,dataArray1315,m)
self.assertEqual(backjoined1315[0].shape,sigArray1315.shape)
self.assertEqual(backjoined1315[1].shape,dataArray1315.shape)
self.assertTrue(numpy.allclose(backjoined1315[0].reshape(n,-1),backjoinedArrays[0]))
self.assertTrue(numpy.allclose(backjoined1315[1].reshape(n,-1),backjoinedArrays[1]))
dataAsSigs=[iisignature.sig(numpy.row_stack([numpy.zeros((d,)),i]),m) for i in data]
dataArray13151=dataArray1315[:,:,:,:,None,:]
dataArray13151=numpy.repeat(dataArray13151,2,4)*[[0.0],[1.0]]
dataArrayAsSigs1315=iisignature.sig(dataArray13151,m)
combined1315=iisignature.sigcombine(sigArray1315,dataArrayAsSigs1315,d,m)
self.assertEqual(joined1315.shape,combined1315.shape)
self.assertTrue(numpy.allclose(joined1315,combined1315))
backcombined1315=iisignature.sigcombinebackprop(joined1315,sigArray1315,dataArrayAsSigs1315,d,m)
backcombined=[iisignature.sigcombinebackprop(i,j,k,d,m) for i,j,k in zip(joined,sigs,dataAsSigs)]
backcombinedArrays=[stack([i[j] for i in backcombined]) for j in range(2)]
self.assertEqual(backcombined1315[0].shape,sigArray1315.shape)
self.assertEqual(backcombined1315[1].shape,sigArray1315.shape)
self.assertTrue(numpy.allclose(backjoined1315[0],backcombined1315[0]))
self.assertTrue(numpy.allclose(backcombined1315[0].reshape(n,-1),backcombinedArrays[0]))
self.assertTrue(numpy.allclose(backcombined1315[1].reshape(n,-1),backcombinedArrays[1]))
scaled=[iisignature.sigscale(i,j,m) for i,j in zip(sigs,data)]
scaled1315=iisignature.sigscale(sigArray1315,dataArray1315,m)
self.assertEqual(scaled1315.shape,(1,3,1,5,siglength))
self.assertTrue(numpy.allclose(scaled1315.reshape(n,-1),stack(scaled)))
backscaled=[iisignature.sigscalebackprop(i,j,k,m) for i,j,k in zip(scaled,sigs,data)]
backscaledArrays=[stack([i[j] for i in backscaled]) for j in range(2)]
backscaled1315=iisignature.sigscalebackprop(scaled1315,sigArray1315,dataArray1315,m)
self.assertEqual(backscaled1315[0].shape,sigArray1315.shape)
self.assertEqual(backscaled1315[1].shape,dataArray1315.shape)
self.assertTrue(numpy.allclose(backscaled1315[0].reshape(n,-1),backscaledArrays[0]))
self.assertTrue(numpy.allclose(backscaled1315[1].reshape(n,-1),backscaledArrays[1]))
s_s=(iisignature.prepare(d,m,"cosax"),iisignature.prepare(d,m,"cosahx"))
for type in ("c","o","s","x","a","ch","oh","sh","ah"):
s=s_s[1 if "h" in type else 0]
logsigs = [iisignature.logsig(i,s,type) for i in paths]
logsigArray=stack(logsigs)
logsigArray1315=iisignature.logsig(pathArray1315,s,type)
self.assertEqual(logsigArray1315.shape,(1,3,1,5,logsigs[0].shape[0]),type)
self.assertTrue(numpy.allclose(logsigArray1315.reshape(n,-1),logsigArray),type)
if type in ("s","x","sh"):
backlogs = stack(iisignature.logsigbackprop(i,j,s,type) for i,j in zip(logsigs,paths))
backlogs1315 = iisignature.logsigbackprop(logsigArray1315,pathArray1315,s,type)
self.assertEqual(backlogs1315.shape,backsigs1315.shape)
self.assertTrue(numpy.allclose(backlogs1315.reshape(n,6,d),backlogs),type)
a=iisignature.rotinv2dprepare(m,"a")
rots=stack([iisignature.rotinv2d(i,a) for i in paths])
rots1315=iisignature.rotinv2d(pathArray1315,a)
self.assertEqual(rots1315.shape,(1,3,1,5,rots.shape[1]))
self.assertTrue(numpy.allclose(rots1315.reshape(n,-1),rots))
def forward(self,X):
result=iisignature.logsig(X.numpy(), self.s, self.method)
self.save_for_backward(X)
return torch.FloatTensor(result)
def stream2logsig_Lyndon(path, m):
d=path.shape[1]
s=_getPrep(d,m,True)
return iisignature.logsig(path,s).astype("float64")
def forward(ctx, X, s):
result = iisignature.logsig(X.detach().numpy(),s)
ctx.save_for_backward(X)
ctx.s = s
return torch.tensor(result).float()
from iisignature_theano import LogSig, Sig
#1: SETUP VARIABLES
dim=2
level=3
pathlength=4
timedim=False
useLogSig = True
s=iisignature.prepare(dim,level)
numpy.random.seed(51)
target = numpy.random.uniform(size=(pathlength,dim)).astype("float32")
#target = numpy.cumsum(2*(target-0.5),0)#makes it more random-walk-ish, less like a scribble
targetSig = iisignature.logsig(target,s) if useLogSig else iisignature.sig(target,level)
start = numpy.random.uniform(size=(pathlength,dim)).astype("float32")
start[0,:] = target[0,:]
learnable_mask = numpy.ones((pathlength,dim)).astype("float32")
learnable_mask[0,:]=0 #to stop the starting point being modified
if timedim:
for i in six.moves.xrange(pathlength):
target[i,0]=start[i,0]=i*0.2
learnable_mask[i,0]=0
learning_rate_decay = 1.003
initial_learning_rate = 1.2
momentum = 0.95
#2: DEFINE THEANO STUFF
learning_rate = theano.shared(numpy.float32(initial_learning_rate),"learning_rate")
def forward(ctx, X, s, method):
result = iisignature.logsig(X.detach().numpy(), s, method)
ctx.save_for_backward(X)
ctx.s = s
ctx.method = method
return torch.FloatTensor(result)
from iisignature_theano import LogSig, Sig
#1: SETUP VARIABLES
dim = 2
level = 3
pathlength = 4
timedim = False
useLogSig = True
s = iisignature.prepare(dim, level)
numpy.random.seed(51)
target = numpy.random.uniform(size=(pathlength, dim)).astype("float32")
#target = numpy.cumsum(2*(target-0.5),0)#makes it more random-walk-ish, less like a scribble
targetSig = iisignature.logsig(target, s) if useLogSig else iisignature.sig(
target, level)
start = numpy.random.uniform(size=(pathlength, dim)).astype("float32")
start[0, :] = target[0, :]
learnable_mask = numpy.ones((pathlength, dim)).astype("float32")
learnable_mask[0, :] = 0 #to stop the starting point being modified
if timedim:
for i in six.moves.xrange(pathlength):
target[i, 0] = start[i, 0] = i * 0.2
learnable_mask[i, 0] = 0
learning_rate_decay = 1.003
initial_learning_rate = 1.2
momentum = 0.95
#2: DEFINE THEANO STUFF
datum = dict()
label.append(G.graph['label'] % 2)
if xtra_feat:
if Takens:
path = np.zeros([len(lam) - 1,
2]) #taken's embedding of eigenvalues
path[:, 0] = lam[1:]
path[:, 1] = lam[:-1]
else:
path = np.zeros([len(lam), 2])
path[:, 0] = lam
path[:, 1] = np.linspace(0, 2, len(lam))
#datum['feats'] = torch.tensor(iisignature.logsig(path,sig_prep)).float()
sigs = torch.tensor(iisignature.logsig(path, sig_prep)).float()
if xxtra:
feats = torch.zeros([xtra_feat_length])
feats[7:] = sigs
else:
datum['feats'] = sigs
evecssq = torch.from_numpy(v**2).float()
if param == 'rbf':
gram = 1 / torch.sqrt(
(torch.reshape(w, [len(G), 1]) - centroids)**2 / bfseps**2 + 1)
A = torch.matmul(evecssq, gram)
#A = A - torch.mean(A, dim = 0)
elif param == 'cheb':
vander = torch.from_numpy(
def compute_log_signature(self, stream, depth):
_, dim = stream.shape
s = self.prepare(dim, depth)
return iisignature.logsig(stream, s)
def forward(self, X):
result = iisignature.logsig(X.numpy(), self.s, self.method)
self.save_for_backward(X)
return torch.FloatTensor(result)
def __call__(self, x):
return iisignature.logsig(x, self.s, self.method)
def transform(self, X):
prepared = prepare(self.dim, self.level)
return np.array([logsig(x, prepared) for x in X])
def test_batch(self):
numpy.random.seed(734)
d=2
m=2
n=15
paths = [numpy.random.uniform(-1,1,size=(6,d)) for i in range(n)]
pathArray15=stack(paths)
pathArray1315=numpy.reshape(pathArray15,(1,3,1,5,6,d))
sigs = [iisignature.sig(i,m) for i in paths]
sigArray=stack(sigs)
sigArray15=iisignature.sig(pathArray15,m)
sigArray1315=iisignature.sig(pathArray1315,m)
siglength=iisignature.siglength(d,m)
self.assertEqual(sigArray1315.shape,(1,3,1,5,siglength))
self.assertTrue(numpy.allclose(sigArray1315.reshape(n,siglength),sigs))
self.assertEqual(sigArray15.shape,(15,siglength))
self.assertTrue(numpy.allclose(sigArray15,sigs))
backsigs=[iisignature.sigbackprop(i,j,m) for i,j in zip(sigs,paths)]
backsigArray = stack(backsigs)
backsigs1315=iisignature.sigbackprop(sigArray1315,pathArray1315,m)
self.assertEqual(backsigs1315.shape,(1,3,1,5,6,d))
self.assertTrue(numpy.allclose(backsigs1315.reshape(n,6,2),backsigArray))
data=[numpy.random.uniform(size=(d,)) for i in range(n)]
dataArray1315=stack(data).reshape((1,3,1,5,d))
joined=[iisignature.sigjoin(i,j,m) for i,j in zip(sigs,data)]
joined1315=iisignature.sigjoin(sigArray1315,dataArray1315,m)
self.assertEqual(joined1315.shape,(1,3,1,5,siglength))
self.assertTrue(numpy.allclose(joined1315.reshape(n,-1),stack(joined)))
backjoined=[iisignature.sigjoinbackprop(i,j,k,m) for i,j,k in zip(joined,sigs,data)]
backjoinedArrays=[stack([i[j] for i in backjoined]) for j in range(2)]
backjoined1315=iisignature.sigjoinbackprop(joined1315,sigArray1315,dataArray1315,m)
self.assertEqual(backjoined1315[0].shape,sigArray1315.shape)
self.assertEqual(backjoined1315[1].shape,dataArray1315.shape)
self.assertTrue(numpy.allclose(backjoined1315[0].reshape(n,-1),backjoinedArrays[0]))
self.assertTrue(numpy.allclose(backjoined1315[1].reshape(n,-1),backjoinedArrays[1]))
scaled=[iisignature.sigscale(i,j,m) for i,j in zip(sigs,data)]
scaled1315=iisignature.sigscale(sigArray1315,dataArray1315,m)
self.assertEqual(scaled1315.shape,(1,3,1,5,siglength))
self.assertTrue(numpy.allclose(scaled1315.reshape(n,-1),stack(scaled)))
backscaled=[iisignature.sigscalebackprop(i,j,k,m) for i,j,k in zip(scaled,sigs,data)]
backscaledArrays=[stack([i[j] for i in backscaled]) for j in range(2)]
backscaled1315=iisignature.sigscalebackprop(scaled1315,sigArray1315,dataArray1315,m)
self.assertEqual(backscaled1315[0].shape,sigArray1315.shape)
self.assertEqual(backscaled1315[1].shape,dataArray1315.shape)
self.assertTrue(numpy.allclose(backscaled1315[0].reshape(n,-1),backscaledArrays[0]))
self.assertTrue(numpy.allclose(backscaled1315[1].reshape(n,-1),backscaledArrays[1]))
s_s=(iisignature.prepare(d,m,"cosax"),iisignature.prepare(d,m,"cosahx"))
for type in ("c","o","s","x","a","ch","oh","sh","ah"):
s=s_s[1 if "h" in type else 0]
logsigs = [iisignature.logsig(i,s,type) for i in paths]
logsigArray=stack(logsigs)
logsigArray1315=iisignature.logsig(pathArray1315,s,type)
self.assertEqual(logsigArray1315.shape,(1,3,1,5,logsigs[0].shape[0]),type)
self.assertTrue(numpy.allclose(logsigArray1315.reshape(n,-1),logsigArray),type)
if type in ("s","x","sh"):
backlogs = stack(iisignature.logsigbackprop(i,j,s,type) for i,j in zip(logsigs,paths))
backlogs1315 = iisignature.logsigbackprop(logsigArray1315,pathArray1315,s,type)
self.assertEqual(backlogs1315.shape,backsigs1315.shape)
self.assertTrue(numpy.allclose(backlogs1315.reshape(n,6,d),backlogs),type)
a=iisignature.rotinv2dprepare(m,"a")
rots=stack([iisignature.rotinv2d(i,a) for i in paths])
rots1315=iisignature.rotinv2d(pathArray1315,a)
self.assertEqual(rots1315.shape,(1,3,1,5,rots.shape[1]))
self.assertTrue(numpy.allclose(rots1315.reshape(n,-1),rots))
length = 20
dim=3
level=2
npaths=3
paths_ = np.random.uniform(size=(npaths,length,dim))
scale_ = np.random.uniform(size=(npaths,dim))
initialsigs_ = np.random.uniform(size=(npaths,iisignature.siglength(dim,level)))
p=iisignature.prepare(dim,level,"cosx")
while 0:
iisignature.sig(paths[0],level)
for i in range(10**10):
#copy major parts of the input data, in case we are leaking references to it
paths=paths_[:]
increment=scale=scale_[:]
initialsigs=initialsigs_[:]
iisignature.sigjoin(initialsigs,scale,level)
iisignature.sigscale(initialsigs,scale,level)
iisignature.sigjoinbackprop(initialsigs,initialsigs,scale,level)
iisignature.sigscalebackprop(initialsigs,initialsigs,scale,level)
iisignature.sig(paths[0,:,:],level)
iisignature.sigbackprop(initialsigs[0,:],paths[0,:,:],level)
#iisignature.sigjacobian(paths[0,:,:],level)
#iisignature.prepare(dim,level,"cosx")#much slower than other functions
iisignature.logsig(paths[0,:,:],p,"c")
iisignature.logsig(paths[0,:,:],p,"o")
iisignature.logsig(paths[0,:,:],p,"s")
if i%10000==0:
print (i)
def testHighDim(self):
for m in [1,2]:
d=1000
path = numpy.random.rand(10,d)
s=iisignature.prepare(d,m)
iisignature.logsig(path,s,"A")
def norm(c0, c1, s):
sig0 = logsig(c0, s)
sig1 = logsig(c1, s)
return np_norm(sig0 - sig1)
def stream2logsig_Lyndon(path, m):
d = path.shape[1]
s = _getPrep(d, m, True)
return iisignature.logsig(path, s).astype("float64")
def run(obj):
return iisignature.logsig(obj.path, obj.prepare)
