def fit(self, X): X = numpy.array(X) X = X.astype(numpy.float32) self._model.fit(X) self._searcher = LOPQSearcher(self._model) self._searcher.add_data(X) print("Fit done")
def __init__(self, name, approximator): self.approximate = True self.name = name self.loaded_entries = set() self.entries = [] self.support_batching = False self.approximator = approximator self.approximator.load() self.searcher = LOPQSearcher(model=self.approximator.model)
def main(input_dir='/Users/aub3/temptest/gtin/', output_dir="/Users/aub3/temptest/products"): products = external_indexed.ProductsIndex(path=output_dir) # products.prepare(input_dir) products.build_approximate() data = products.data # data = load_oxford_data() print data.shape pca_reduction = PCA(n_components=32) pca_reduction.fit(data) data = pca_reduction.transform(data) print data.shape P, mu = pca(data) data = data - mu data = np.dot(data, P) train, test = train_test_split(data, test_size=0.2) print train.shape, test.shape nns = compute_all_neighbors(test, train) m = LOPQModel(V=16, M=8) m.fit(train, n_init=1) print "fitted" searcher = LOPQSearcher(m) print "adding data" searcher.add_data(train) recall, _ = get_recall(searcher, test, nns) print 'Recall (V=%d, M=%d, subquants=%d): %s' % ( m.V, m.M, m.subquantizer_clusters, str(recall)) m2 = LOPQModel(V=16, M=16, parameters=(m.Cs, None, None, None)) m2.fit(train, n_init=1) searcher = LOPQSearcher(m2) searcher.add_data(train) recall, _ = get_recall(searcher, test, nns) print 'Recall (V=%d, M=%d, subquants=%d): %s' % ( m2.V, m2.M, m2.subquantizer_clusters, str(recall)) m3 = LOPQModel(V=16, M=8, subquantizer_clusters=512, parameters=(m.Cs, m.Rs, m.mus, None)) m3.fit(train, n_init=1) searcher = LOPQSearcher(m3) searcher.add_data(train) recall, _ = get_recall(searcher, test, nns) print 'Recall (V=%d, M=%d, subquants=%d): %s' % ( m3.V, m3.M, m3.subquantizer_clusters, str(recall))
def __init__(self,name,approximator): super(LOPQRetriever, self).__init__(name=name,approximator=approximator,algorithm="LOPQ") self.approximate = True self.name = name self.loaded_entries = {} self.entries = [] self.support_batching = False self.approximator = approximator self.approximator.load() self.searcher = LOPQSearcher(model=self.approximator.model)
def cluster(self): print self.data.shape pca_reduction = PCA(n_components=32) pca_reduction.fit(self.data) self.data = pca_reduction.transform(self.data) print self.data.shape P, mu = self.pca() self.data = self.data - mu data = np.dot(self.data, P) train, test = train_test_split(self.data, test_size=0.2) print train.shape, test.shape nns = compute_all_neighbors(test, train) m = LOPQModel(V=16, M=8) m.fit(train, n_init=1) print "fitted" searcher = LOPQSearcher(m) print "adding data" searcher.add_data(train) recall, _ = get_recall(searcher, test, nns) print 'Recall (V=%d, M=%d, subquants=%d): %s' % ( m.V, m.M, m.subquantizer_clusters, str(recall)) m2 = LOPQModel(V=16, M=16, parameters=(m.Cs, None, None, None)) m2.fit(train, n_init=1) searcher = LOPQSearcher(m2) searcher.add_data(train) recall, _ = get_recall(searcher, test, nns) print 'Recall (V=%d, M=%d, subquants=%d): %s' % ( m2.V, m2.M, m2.subquantizer_clusters, str(recall)) m3 = LOPQModel(V=16, M=8, subquantizer_clusters=512, parameters=(m.Cs, m.Rs, m.mus, None)) m3.fit(train, n_init=1) searcher = LOPQSearcher(m3) searcher.add_data(train) recall, _ = get_recall(searcher, test, nns) print 'Recall (V=%d, M=%d, subquants=%d): %s' % ( m3.V, m3.M, m3.subquantizer_clusters, str(recall))
def cluster(self): self.pca_reduction = PCA(n_components=self.n_components) self.pca_reduction.fit(self.data) self.data = self.pca_reduction.transform(self.data) self.P, self.mu = self.pca() self.data = self.data - self.mu self.data = np.dot(self.data, self.P) train, test = train_test_split(self.data, test_size=0.2) self.model = LOPQModel(V=self.v, M=self.m, subquantizer_clusters=self.sub) self.model.fit(train, n_init=1) self.searcher = LOPQSearcher(self.model) if self.test_mode: self.searcher.add_data(train) nns = compute_all_neighbors(test, train) recall, _ = get_recall(self.searcher, test, nns) print 'Recall (V=%d, M=%d, subquants=%d): %s' % ( self.model.V, self.model.M, self.model.subquantizer_clusters, str(recall)) for i, e in enumerate(self.entries): e['coarse'] = self.model.predict(self.data[i]).coarse e['fine'] = self.model.predict(self.data[i]).fine
def fit_model(self,train): self.fit(train) self.model.export_proto(self.model_path) self.searcher = LOPQSearcher(self.model) # LOPQSearcherLMDB(self.model,self.lmdb_path)
def main(): """ A brief demo script showing how to train various LOPQ models with brief discussion of trade offs. """ # Get the oxford dataset data = load_oxford_data() # Compute PCA of oxford dataset. See README in data/oxford for details # about this dataset. P, mu = pca(data) # Mean center and rotate the data; includes dimension permutation. # It is worthwhile see how this affects recall performance. On this # dataset, which is already PCA'd from higher dimensional features, # this additional step to variance balance the dimensions typically # improves recall@1 by 3-5%. The benefit can be much greater depending # on the dataset. data = data - mu data = np.dot(data, P) # Create a train and test split. The test split will become # a set of queries for which we will compute the true nearest neighbors. train, test = train_test_split(data, test_size=0.2) # Compute distance-sorted neighbors in training set for each point in test set. # These will be our groundtruth for recall evaluation. nns = compute_all_neighbors(test, train) # Fit model m = LOPQModel(V=16, M=8) m.fit(train, n_init=1) # Note that we didn't specify a random seed for fitting the model, so different # runs will be different. You may also see a warning that some local projections # can't be estimated because too few points fall in a cluster. This is ok for the # purposes of this demo, but you might want to avoid this by increasing the amount # of training data or decreasing the number of clusters (the V hyperparameter). # With a model in hand, we can test it's recall. We populate a LOPQSearcher # instance with data and get recall stats. By default, we will retrieve 1000 # ranked results for each query vector for recall evaluation. searcher = LOPQSearcher(m) searcher.add_data(train) recall, _ = get_recall(searcher, test, nns) print('Recall (V=%d, M=%d, subquants=%d): %s' % (m.V, m.M, m.subquantizer_clusters, str(recall))) # We can experiment with other hyperparameters without discarding all # parameters everytime. Here we train a new model that uses the same coarse # quantizers but a higher number of subquantizers, i.e. we increase M. m2 = LOPQModel(V=16, M=16, parameters=(m.Cs, None, None, None)) m2.fit(train, n_init=1) # Let's evaluate again. searcher = LOPQSearcher(m2) searcher.add_data(train) recall, _ = get_recall(searcher, test, nns) print('Recall (V=%d, M=%d, subquants=%d): %s' % (m2.V, m2.M, m2.subquantizer_clusters, str(recall))) # The recall is probably higher. We got better recall with a finer quantization # at the expense of more data required for index items. # We can also hold both coarse quantizers and rotations fixed and see what # increasing the number of subquantizer clusters does to performance. m3 = LOPQModel(V=16, M=8, subquantizer_clusters=512, parameters=(m.Cs, m.Rs, m.mus, None)) m3.fit(train, n_init=1) searcher = LOPQSearcher(m3) searcher.add_data(train) recall, _ = get_recall(searcher, test, nns) print('Recall (V=%d, M=%d, subquants=%d): %s' % (m3.V, m3.M, m3.subquantizer_clusters, str(recall)))
gtobj = GTOBJ() relevant_labels_mapping = { 'DSVR': ['ND', 'DS'], 'CSVR': ['ND', 'DS', 'CS'], 'ISVR': ['ND', 'DS', 'CS', 'IS'], } print('LOPQModel!') start = time.time() final_vids, features, vid2features = load_features( '/home/camp/FIVR/features/vcms_v1', is_gv=False) # Define a model and fit it to data model = LOPQModel(V=8, M=4) model.fit(np.array(features).reshape(-1, 512)) # Create a searcher to index data with the model searcher = LOPQSearcher(model) searcher.add_data(features) print('Read time: %.2f' % (time.time() - start)) # 加载特征 vids = list(vid2features.keys()) print(vids[:10]) global_features = np.squeeze( np.asarray(list(vid2features.values()), np.float32)) print(np.shape(global_features)) # 加载vid2name 和 name2vid with open('/home/camp/FIVR/vid2name.pk', 'rb') as pk_file: vid2names = pk.load(pk_file) with open('/home/camp/FIVR/vid2name.pk', 'rb') as pk_file: name2vids = pk.load(pk_file)
def main(new=True): # data: 3000 x 128dim if not new: # load data data = np.load('./data.npy') else: data = np.vstack((np.random.rand(1000, 128), np.random.rand(1000, 128) + 1, np.random.rand(1000, 128) - 1)) print 'make data' # save data np.save('data.npy', data) # wanted to know this nearest neighbors x = np.ones(128) * 2 print 'naive implementation' start = time.time() dist = np.sum(np.power((data - x), 2), axis=1) res = np.argsort(dist) print res[0:10] # return indices; top 10 print time.time() - start, 's taken for naive NNsearch' model = None if not new: # load model model = LOPQModel.load_mat('params.mat') else: # Define a model and fit it to data model = LOPQModel(V=3, M=2, subquantizer_clusters=64) start = time.time() model.fit(data) print time.time() -start, 's taken for model fitting' # save model model.export_mat('params.mat') # Compute the LOPQ codes for a vector # if we define SC as subquantizer_clusters, # input vec(128dim); output: coarse codes(V, V), fine codes(SC, SC) because M = 2 """ for i in xrange(10): y = np.random.rand(128) code = model.predict(y) print 'output: ', code """ # Create a searcher to index data with the model searcher = LOPQSearcher(model) searcher.add_data(data) start = time.time() # Retrieve ranked nearest neighbors nns = searcher.search(x, quota=10) ans = [nns[0][i][0] for i in range(10)] print ans print time.time() -start, 's taken for prediction top 10' count = 0 for element in ans: if element in res[0:10]: count += 1 else: print 'accuracy: ', count, '/', 10