Exemple #1
0
    def dominanceRankingTotal(self, currentEvent, nApp, domIndex, j, minPred,
                              diffPred):
        dom = []
        for i in range(j, nApp):
            currentApp = domIndex[i]
            signature = self.signatures.keys()[currentApp]

            initPath, dist = _ucrdtw.ucrdtw(self.signatures[signature],
                                            currentEvent, 0.1)
            path = range(initPath, initPath + len(currentEvent))
            signatureChunk = self.signatures.items()[currentApp][1][path]
            eventTemp = np.array(currentEvent) >= 0
            signatureChunkTemp = signatureChunk[eventTemp]
            eventTemp = np.array(currentEvent)[eventTemp]
            if len(eventTemp) == 0:
                dist = np.sum(currentEvent)
            else:
                if diffPred[currentApp] < 2:
                    dist = 0
                else:
                    signatureChunkTemp = np.subtract(signatureChunkTemp,
                                                     minPred[currentApp])
                    dist = np.divide(
                        np.percentile(
                            np.abs(np.subtract(eventTemp, signatureChunkTemp)),
                            95), np.max(self.signatures.items()[currentApp][1])
                    )  # Scaled 95-th percentile distance on signature max value
            dom.append(dist)
        domIndexNew = np.argsort(dom)
        del dom, nApp
        toReturn = domIndex[domIndexNew[0] + j]
        return toReturn
 def calc_distances(self,ex_key):
     example=self.example_data[ex_key]
     
     #UCRDTW
     z=np.zeros(self.n)
     for c,col in enumerate(example):
         x=example[col].values[::-1]
         z_c=np.array([ucrdtw(df[col].values[::-1], x, 0.20, False)[1] for key, df in self.test_data.iteritems()])
         #print col
         #print z_c
         z=z+self.w[c]*z_c
     return z        
Exemple #3
0
 def dtw_totalVsSig_singleEvent(self, event, signature):
     totDistances = list()
     totCosts = list()
     totPaths = list()
     currentEvent = event
     initPath, dist = _ucrdtw.ucrdtw(self.signatures[signature],
                                     currentEvent, 0.1)
     path = range(initPath, initPath + len(event))
     totDistances.append(dist)
     totPaths.append(path)
     self.totDistances[signature] = np.divide(totDistances, len(totPaths))
     self.totPaths[signature] = totPaths
     del totDistances, totPaths, currentEvent, path, initPath, dist
Exemple #4
0
def featurize(ts, dat, templates):
    """
    Get the features from the raw tennis data
    :param ts: numpy array of size (samples,sensor readings) which contains the raw data
    :param dat: tuple with start and stop indices to slice data
    :return: 
    :rtype : 
    """
    s = dat[0]
    t = dat[1]
    data = ts[s:t, :]
    length = 1.0 * len(data[:, 0])
    a = np.sqrt(np.sum(np.array(data**2, dtype=float), axis=1))
    max_index = np.argmax(a)
    max_index = 8
    if s - max_index < 0:
        s = 16
    model1x = sm.OLS(range(1, 9), ts[s + max_index:s + max_index + 8, 0])
    model1y = sm.OLS(range(1, 9), ts[s + max_index:s + max_index + 8, 1])
    model1z = sm.OLS(range(1, 9), ts[s + max_index:s + max_index + 8, 2])
    reg1 = np.array([
        model1x.fit().params[0],
        model1y.fit().params[0],
        model1z.fit().params[0]
    ])
    model2x = sm.OLS(range(1, 9), ts[s + max_index - 8:s + max_index, 0])
    model2y = sm.OLS(range(1, 9), ts[s + max_index - 8:s + max_index, 1])
    model2z = sm.OLS(range(1, 9), ts[s + max_index - 8:s + max_index, 2])
    reg2 = np.array([
        model2x.fit().params[0],
        model2y.fit().params[0],
        model2z.fit().params[0]
    ])
    dist = np.zeros((len(templates)))
    for j, template in enumerate(templates):
        dist[j] = _ucrdtw.ucrdtw(data, template, 0.5, False)[1]
    correlation = np.corrcoef(np.c_[data, a], rowvar=0)
    return np.hstack([
    np.max(data,axis=0),\
    np.min(data,axis=0),np.mean(a),\
    np.std(a),\
    np.min(a),np.max(a),
    reg1,reg2,
    np.sign(ts[8,0:2]),
    (np.argmax(dat,axis=0)-np.argmin(dat,axis=0))/length,
    np.array([correlation[0,1],correlation[0,2],correlation[1,2],correlation[0,3],correlation[1,3],correlation[2,3]]),
    dist,
    np.sum(np.diff(np.sign(data),axis=0)>0,axis=0)/length,\
    np.sum(np.diff(np.sign(data),axis=0)<0,axis=0)/length])
Exemple #5
0
    def predict(self, X):       
        """
            The method predicts over the input data
            
            Args:
                Xarr (ndarray<float>): The data to predict over

            Returns:
                (ndarray<int>) The predictions over the data
        """
        X = np.array(X)
        out = []
        for i in range(X.shape[0]):
            loc, dist = _ucrdtw.ucrdtw(self.sequences, X[i,:], 0.05, True)
            out.append(self.labels[np.floor(loc/(2.0*X.shape[1]))])
        return out
