def main(): print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&') client = TSDBClient() n_add = 50 mus = np.random.uniform(low=0.0, high=1.0, size=n_add) sigs = np.random.uniform(low=0.05, high=0.4, size=n_add) jits = np.random.uniform(low=0.05, high=0.2, size=n_add) for i, m, s, j in zip(range(n_add), mus, sigs, jits): client.insert_ts("ts-{}".format(i), tsmaker(m, s, j)) for i in range(5): client.add_vp() _, results = client.select(fields=[]) print("RESULT TYPE: ", type(results)) for k in results: print(k, results[k]) m = np.random.uniform(low=0.0, high=1.0) s = np.random.uniform(low=0.05, high=0.4) j = np.random.uniform(low=0.05, high=0.2) query = tsmaker(m, s, j) _, closest = client.simsearch(query) print("CLOSEST MATCH: ", closest) _, closest = client.sim_search_SAX(query) print("CLOSEST MATCH: ", closest)
def main(): client = TSDBClient() client.insert_ts('one',ts.TimeSeries([1, 2, 3],[1, 4, 9])) client.insert_ts('two',ts.TimeSeries([2, 3, 4],[4, 9, 16])) client.insert_ts('three',ts.TimeSeries([9,3,4],[4,0,16])) client.insert_ts('four',ts.TimeSeries([0,0,4],[1,0,4])) client.upsert_meta('one', {'order': 1, 'blarg': 1}) client.upsert_meta('two', {'order': 2}) client.upsert_meta('three', {'order': 1, 'blarg': 2}) client.upsert_meta('four', {'order': 2, 'blarg': 2}) client.select() client.select({'order': 1}) client.select({'blarg': 1}) bla = client.select({'order': 1, 'blarg': 2}) print("END", bla)
def main(): print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&') client = TSDBClient() # add a trigger. notice the argument. It does not do anything here but # could be used to save a shlep of data from client to server. client.add_trigger('junk', 'insert_ts', None, 'db:one:ts') # our stats trigger client.add_trigger('stats', 'insert_ts', ['mean', 'std'], None) #Set up 50 time series mus = np.random.uniform(low=0.0, high=1.0, size=50) sigs = np.random.uniform(low=0.05, high=0.4, size=50) jits = np.random.uniform(low=0.05, high=0.2, size=50) # dictionaries for time series and their metadata tsdict={} metadict={} for i, m, s, j in zip(range(50), mus, sigs, jits): meta, tsrs = tsmaker(m, s, j) # the primary key format is ts-1, ts-2, etc pk = "ts-{}".format(i) tsdict[pk] = tsrs meta['vp'] = False # augment metadata with a boolean asking if this is a VP. metadict[pk] = meta # choose 5 distinct vantage point time series vpkeys = ["ts-{}".format(i) for i in np.random.choice(range(50), size=5, replace=False)] for i in range(5): # add 5 triggers to upsert distances to these vantage points client.add_trigger('corr', 'insert_ts', ["d_vp-{}".format(i)], tsdict[vpkeys[i]]) print('lalala:', i, *tsdict[vpkeys[i]]) # change the metadata for the vantage points to have meta['vp']=True metadict[vpkeys[i]]['vp']=True # Having set up the triggers, now inser the time series, and upsert the metadata for k in tsdict: client.insert_ts(k, tsdict[k]) client.upsert_meta(k, metadict[k]) print("UPSERTS FINISHED") print('---------------------') print("STARTING SELECTS") print('---------DEFAULT------------') client.select() #in this version, select has sprouted an additional keyword argument # to allow for sorting. Limits could also be enforced through this. print('---------ADDITIONAL------------') print(client.select(additional={'sort_by': '-order'})) print('----------ORDER FIELD-----------') _, results = client.select(fields=['order']) print(results) for k in results: print(k, results[k]) print('---------ALL FIELDS------------') client.select(fields=[]) print('------------TS with order 1---------') client.select({'order': 1}, fields=['ts']) print('------------All fields, blarg 1 ---------') client.select({'blarg': 1}, fields=[]) print('------------order 1 blarg 2 no fields---------') _, bla = client.select({'order': 1, 'blarg': 2}) print(bla) print('------------order >= 4 order, blarg and mean sent back, also sorted---------') _, results = client.select({'order': {'>=': 4}}, fields=['order', 'blarg', 'mean'], additional={'sort_by': '-order'}) for k in results: print(k, results[k]) print('------------order 1 blarg >= 1 fields blarg and std---------') _, results = client.select({'blarg': {'>=': 1}, 'order': 1}, fields=['blarg', 'std']) for k in results: print(k, results[k]) print('------now computing vantage point stuff---------------------') #we first create a query time series. _, query = tsmaker(0.5, 0.2, 0.1) # Step 1: in the vpdist key, get distances from query to vantage points # this is an augmented select client.insert_ts('ts-query',query) dists = client.select({'pk': 'ts-query'},fields=['d_vp-{}'.format(i) for i in range(5)])[1]['ts-query'] min_dist = np.inf nearest_vp_to_query = None for vp in dists: if dists[vp] < min_dist: min_dist = dists[vp] nearest_vp_to_query = vp print(nearest_vp_to_query,min_dist) #1b: choose the lowest distance vantage point # you can do this in local code # Step 2: find all time series within 2*d(query, nearest_vp_to_query) #this is an augmented select to the same proc in correlation # nearestwanted = client.augmented_select('corr', ['d_vp-1'], arg=query, # metadata_dict={'d_vp-1': {'<=': 2.0*min_dist}}, additional={'sort_by': '+d_vp-1', 'limit': 10}) #print(client.select(fields=['d_vp-1'])) #print(2*min_dist) nearestwanted = client.select(fields=['d_vp-1'], metadata_dict={'d_vp-1': {'<=': 2.0*min_dist}}, additional={'sort_by': '+d_vp-1', 'limit': 10}) print(nearestwanted) nearestwanted = list(nearestwanted[1].keys())[0] #2b: find the smallest distance amongst this ( or k smallest) #you can do this in local code #your code here ends # plot the timeseries to see visually how we did. import matplotlib.pyplot as plt for k in tsdict: plt.plot(tsdict[k], alpha=0.15) plt.plot(query) plt.plot(tsdict[nearestwanted]) plt.show()
def main(): print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&') client = TSDBClient(30000) # add a trigger. notice the argument. It does not do anything here but # could be used to save a shlep of data from client to server. client.add_trigger('junk', 'insert_ts', None, 'db:one:ts') # our stats trigger client.add_trigger('stats', 'insert_ts', ['mean', 'std'], None) # Set up 50 time series mus = np.random.uniform(low=0.0, high=1.0, size=50) sigs = np.random.uniform(low=0.05, high=0.4, size=50) jits = np.random.uniform(low=0.05, high=0.2, size=50) # dictionaries for time series and their metadata tsdict = {} metadict = {} for i, m, s, j in zip(range(50), mus, sigs, jits): meta, tsrs = tsmaker(m, s, j) # the primary key format is ts-1, ts-2, etc pk = "ts-{}".format(i) tsdict[pk] = tsrs meta[ 'vp'] = False # augment metadata with a boolean asking if this is a VP. metadict[pk] = meta # choose 5 distinct vantage point time series vpkeys = [ "ts-{}".format(i) for i in np.random.choice(range(50), size=5, replace=False) ] for i in range(5): # add 5 triggers to upsert distances to these vantage points client.add_trigger('corr', 'insert_ts', ["d_vp-{}".format(i)], tsdict[vpkeys[i]]) # change the metadata for the vantage points to have meta['vp']=True metadict[vpkeys[i]]['vp'] = True # Having set up the triggers, now insert the time series, and upsert the metadata for k in tsdict: client.insert_ts(k, tsdict[k]) time.sleep(1) client.upsert_meta(k, metadict[k]) print("UPSERTS FINISHED") time.sleep(5) print('---------------------') print("STARTING SELECTS") print('---------DEFAULT------------') client.select() # in this version, select has sprouted an additional keyword argument # to allow for sorting. Limits could also be enforced through this. print('---------ADDITIONAL------------') client.select(additional={'sort_by': '-order'}) print('----------ORDER FIELD-----------') _, results = client.select(fields=['order']) for k in results: print(k, results[k]) print('---------ALL FIELDS------------') client.select(fields=[]) print('------------TS with order 1---------') client.select({'order': 1}, fields=['ts']) print('------------All fields, blarg 1 ---------') client.select({'blarg': 1}, fields=[]) print('------------order 1 blarg 2 no fields---------') _, bla = client.select({'order': 1, 'blarg': 2}) print(bla) print( '------------order >= 4 order, blarg and mean sent back, also sorted---------' ) _, results = client.select({'order': { '>=': 4 }}, fields=['order', 'blarg', 'mean'], additional={'sort_by': '-order'}) for k in results: print(k, results[k]) print('------------order 1 blarg >= 1 fields blarg and std---------') _, results = client.select({ 'blarg': { '>=': 1 }, 'order': 1 }, fields=['blarg', 'std']) for k in results: print(k, results[k]) print('------now computing vantage point stuff---------------------') print("VPS", vpkeys) # # # we first create a query time series. _, query = tsmaker(0.5, 0.2, 0.1) # query = tsdict['ts-6'] # # # your code here begins # # # Step 1: in the vpdist key, get distances from query to vantage points # # this is an augmented select res = client.augmented_select('corr', ['dist'], query, {'vp': True}) print(res) # # 1b: choose the lowest distance vantage point # # you can do this in local code d_res = res[1] sorted_res = [] for k, v in d_res.items(): sorted_res.append((v['dist'], k)) sorted_res.sort() D = sorted_res[0][0] D_vp = vpkeys.index(sorted_res[0][1]) print(sorted_res, 'D = ', D) # # Step 2: find all time series within 2*d(query, nearest_vp_to_query) # # this is an augmented select to the same proc in correlation res2 = client.augmented_select('corr', ['dist'], query, {'d_vp-{}'.format(D_vp): { '<=': 2 * D }}) print(res2) # # 2b: find the smallest distance amongst this ( or k smallest) d_res = res2[1] sorted_res = [] for k, v in d_res.items(): sorted_res.append((v['dist'], k)) sorted_res.sort() D = sorted_res[0][0] D_k = sorted_res[0][1] print(sorted_res, 'D = ', D, 'D_k = ', D_k) nearestwanted = D_k # # you can do this in local code # # your code here ends # # plot the timeseries to see visually how we did. import matplotlib matplotlib.use('qt4agg') import matplotlib.pyplot as plt plt.plot(query, label='') plt.plot(tsdict[nearestwanted]) plt.show()
def main(): print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&') client = TSDBClient() # add a trigger. notice the argument. It does not do anything here but # could be used to save a shlep of data from client to server. client.add_trigger('junk', 'insert_ts', None, 'db:one:ts') # our stats trigger client.add_trigger('stats', 'insert_ts', ['mean', 'std'], None) #Set up 50 time series mus = np.random.uniform(low=0.0, high=1.0, size=50) sigs = np.random.uniform(low=0.05, high=0.4, size=50) jits = np.random.uniform(low=0.05, high=0.2, size=50) # dictionaries for time series and their metadata tsdict = {} metadict = {} for i, m, s, j in zip(range(50), mus, sigs, jits): meta, tsrs = tsmaker(m, s, j) # the primary key format is ts-1, ts-2, etc pk = "ts-{}".format(i) tsdict[pk] = tsrs meta[ 'vp'] = False # augment metadata with a boolean asking if this is a VP. metadict[pk] = meta # choose 5 distinct vantage point time series vpkeys = [ "ts-{}".format(i) for i in np.random.choice(range(50), size=5, replace=False) ] for i in range(5): # add 5 triggers to upsert distances to these vantage points client.add_trigger('corr', 'insert_ts', ["d_vp-{}".format(i)], tsdict[vpkeys[i]]) print('lalala:', i, *tsdict[vpkeys[i]]) # change the metadata for the vantage points to have meta['vp']=True metadict[vpkeys[i]]['vp'] = True # Having set up the triggers, now inser the time series, and upsert the metadata for k in tsdict: client.insert_ts(k, tsdict[k]) client.upsert_meta(k, metadict[k]) print("UPSERTS FINISHED") print('---------------------') print("STARTING SELECTS") print('---------DEFAULT------------') client.select() #in this version, select has sprouted an additional keyword argument # to allow for sorting. Limits could also be enforced through this. print('---------ADDITIONAL------------') print(client.select(additional={'sort_by': '-order'})) print('----------ORDER FIELD-----------') _, results = client.select(fields=['order']) print(results) for k in results: print(k, results[k]) print('---------ALL FIELDS------------') client.select(fields=[]) print('------------TS with order 1---------') client.select({'order': 1}, fields=['ts']) print('------------All fields, blarg 1 ---------') client.select({'blarg': 1}, fields=[]) print('------------order 1 blarg 2 no fields---------') _, bla = client.select({'order': 1, 'blarg': 2}) print(bla) print( '------------order >= 4 order, blarg and mean sent back, also sorted---------' ) _, results = client.select({'order': { '>=': 4 }}, fields=['order', 'blarg', 'mean'], additional={'sort_by': '-order'}) for k in results: print(k, results[k]) print('------------order 1 blarg >= 1 fields blarg and std---------') _, results = client.select({ 'blarg': { '>=': 1 }, 'order': 1 }, fields=['blarg', 'std']) for k in results: print(k, results[k]) print('------now computing vantage point stuff---------------------') #we first create a query time series. _, query = tsmaker(0.5, 0.2, 0.1) # Step 1: in the vpdist key, get distances from query to vantage points # this is an augmented select client.insert_ts('ts-query', query) dists = client.select({'pk': 'ts-query'}, fields=['d_vp-{}'.format(i) for i in range(5)])[1]['ts-query'] min_dist = np.inf nearest_vp_to_query = None for vp in dists: if dists[vp] < min_dist: min_dist = dists[vp] nearest_vp_to_query = vp print(nearest_vp_to_query, min_dist) #1b: choose the lowest distance vantage point # you can do this in local code # Step 2: find all time series within 2*d(query, nearest_vp_to_query) #this is an augmented select to the same proc in correlation # nearestwanted = client.augmented_select('corr', ['d_vp-1'], arg=query, # metadata_dict={'d_vp-1': {'<=': 2.0*min_dist}}, additional={'sort_by': '+d_vp-1', 'limit': 10}) #print(client.select(fields=['d_vp-1'])) #print(2*min_dist) nearestwanted = client.select( fields=['d_vp-1'], metadata_dict={'d_vp-1': { '<=': 2.0 * min_dist }}, additional={ 'sort_by': '+d_vp-1', 'limit': 10 }) print(nearestwanted) nearestwanted = list(nearestwanted[1].keys())[0] #2b: find the smallest distance amongst this ( or k smallest) #you can do this in local code #your code here ends # plot the timeseries to see visually how we did. import matplotlib.pyplot as plt for k in tsdict: plt.plot(tsdict[k], alpha=0.15) plt.plot(query) plt.plot(tsdict[nearestwanted]) plt.show()
def main(): print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&') client = TSDBClient(30000) # add a trigger. notice the argument. It does not do anything here but # could be used to save a shlep of data from client to server. client.add_trigger('junk', 'insert_ts', None, 'db:one:ts') # our stats trigger client.add_trigger('stats', 'insert_ts', ['mean', 'std'], None) # Set up 50 time series mus = np.random.uniform(low=0.0, high=1.0, size=50) sigs = np.random.uniform(low=0.05, high=0.4, size=50) jits = np.random.uniform(low=0.05, high=0.2, size=50) # dictionaries for time series and their metadata tsdict = {} metadict = {} for i, m, s, j in zip(range(50), mus, sigs, jits): meta, tsrs = tsmaker(m, s, j) # the primary key format is ts-1, ts-2, etc pk = "ts-{}".format(i) tsdict[pk] = tsrs meta['vp'] = False # augment metadata with a boolean asking if this is a VP. metadict[pk] = meta # choose 5 distinct vantage point time series vpkeys = ["ts-{}".format(i) for i in np.random.choice(range(50), size=5, replace=False)] for i in range(5): # add 5 triggers to upsert distances to these vantage points client.add_trigger('corr', 'insert_ts', ["d_vp-{}".format(i)], tsdict[vpkeys[i]]) # change the metadata for the vantage points to have meta['vp']=True metadict[vpkeys[i]]['vp'] = True # Having set up the triggers, now insert the time series, and upsert the metadata for k in tsdict: client.insert_ts(k, tsdict[k]) time.sleep(1) client.upsert_meta(k, metadict[k]) print("UPSERTS FINISHED") time.sleep(5) print('---------------------') print("STARTING SELECTS") print('---------DEFAULT------------') client.select() # in this version, select has sprouted an additional keyword argument # to allow for sorting. Limits could also be enforced through this. print('---------ADDITIONAL------------') client.select(additional={'sort_by': '-order'}) print('----------ORDER FIELD-----------') _, results = client.select(fields=['order']) for k in results: print(k, results[k]) print('---------ALL FIELDS------------') client.select(fields=[]) print('------------TS with order 1---------') client.select({'order': 1}, fields=['ts']) print('------------All fields, blarg 1 ---------') client.select({'blarg': 1}, fields=[]) print('------------order 1 blarg 2 no fields---------') _, bla = client.select({'order': 1, 'blarg': 2}) print(bla) print('------------order >= 4 order, blarg and mean sent back, also sorted---------') _, results = client.select({'order': {'>=': 4}}, fields=['order', 'blarg', 'mean'], additional={'sort_by': '-order'}) for k in results: print(k, results[k]) print('------------order 1 blarg >= 1 fields blarg and std---------') _, results = client.select({'blarg': {'>=': 1}, 'order': 1}, fields=['blarg', 'std']) for k in results: print(k, results[k]) print('------now computing vantage point stuff---------------------') print("VPS", vpkeys) # # # we first create a query time series. _, query = tsmaker(0.5, 0.2, 0.1) # query = tsdict['ts-6'] # # # your code here begins # # # Step 1: in the vpdist key, get distances from query to vantage points # # this is an augmented select res = client.augmented_select('corr', ['dist'], query, {'vp': True}) print(res) # # 1b: choose the lowest distance vantage point # # you can do this in local code d_res = res[1] sorted_res = [] for k, v in d_res.items(): sorted_res.append((v['dist'], k)) sorted_res.sort() D = sorted_res[0][0] D_vp = vpkeys.index(sorted_res[0][1]) print (sorted_res, 'D = ', D) # # Step 2: find all time series within 2*d(query, nearest_vp_to_query) # # this is an augmented select to the same proc in correlation res2 = client.augmented_select('corr', ['dist'], query, {'d_vp-{}'.format(D_vp): {'<=': 2*D}}) print (res2) # # 2b: find the smallest distance amongst this ( or k smallest) d_res = res2[1] sorted_res = [] for k, v in d_res.items(): sorted_res.append( (v['dist'], k) ) sorted_res.sort() D = sorted_res[0][0] D_k = sorted_res[0][1] print (sorted_res, 'D = ', D, 'D_k = ', D_k) nearestwanted = D_k # # you can do this in local code # # your code here ends # # plot the timeseries to see visually how we did. import matplotlib matplotlib.use('qt4agg') import matplotlib.pyplot as plt plt.plot(query, label='') plt.plot(tsdict[nearestwanted]) plt.show()