import config from utils import * import faiss import numpy as np from collections import defaultdict from time import time from scipy.spatial import KDTree import tqdm from sklearn.preprocessing import RobustScaler class Blocker: def __init__(self, dataset_name, object_dict, property_dict, feature_importance_scores, property_ratios, blocking_method, sdr_factor, bkafi_criterion, train_or_test): self.dataset_name = dataset_name self.blocking_method = blocking_method self.nn_param = config.Blocking.nn_param self.cand_pairs_per_item_list = config.Blocking.cand_pairs_per_item_list self.bkafi_dim_list = config.Blocking.bkafi_dim_list self.bkafi_criterion = bkafi_criterion self.nbits = config.Blocking.nbits self.object_dict = object_dict self.property_dict = property_dict self.feature_importance_scores = feature_importance_scores self.property_ratios = property_ratios self.sdr_factor = sdr_factor self.train_or_test = train_or_test self.centroids_dict = self._get_centroids() self.cands_mapping = {ind: orig_ind for ind, orig_ind in enumerate(self.object_dict['cands'].keys())} self.index_mapping = {ind: orig_ind for ind, orig_ind in enumerate(self.object_dict['index'].keys())} self.blocking_method_dict = self._get_blocking_method_dict() self.nn_dict, self.dist_dict, self.blocking_execution_time = self._run_blocking() self.pos_pairs_dict, self.neg_pairs_dict = self._get_candidate_pairs() def _get_centroids(self): centroids_dict = defaultdict(dict) for objects_type in ['cands', 'index']: centroids_dict[objects_type] = {obj_ind: obj_data['centroid'] for obj_ind, obj_data in self.object_dict[objects_type].items()} centroids_dict[objects_type] = dict(sorted(centroids_dict[objects_type].items())) return centroids_dict @staticmethod def _get_ind_mapping(centroids): return {ind: orig_ind for ind, orig_ind in enumerate(sorted(centroids))} def _get_blocking_method_dict(self): blocking_method_dict = {'bkafi': self._run_bkafi, 'ViT-B_32': self._run_vit, 'ViT-L_14': self._run_vit, 'centroid': self._run_exhaustive, 'centroid_with_transform': self._run_exhaustive, # 'lsh': self._run_lsh, # 'kdtree': self._run_kdtree, } return blocking_method_dict def _run_blocking(self): nn_dict, dists_dict, blocking_execution_time = self.blocking_method_dict[self.blocking_method]() return nn_dict, dists_dict, blocking_execution_time def _run_exhaustive(self): nn_dict, dists_dict = {}, {} cands_centroids_np = np.array(list(self.centroids_dict['cands'].values()), dtype=np.float32) index_centroids_np = np.array(list(self.centroids_dict['index'].values()), dtype=np.float32) if self.blocking_method == 'centroid_with_transform': cands_centroids_np = self._transform_centroids(cands_centroids_np, index_centroids_np) index = faiss.IndexFlatL2(index_centroids_np.shape[1]) index.add(index_centroids_np) start = time() for i, query_centroid in enumerate(cands_centroids_np): dists, neighbors = index.search(np.array([query_centroid]), self.nn_param) nn_dict[self.cands_mapping[i]] = [self.index_mapping[ind] for ind in neighbors.flatten()] dists_dict[self.cands_mapping[i]] = [dist for dist in dists.flatten()] end = time() return nn_dict, dists_dict, round(end - start, 3) def _transform_centroids(self, cands_centroids_np, index_centroids_np): index_mean = np.mean(index_centroids_np, axis=0) cands_mean = np.mean(cands_centroids_np, axis=0) index_centered = index_centroids_np - index_mean cands_centered = cands_centroids_np - cands_mean H = np.dot(index_centered, cands_centered.T) U, S, Vt = np.linalg.svd(H) rotation_matrix = np.dot(Vt.T, U.T) if np.linalg.det(rotation_matrix) < 0: Vt[-1, :] *= -1 rotation_matrix = np.dot(Vt.T, U.T) translation_vector = cands_mean - np.dot(index_mean, rotation_matrix) scaling_factor = np.linalg.norm(cands_centered) / np.linalg.norm(index_centered) cands_centroids_np = scaling_factor * np.dot(index_centroids_np, rotation_matrix) + translation_vector return cands_centroids_np def _run_lsh(self): nn_dict, dists_dict = {}, {} cands_centroids_np = np.array(list(self.centroids_dict['cands'].values()), dtype=np.float32) index_centroids_np = np.array(list(self.centroids_dict['index'].values()), dtype=np.float32) index = faiss.IndexLSH(index_centroids_np.shape[1], self.nbits) index.add(index_centroids_np) for i, query_centroid in enumerate(cands_centroids_np): dists, neighbors = index.search(np.array([query_centroid]), self.nn_param) nn_dict[self.cands_mapping[i]] = [self.index_mapping[ind] for ind in neighbors.flatten()] dists_dict[self.cands_mapping[i]] = [dist for dist in dists.flatten()] return nn_dict, dists_dict def _run_kdtree(self, search_dict): robust_scaler = RobustScaler() nn_dict, dists_dict = {}, {} cands_vectors_np = np.array(list(search_dict['cands'].values()), dtype=np.float32) index_vectors_np = np.array(list(search_dict['index'].values()), dtype=np.float32) cands_vectors_np = robust_scaler.fit_transform(cands_vectors_np) index_vectors_np = robust_scaler.transform(index_vectors_np) index = KDTree(index_vectors_np) dists, neighbors = index.query(cands_vectors_np, self.nn_param) for i, query_centroid in enumerate(cands_vectors_np): nn_dict[self.cands_mapping[i]] = [self.index_mapping[ind] for ind in neighbors[i]] dists_dict[self.cands_mapping[i]] = [round(dist, 3) for dist in dists[i]] return nn_dict, dists_dict def _run_bkafi(self): if self.train_or_test == 'train': return self._run_bkafi_train() nn_dict, dists_dict = {}, {} model_name = config.Models.blocking_model execution_time_dict = {} for bkafi_dim in self.bkafi_dim_list: target_blocking_features = self._get_target_blocking_features(model_name, bkafi_dim) bkafi_dict = self._get_bkafi_dict(target_blocking_features) start_time = time() nn_dict[bkafi_dim], dists_dict[bkafi_dim] = self._run_kdtree(bkafi_dict) end_time = time() execution_time_dict[bkafi_dim] = round(end_time - start_time, 3) return nn_dict, dists_dict, execution_time_dict def _get_target_blocking_features(self, model_name, bkafi_dim): if self.bkafi_criterion == 'std': target_blocking_features = {prop: prop_information for prop, prop_information in list(self.property_ratios.items())[:bkafi_dim]} else: # feature_importance target_blocking_features = {feature: self.property_ratios[feature.split('_ratio')[0]] for feature, _ in self.feature_importance_scores[model_name][:bkafi_dim]} return target_blocking_features def _run_bkafi_train(self): nn_dict, dists_dict = {}, {} model_name = config.Models.blocking_model bkafi_dim = len(self.feature_importance_scores[model_name]) target_blocking_features = {feature: self.property_ratios[feature.split('_ratio')[0]] for feature, _ in self.feature_importance_scores[model_name][:bkafi_dim]} bkafi_dict = self._get_bkafi_dict(target_blocking_features) nn_dict[bkafi_dim], dists_dict[bkafi_dim] = self._run_kdtree(bkafi_dict) return nn_dict, dists_dict, None def _get_bkafi_dict(self, target_blocking_features): bkafi_dict = defaultdict(dict) factor_dict = self._get_bkafi_factor_dict(target_blocking_features) for obj_type in ['cands', 'index']: for obj_ind in self.object_dict[obj_type].keys(): bkafi_dict[obj_type][obj_ind] = [] for feature in target_blocking_features: property_val = self.property_dict[feature.split('_ratio')[0]][obj_type][obj_ind] bkafi_dict[obj_type][obj_ind].append(property_val * factor_dict[obj_type][feature]) bkafi_dict[obj_type][obj_ind] = np.array(bkafi_dict[obj_type][obj_ind]) return bkafi_dict def _get_bkafi_factor_dict(self, target_blocking_features): factor_dict = defaultdict(dict) if self.sdr_factor: factor_dict['cands'] = {feature: target_blocking_features[feature]['mean'] for feature in target_blocking_features} else: factor_dict['cands'] = {feature: 1.0 for feature in target_blocking_features} factor_dict['index'] = {feature: 1.0 for feature in target_blocking_features} return factor_dict def _run_vit(self): vit_model_name = self.blocking_method embeddings_dict = get_embeddings_wrapper(self.dataset_name, self.object_dict, vit_model_name) faiss_embds_dict, mapping_dict = get_faiss_embeddings(embeddings_dict) dim = faiss_embds_dict['index'].shape[1] index = faiss.IndexFlatIP(dim) index.add(faiss_embds_dict['index']) nn_dict, dists_dict = {}, {} start_time = time() for i, cand_query in enumerate(faiss_embds_dict['cands']): query = cand_query.reshape(1, -1) dists, neighbors = index.search(query, self.nn_param) nn_dict[mapping_dict['cands'][i]] = [mapping_dict['index'][ind] for ind in neighbors[0]] dists_dict[mapping_dict['cands'][i]] = [dist for dist in dists[0]] end_time = time() return nn_dict, dists_dict, round(end_time - start_time, 3) @staticmethod def _get_start_ind4nn(nn_inds, cand_ind): if nn_inds[0] + 1 == cand_ind: return 1 else: return 0 def _get_candidate_pairs(self): if self.train_or_test == 'train': cand_pairs_per_item_list = [self.cand_pairs_per_item_list[0]] else: cand_pairs_per_item_list = self.cand_pairs_per_item_list if 'bkafi' in self.blocking_method: return self._get_candidate_pairs_bkafi(cand_pairs_per_item_list) else: return self._get_candidate_pairs_not_bkafi(cand_pairs_per_item_list) def _get_candidate_pairs_bkafi(self, cand_pairs_per_item_list): pos_pairs_dict, neg_pairs_dict = defaultdict(dict), defaultdict(dict) for bkafi_dim in self.nn_dict.keys(): for list_ind, cand_pairs_per_item in enumerate(cand_pairs_per_item_list): if list_ind == 0: pos_pairs_dict[bkafi_dim][cand_pairs_per_item] = [] neg_pairs_dict[bkafi_dim][cand_pairs_per_item] = [] else: previous_val = self.cand_pairs_per_item_list[list_ind - 1] pos_pairs_dict[bkafi_dim][cand_pairs_per_item] = pos_pairs_dict[bkafi_dim][previous_val].copy() neg_pairs_dict[bkafi_dim][cand_pairs_per_item] = neg_pairs_dict[bkafi_dim][previous_val].copy() for cand_ind, nn_inds in self.nn_dict[bkafi_dim].items(): start_ind = self.cand_pairs_per_item_list[list_ind - 1] if list_ind > 0 else 0 # cand_ind = str(cand_ind) for nn_ind in nn_inds[start_ind:cand_pairs_per_item]: if cand_ind == nn_ind: pos_pairs_dict[bkafi_dim][cand_pairs_per_item].append((cand_ind, nn_ind)) else: neg_pairs_dict[bkafi_dim][cand_pairs_per_item].append((cand_ind, nn_ind)) return pos_pairs_dict, neg_pairs_dict def _get_candidate_pairs_not_bkafi(self, cand_pairs_per_item_list): pos_pairs_dict, neg_pairs_dict = dict(), dict() for list_ind, cand_pairs_per_item in enumerate(cand_pairs_per_item_list): if list_ind == 0: pos_pairs_dict[cand_pairs_per_item] = [] neg_pairs_dict[cand_pairs_per_item] = [] else: previous_val = self.cand_pairs_per_item_list[list_ind - 1] pos_pairs_dict[cand_pairs_per_item] = pos_pairs_dict[previous_val].copy() neg_pairs_dict[cand_pairs_per_item] = neg_pairs_dict[previous_val].copy() for cand_ind, nn_inds in self.nn_dict.items(): start_ind = self.cand_pairs_per_item_list[list_ind - 1] if list_ind > 0 else 0 cand_ind = str(cand_ind) for nn_ind in nn_inds[start_ind:cand_pairs_per_item]: if cand_ind == nn_ind: pos_pairs_dict[cand_pairs_per_item].append((cand_ind, nn_ind)) else: neg_pairs_dict[cand_pairs_per_item].append((cand_ind, nn_ind)) return pos_pairs_dict, neg_pairs_dict def _get_local_mapping_dict(self): """ This function returns the mapping dictionary of the objects in the current object_dict. The mapping is required because in some datasets object file names are recognized as integers and in some datasets as uids """ local_mapping_dict = defaultdict(dict) if 'mapping_dict' not in self.object_dict.keys(): local_mapping_dict['cands'] = {ind: ind for ind in self.object_dict['cands'].keys()} local_mapping_dict['index'] = {ind: ind for ind in self.object_dict['index'].keys()} else: local_mapping_dict['cands'] = self.object_dict['mapping_dict']['cands'] local_mapping_dict['index'] = self.object_dict['mapping_dict']['index'] return local_mapping_dict