Exemple #6
0
    def predict(self, X):
        """
            The method predicts over the input data
            
            Args:
                Xarr (ndarray<float>): The data to predict over

            Returns:
                (ndarray<int>) The predictions over the data
        """
        X = np.array(X)
        out = []
        for i in range(X.shape[0]):
            loc, dist = _ucrdtw.ucrdtw(self.sequences, X[i, :], 0.05, True)
            out.append(self.labels[np.floor(loc / (2.0 * X.shape[1]))])
        return out
def ComputeDTW(sample_data, sample_data2):
    #Read tsFresh tables for all gestures
    sample_data = sample_data.as_matrix()
    sample_data2 = sample_data2.as_matrix()

    mic_distances = []
    for mic in range(1, 5):
        #distance, path = dtw(sample_data[:,mic], sample_data2[:,mic], dist=euclidean)
        loc, distance = _ucrdtw.ucrdtw(stats.zscore(sample_data[:, mic]),
                                       stats.zscore(sample_data2[:, mic]),
                                       0.05)

        #Print results
        mic_distances.append(distance)
        print "Mic: " + str(mic) + ", distance= " + str(distance)

    return mic_distances
def featurize(ts,dat,templates):
    """
    Get the features from the raw tennis data
    :param ts: numpy array of size (samples,sensor readings) which contains the raw data
    :param dat: tuple with start and stop indices to slice data
    :return: 
    :rtype : 
    """
    #start and stop indices 
    s=dat[0]
    t=dat[1]
    #slices the time series 
    data=ts[s:t,:]
    length=1.0*len(data[:,0])
    #this handles the edge case in which the swings is at the very end of the collection
    
    #computes total acceleration
    a=np.sqrt(np.sum(np.array(data**2,dtype=float),axis=1))
    #finds the index which corresponds to the maximum acceleration
    max_index=8
    model1x=sm.OLS(range(1,9),ts[s:s+max_index,0])
    model1y=sm.OLS(range(1,9),ts[s:s+max_index,1]) 
    model1z=sm.OLS(range(1,9),ts[s:s+max_index,2]) 
    reg1=np.array([model1x.fit().params[0],model1y.fit().params[0],model1z.fit().params[0]])
    model2x=sm.OLS(range(1,9),ts[s+max_index:t,0])
    model2y=sm.OLS(range(1,9),ts[s+max_index:t,1]) 
    model2z=sm.OLS(range(1,9),ts[s+max_index:t,2]) 
    reg2=np.array([model2x.fit().params[0],model2y.fit().params[0],model2z.fit().params[0]])
    dist=np.zeros((len(templates)))
    for j,template in enumerate(templates):
        dist[j]=_ucrdtw.ucrdtw(data, template, 0.5, False)[1]
    #cross correlation between each sensor reading
    correlation=np.corrcoef(np.c_[data,a],rowvar=0)
    return np.hstack([
    np.max(data,axis=0),\
    np.min(data,axis=0),np.mean(a),\
    np.std(a),\
    np.min(a),np.max(a),
    reg1,reg2,#reg3,reg4,
    np.sign(ts[8,0:2]),
    (np.argmax(dat,axis=0)-np.argmin(dat,axis=0))/length,
    np.array([correlation[0,1],correlation[0,2],correlation[1,2],correlation[0,3],correlation[1,3],correlation[2,3]]),
    dist,
    np.sum(np.diff(np.sign(data),axis=0)>0,axis=0)/length,\
    np.sum(np.diff(np.sign(data),axis=0)<0,axis=0)/length])
Exemple #9
0
                        metavar='DATA_FILE',
                        type=str,
                        help='Path to data file')
    parser.add_argument('query',
                        metavar='QUERY_FILE',
                        type=str,
                        help='Path to query file')
    parser.add_argument('query_size',
                        metavar='QUERY_SIZE',
                        type=int,
                        default=0,
                        help='Max size of query')
    parser.add_argument('warp_width',
                        metavar='WARP_WIDTH',
                        type=float,
                        default=0.05,
                        help='Width of allowed warp as fraction of query size')
    parser.add_argument('-v',
                        '--verbose',
                        action='store_true',
                        default=False,
                        help='Print verbose info')
    args = parser.parse_args()

    data = numpy.fromfile(args.data, sep=' ')
    query = numpy.fromfile(
        args.query,
        sep=' ',
        count=args.query_size if args.query_size > 0 else -1)
    print _ucrdtw.ucrdtw(data, query, args.warp_width, True)
