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 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 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)