Exemple #10
0
    parser.add_argument('warp_width',
                        metavar='WARP_WIDTH',
                        type=float,
                        default=0.05,
                        help='Width of allowed warp as fraction of query size')
    parser.add_argument('curr_ind',
                        metavar='CURR_IND',
                        type=int,
                        default=-1,
                        help='Current index for self similarity')
    parser.add_argument('ez',
                        metavar='EZ',
                        type=int,
                        default=2,
                        help='Exclusion Zone for self similarity')
    parser.add_argument('-v',
                        '--verbose',
                        action='store_true',
                        default=False,
                        help='Print verbose info')
    args = parser.parse_args()

    data = numpy.fromfile(args.data, sep=' ')
    query = numpy.fromfile(
        args.query,
        sep=' ',
        count=args.query_size if args.query_size > 0 else -1)
    print(
        _ucrdtw.ucrdtw(data, query, args.warp_width, args.curr_ind, args.ez,
                       True))
Exemple #11
0
import _ucrdtw
import sys
import numpy as np
import matplotlib.pyplot as plt
import math

if __name__ == '__main__':
    data = np.cos(np.linspace(0.0, math.pi * 6, 600)) + (np.random.uniform(-0.5, 0.5, 600) / 10)
    query = np.sin(np.linspace(0.0, math.pi * 2, 200))

    plt.figure()
    plt.plot(data)
    plt.plot(query)
    loc, dist = _ucrdtw.ucrdtw(data, query, 0.05, True)
    query = np.concatenate((np.linspace(0.0, 0.0, loc), query))
    plt.plot(query)
    plt.show()
Exemple #12
0
import _ucrdtw
import sys
import numpy as np
import matplotlib.pyplot as plt
import math

if __name__ == '__main__':
    data = np.cos(np.linspace(0.0, math.pi * 6,
                              600)) + (np.random.uniform(-0.5, 0.5, 600) / 10)
    query = np.sin(np.linspace(0.0, math.pi * 2, 200))

    plt.figure()
    plt.plot(data)
    plt.plot(query)
    loc, dist = _ucrdtw.ucrdtw(data, query, 0.05, True)
    query = np.concatenate((np.linspace(0.0, 0.0, loc), query))
    plt.plot(query)
    plt.show()
Exemple #13
0
     text_file.write("\n" + str(amp + 1) + "," + str(window + 1) +
                     ",ftw," + str(ftwdistance) + "," +
                     str(timet.microseconds) + ',' +
                     str(ftwpath[1][0] + count) + ',' +
                     str(ftwpath[1][-1] + count))
 path1 = np.savetxt('paths/' + "amp_" + str(amp + 1) + "_window_" +
                    str(window + 1) + '_query_ftw.txt',
                    ftwpath[0],
                    delimiter=',')
 path2 = np.savetxt('paths/' + "amp_" + str(amp + 1) + "_window_" +
                    str(window + 1) + '_ref_ftw.txt',
                    ftwpath[1],
                    delimiter=',')
 #ucrdtw
 timeb = datetime.now()
 ucrloc, ucrdist = _ucrdtw.ucrdtw(y, x, 0.05)
 timet = datetime.now() - timeb
 print("ucr complete on amp " + str(amp + 1))
 with open("bench_log.txt", "a") as text_file:
     text_file.write("\n" + str(amp + 1) + "," + str(window + 1) +
                     ",ucr," + str(ucrdist) + "," +
                     str(timet.microseconds) + ',' +
                     str(ucrloc + count) + ',' + str(ucrloc + count))
 with open(
         'paths/' + str(amp + 1) + "," + str(window + 1) +
         '_loc_ucr.txt', "w") as text_file:
     text_file.write(str(ucrloc))
 #cydtw
 timeb = datetime.now()
 cdtw_master = pydtw.dtw(
     x,
def use_dtw(signal, chunk):
    signal_x=signal.axes_data[0]
    chunk_x=chunk.axes_data[0]
    index, dist = dtw.ucrdtw(signal_x, chunk_x, 0.05, False)
    return index, dist
def calc_dtw(scrappie_df_1, scrappie_df_2, warp_width=0.1):
    _, dtw_dist = ucrdtw(scrappie_df_1, scrappie_df_2, warp_width, False)
    dtw_dist = np.float32(dtw_dist)
    return dtw_dist
 def transform_dist(x, y, row):
     index, dist = dtw.ucrdtw(x[row].values, y[row].values,
                              0.05, False)
     return dist
Exemple #17
0
import _ucrdtw
import numpy
import sys
import argparse
import time

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Calculate best DTW location and distance")
    parser.add_argument("data", metavar="DATA_FILE", type=str, help="Path to data file")
    parser.add_argument("query", metavar="QUERY_FILE", type=str, help="Path to query file")
    parser.add_argument("query_size", metavar="QUERY_SIZE", type=int, default=0, help="Max size of query")
    parser.add_argument(
        "warp_width",
        metavar="WARP_WIDTH",
        type=float,
        default=0.05,
        help="Width of allowed warp as fraction of query size",
    )
    parser.add_argument("-v", "--verbose", action="store_true", default=False, help="Print verbose info")
    args = parser.parse_args()

    data = numpy.fromfile(args.data, sep=" ")
    query = numpy.fromfile(args.query, sep=" ", count=args.query_size if args.query_size > 0 else -1)
    print _ucrdtw.ucrdtw(data, query, args.warp_width, True)