Upload STER-GI code

code/blocking.py

@@ -0,0 +1,267 @@
+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
+

code/classifier.py

@@ -0,0 +1,324 @@
+from sklearn.model_selection import GridSearchCV
+from sklearn.ensemble import (RandomForestClassifier, AdaBoostClassifier,
+                              GradientBoostingClassifier, BaggingClassifier)
+from xgboost import XGBClassifier
+from sklearn.svm import SVC
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import precision_score, recall_score, f1_score, make_scorer
+import logging
+from sklearn.neural_network import MLPClassifier
+import joblib
+from collections import defaultdict
+import config
+import os
+from sklearn.preprocessing import LabelEncoder
+import numpy as np
+from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
+import matplotlib.pyplot as plt
+from utils import get_feature_name_list, get_file_name
+from time import time
+
+
+class FlexibleClassifier:
+    def __init__(self, dataset_dict, property_dict, params_dict, seed, logger, dataset_name, evaluation_mode,
+                 dataset_size_version, neg_samples_num, load_trained_models=False, cv=5, dirty=False,
+                 contamination_level=0.0, contaminated_indices_dict=None):
+        self.dataset_dict = dataset_dict
+        self.property_dict = property_dict
+        self.params_dict = params_dict
+        self.seed = seed
+        self.dataset_size_version = dataset_size_version
+        self.neg_samples_num = neg_samples_num
+        self.load_trained_models = load_trained_models
+        self.dirty = dirty
+        self.cv = cv
+        self.models_path = f"{config.FilePaths.saved_models_path}/{dataset_name}/"
+        self.dataset_name = dataset_name
+        self.logger = logger
+        self.evaluation_mode = evaluation_mode
+        self.contamination_level = contamination_level
+        self.contaminated_indices_dict = contaminated_indices_dict
+        self.model_dict = self._get_model_dict()
+        self.file_name = get_file_name()
+        self.scorer = make_scorer(f1_score, average='macro')
+        self.best_model_dict, self.result_dict = self._train_and_evaluate_all_models()
+        self._print_results()
+
+    def _get_model_dict(self):
+        model_dict = {
+            'RandomForestClassifier': RandomForestClassifier(random_state=self.seed),
+            'SVC': SVC(random_state=self.seed),
+            'LogisticRegression': LogisticRegression(random_state=self.seed),
+            'MLPClassifier': MLPClassifier(random_state=self.seed),
+            'AdaBoostClassifier': AdaBoostClassifier(random_state=self.seed),
+            'GradientBoostingClassifier': GradientBoostingClassifier(random_state=self.seed),
+            'BaggingClassifier': BaggingClassifier(random_state=self.seed),
+            'XGBClassifier': XGBClassifier(random_state=self.seed)
+        }
+        return model_dict
+
+    def _get_model_general_file_name(self):
+        general_file_name = (f"{self.evaluation_mode}_{self.file_name}_{self.dataset_size_version}_"
+                             f"neg_samples_num={self.neg_samples_num}")
+        if self.contamination_level > 0.0:
+            general_file_name += f"_contamination_level={self.contamination_level}"
+        return general_file_name
+
+    def _save_model(self, model, model_name):
+        general_file_name = self._get_model_general_file_name()
+        if not os.path.exists(self.models_path[:-1]):
+            os.makedirs(self.models_path[:-1])
+        try:
+            model_file_name = f'{self.models_path}{model_name}_{general_file_name}_seed{self.seed}.joblib'
+            feature_name_list = self._get_final_feature_name_list()
+            joblib.dump({'model': model, 'feature_name_list': feature_name_list}, model_file_name)
+            logging.info(f"Model {model_name} was saved successfully ({self.evaluation_mode})")
+            logging.info('')
+        except Exception as e:
+            logging.error(f"Error happened while saving model {model_name} ({self.evaluation_mode}): {e}")
+
+    def _load_model(self, model_name):
+        general_file_name = self._get_model_general_file_name()
+        try:
+            model = joblib.load(f'{self.models_path}{model_name}_{general_file_name}_seed{self.seed}.joblib')
+            logging.info(f"Model {model_name} was loaded successfully")
+            logging.info('')
+            print(f"Model {model_name} was loaded successfully {self.evaluation_mode})")
+            return model['model']
+        except Exception as e:
+            logging.error(f"Error happened while loading model {model_name}: {e}. Starting training...")
+            print(f"Error happened while loading model {model_name}: {e}. Starting training...")
+            return None
+
+    @staticmethod
+    def _get_final_feature_name_list():
+        operator = config.Features.operator
+        feature_name_list = get_feature_name_list(operator)
+        return feature_name_list
+
+    @staticmethod
+    def _get_neighborhood_feature_name_list():
+        if config.Features.knn_buildings == 0:
+            return []
+        with_knn = [f"{i}_nearest_building_dists" for i in range(1, config.Features.knn_buildings + 1)]
+        other_features = [feature for feature in config.Features.neighborhood if feature != "nearest_building_dists"]
+        return with_knn + other_features
+
+    @staticmethod
+    def _get_roads_feature_name_list():
+        if config.Features.knn_roads == 0:
+            return []
+        with_knn = [f"{i}_nearest_road_dists" for i in range(1, config.Features.knn_roads + 1)]
+        other_features = [feature for feature in config.Features.roads if feature != "nearest_road_dists"]
+        return with_knn + other_features
+
+    def _train_and_evaluate_all_models(self):
+        result_dict = defaultdict(dict)
+        best_model_dict = defaultdict(dict)
+        for model_name, model_params in self.params_dict.items():
+            try:
+                best_model_dict, result_dict = self._train_and_evaluate_model_wrapper(result_dict, best_model_dict,
+                                                                                      model_name, model_params)
+            except Exception as e:
+                logging.error(f"Error for model {model_name}: {e}")
+        return best_model_dict, result_dict
+
+    def _train_and_evaluate_model_wrapper(self, result_dict, best_model_dict, model_name, model_params):
+        if self.contaminated_indices_dict is not None:
+            best_model_dict[model_name], result_dict = self._train_and_evaluate_model_contam(result_dict,
+                                                                                             model_name,
+                                                                                             model_params)
+        elif self.dirty is True:
+            best_model_dict[model_name], result_dict = self._train_and_evaluate_model_dirty(result_dict,
+                                                                                            model_name,
+                                                                                            model_params)
+
+        else:
+            best_model_dict[model_name], result_dict = self._train_and_evaluate_model(result_dict,
+                                                                                      model_name,
+                                                                                      model_params)
+        return best_model_dict, result_dict
+
+    def _get_best_model(self, model_name, params):
+        if self.load_trained_models:
+            best_model = self._load_model(model_name)
+            if best_model is not None:
+                return best_model, 0.0
+        model = self.model_dict[model_name]
+        best_model, training_time = self._train_model(model_name, model, params)
+        self._save_model(best_model, model_name)
+        return best_model, training_time
+
+    def _train_and_evaluate_model(self, result_dict, model_name, params):
+        best_model, training_time = self._get_best_model(model_name, params)
+        feature_name_list = self._get_final_feature_name_list()
+        data_type = 'train' if self.evaluation_mode == "blocking" else 'test'
+        x_test = self.dataset_dict[data_type]['X']
+        start_time = time()
+        y_test_preds = best_model.predict(x_test)
+        inference_time = round(time() - start_time, 2)
+        self.logger.info(f"Model {model_name} was evaluated successfully in {inference_time} seconds")
+        result_dict = self._insert_results_to_dict(result_dict, model_name, y_test_preds,
+                                                   training_time, inference_time)
+        return {'model': best_model, 'feature_name_list': feature_name_list}, result_dict
+
+    def _train_and_evaluate_model_contam(self, result_dict, model_name, params):
+        best_model, _ = self._get_best_model(model_name, params)
+        feature_name_list = self._get_final_feature_name_list()
+        contaminated_indices = self.contaminated_indices_dict['test']
+        x_test_all = self.dataset_dict['test']['X']
+        x_test_contaminated = x_test_all[contaminated_indices]
+        y_test_preds_all = best_model.predict(x_test_all)
+        y_test_preds_contaminated = best_model.predict(x_test_contaminated)
+        self.logger.info(f"Model {model_name} was evaluated successfully")
+        result_dict = self._insert_results_to_dict_contaminated(result_dict, model_name, y_test_preds_all,
+                                                                y_test_preds_contaminated, contaminated_indices)
+        return {'model': best_model, 'feature_name_list': feature_name_list}, result_dict
+
+    def _train_and_evaluate_model_dirty(self, result_dict, model_name, params):
+        best_model, training_time = self._get_best_model(model_name, params)
+        feature_name_list = self._get_final_feature_name_list()
+        x_test = self.dataset_dict['test']['X']
+        x_test_dirty = self.dataset_dict['test_dirty']['X']
+        y_test_preds = best_model.predict(x_test)
+        y_test_preds_dirty = best_model.predict(x_test_dirty)
+        result_dict = self._insert_results_to_dict_dirty(result_dict, model_name, y_test_preds, y_test_preds_dirty)
+        return {'model': best_model, 'feature_name_list': feature_name_list}, result_dict
+
+    def _get_y_train(self, model_name):
+        y_train = self.dataset_dict['train']['Y']
+        if model_name == 'XGBClassifier':
+            le = LabelEncoder()
+            return le.fit_transform(y_train)
+        else:
+            return y_train
+
+    def _train_model(self, model_name, model, params):
+        start_time = time()
+        if 'train' not in self.dataset_dict.keys():
+            raise ValueError("You first need to run the code with "
+                             "config.TrainingPhase.run_preparatory_phase = True")
+        x_train = self.dataset_dict['train']['X']
+        y_train = self._get_y_train(model_name)
+        self.logger.info(f"Training model {model.__class__.__name__}...")
+        grid_search = GridSearchCV(model, params, cv=self.cv, scoring=self.scorer)
+        grid_search.fit(x_train, y_train)
+        best_model = grid_search.best_estimator_
+        total_time = round(time() - start_time, 2)
+        self.logger.info(f"Model {model_name} was trained successfully in {total_time} seconds")
+        return best_model, total_time
+
+    def _insert_results_to_dict(self, result_dict, model_name, y_test_preds, training_time,
+                                inference_time, y_prediction_file=None):
+        data_type = 'train' if self.evaluation_mode == "blocking" else 'test'
+        y_test = self.dataset_dict[data_type]['Y']
+        result_dict[model_name]['precision'] = precision_score(y_test, y_test_preds, average='binary')
+        result_dict[model_name]['recall'] = recall_score(y_test, y_test_preds, average='binary')
+        result_dict[model_name]['f1'] = f1_score(y_test, y_test_preds, average='binary')
+        result_dict[model_name]['training_time'] = training_time
+        result_dict[model_name]['inference_time'] = inference_time
+        return result_dict
+
+    def _insert_results_to_dict_contaminated(self, result_dict, model_name, y_test_preds_all,
+                                             y_test_preds_contaminated, contaminated_indices):
+        y_test_all = self.dataset_dict['test']['Y']
+        y_test_contaminated = y_test_all[contaminated_indices]
+        result_dict[model_name]['precision'] = precision_score(y_test_all, y_test_preds_all, average='binary')
+        result_dict[model_name]['recall'] = recall_score(y_test_all, y_test_preds_all, average='binary')
+        result_dict[model_name]['f1'] = f1_score(y_test_all, y_test_preds_all, average='binary')
+        result_dict[model_name]['precision_contaminated'] = precision_score(y_test_contaminated,
+                                                                            y_test_preds_contaminated,
+                                                                            average='binary')
+        result_dict[model_name]['recall_contaminated'] = recall_score(y_test_contaminated,
+                                                                      y_test_preds_contaminated,
+                                                                      average='binary')
+        result_dict[model_name]['f1_contaminated'] = f1_score(y_test_contaminated, y_test_preds_contaminated,
+                                                               average='binary')
+        return result_dict
+
+    def _insert_results_to_dict_dirty(self, result_dict, model_name, y_test_preds, y_test_preds_dirty):
+        y_test = self.dataset_dict['test']['Y']
+        y_test_dirty = self.dataset_dict['test_dirty']['Y']
+        result_dict[model_name]['precision'] = precision_score(y_test, y_test_preds, average='binary')
+        result_dict[model_name]['recall'] = recall_score(y_test, y_test_preds, average='binary')
+        result_dict[model_name]['f1'] = f1_score(y_test, y_test_preds, average='binary')
+        result_dict[model_name]['precision_dirty'] = precision_score(y_test_dirty, y_test_preds_dirty,
+                                                                    average='binary')
+        result_dict[model_name]['recall_dirty'] = recall_score(y_test_dirty, y_test_preds_dirty,
+                                                              average='binary')
+        result_dict[model_name]['f1_dirty'] = f1_score(y_test_dirty, y_test_preds_dirty, average='binary')
+        return result_dict
+
+    def _print_results(self):
+        for model_name, model_results in self.result_dict.items():
+            eval_mode_message = f" {self.evaluation_mode} mode (results over train set)" if (
+                    self.evaluation_mode == "blocking") else ""
+            self.logger.info(f"{eval_mode_message}")
+            self.logger.info(f"Results for model {model_name}:")
+            self.logger.info(f"Precision: {round(model_results['precision'], 3)}")
+            self.logger.info(f"Recall: {round(model_results['recall'], 3)}")
+            self.logger.info(f"F1 score: {round(model_results['f1'], 3)}")
+            if self.contaminated_indices_dict is not None:
+                self.print_results_contaminated(model_results)
+            self.logger.info(3*'--------------------------')
+            self.logger.info('')
+        return
+
+    def print_results_contaminated(self, model_results):
+        self.logger.info(f"Contamination level: {self.contamination_level}")
+        self.logger.info(f"Precision (contaminated): {round(model_results['precision_contaminated'], 3)}")
+        self.logger.info(f"Recall (contaminated): {round(model_results['recall_contaminated'], 3)}")
+        self.logger.info(f"F1 score (contaminated): {round(model_results['f1_contaminated'], 3)}")
+        return
+
+    def feature_importance_extraction(self):
+        """
+        Extracts the feature importance scores for the best model (used in the preparatory phase for blocking)
+        """
+        feature_importance_dict = dict()
+        self.logger.info("Feature importance scores:\n")
+        for model_name in self.best_model_dict.keys():
+            best_model = self.best_model_dict[model_name]['model']
+            feature_name_list = self.best_model_dict[model_name]['feature_name_list']
+            sorted_importance_scores = sorted(zip(feature_name_list, best_model.feature_importances_),
+                                              key=lambda x: x[1], reverse=True)
+            self._print_feature_importance_scores(sorted_importance_scores)
+            feature_importance_dict[model_name] = sorted_importance_scores
+        self._save_feature_importance_scores(feature_importance_dict)
+        self.logger.info(3 * '*******************************************')
+        self.logger.info(3 * '*******************************************')
+        return feature_importance_dict
+
+    def _save_feature_importance_scores(self, sorted_importance_scores):
+        general_file_name = ''.join((self.file_name, '_feature_importance_dict'))
+        feature_importance_file_name = f'{self.models_path}_{general_file_name}_seed={self.seed}.joblib'
+        joblib.dump(sorted_importance_scores, feature_importance_file_name)
+        self.logger.info(f"Feature importance scores were saved successfully")
+        self.logger.info('')
+        return
+
+    def _print_feature_importance_scores(self, sorted_importance_scores):
+        for feature, score in sorted_importance_scores:
+            self.logger.info(f"{feature}: {round(score, 3)}")
+        self.logger.info(3 * '==============================')
+        self.logger.info('')
+        return
+
+    def get_property_ratios(self):
+        property_ratios = dict()
+        for prop, curr_prop_dict in self.property_dict.items():
+            ratio_hist = [curr_prop_dict['index'][ind] / curr_prop_dict['cands'][ind] for ind in
+                          curr_prop_dict['index'].keys() if ind in curr_prop_dict['cands'].keys()]
+            property_ratios[prop] = {'mean': round(np.mean(ratio_hist), 3),
+                                     'std': round(np.std(ratio_hist), 3)}
+        property_ratios = dict(sorted(property_ratios.items(), key=lambda item: item[1]['std']))
+        self._save_property_ratios(property_ratios)
+        return property_ratios
+
+    def _save_property_ratios(self, property_ratios):
+        general_file_name = ''.join((self.file_name, '_property_ratios'))
+        property_ratios_file_name = f'{self.models_path}{general_file_name}_seed={self.seed}.joblib'
+        joblib.dump(property_ratios, property_ratios_file_name)
+        self.logger.info(f"Matching pairs property ratios were saved successfully")
+        self.logger.info('')
+        return

code/config.py

@@ -0,0 +1,173 @@
+
+
+class FilePaths:
+    results_path = "results/"
+    saved_models_path = "saved_model_files/"
+    object_dict_path = "data/object_dicts/"
+    dataset_dict_path = "data/dataset_dicts/"
+    property_dict_path = "data/property_dicts/"
+    dataset_partition_path = "data/dataset_partitions/"
+
+
+class Constants:
+    dataset_name = "Hague"  # "Hague", "delivery3", "bo_em", "gpkg"
+    synthetic_folder_name = "example"  # Relevant only if dataset_name is "synthetic"
+    evaluation_mode = "matching"  # "blocking", "matching"
+    dataset_size_version = 'medium'  # 'small', 'medium', 'large'
+    matching_cands_generation = 'negative_sampling'  # 'negative_sampling', 'blocking-based'
+    neg_samples_num = 2  # 2, 5
+    seeds_num = 1
+    train_ratio = 0.6
+    val_ratio = 0.2
+    test_ratio = 1 - train_ratio - val_ratio
+    max_ratio_val = 1000  # Avoid infinity values
+    load_object_dict = False  # Must be False when disaster simulation is active
+    save_object_dict = True  # Cache object dict to avoid reloading from disk
+    load_train_items = False  # Load existing preparatory items
+    save_property_dict = True  # Cache property dict to avoid recomputing
+    load_property_dict = False  # Load the properties dictionary
+    save_dataset_dict = True  # Cache dataset dict to avoid recomputing
+    load_dataset_dict = False  # load existing dataset dictionary
+    file_name_suffix = 'allmodels_v1'  # Stable suffix so model files are reusable across runs
+    max_grid_cells = 50  # None = all cells; 50 = medium run on 8GB RAM
+
+
+class TrainingPhase:
+    training_ratio = 0.5  # Number of positive samples
+    neg_pairs_ratio = 4  # Number of negative samples per positive sample
+    run_preparatory_phase = True  # If False, the preparatory phase will not be run
+
+
+class Features:
+    knn_buildings = 0  # Number of nearest buildings to consider
+    knn_roads = 0  # Number of nearest roads to consider
+    operator = 'division'  # 'division', 'concatenation'
+    object_properties = ["bounding_box_width", "bounding_box_length", "area", "perimeter", "perimeter_ind",
+                         "volume", "convex_hull_area", "convex_hull_volume", "ave_centroid_distance", "height_diff",
+                         "num_floors", "axes_symmetry", "compactness_2d", "compactness_3d", "density",
+                         "elongation", "shape_ind", "hemisphericality", "fractality", "cubeness", "circumference",
+                         "aligned_bounding_box_width", "aligned_bounding_box_length", "aligned_bounding_box_height",
+                         "num_vertices"]
+
+    # object_properties = ["circumference", "density", "convex_hull_area"]
+    normalization = 'log_transform'  # 'log_transform', None
+    neighborhood = []
+    roads = []
+
+
+class Blocking:
+    blocking_method = 'bkafi'  # 'bkafi', 'bkafi_without_SDR', 'ViT-B_32', 'ViT-L_14', 'centroid'
+                                # 'coordinates', 'coordinates_transformed'
+    cand_pairs_per_item_list = [i for i in range(1, 21)]  # total number of neighbors per each candidate object
+    nn_param = cand_pairs_per_item_list[-1] + 1  # number of nearest neighbors to retrieve as candidates
+    nbits = 10  # number of bits to use for LSH
+    # bkafi_dim_list = [dim for dim in range(1, len(Features.object_properties))] # Number of important features to
+    # use for blocking (for the bkafi method)
+    bkafi_dim_list = [dim for dim in range(1, len(Features.object_properties))]  # Number of important features to use
+    dist_threshold = None  # Define it as a hyperparameter or in a flexible manner
+    sdr_factor = False  # If True, the SDR factor will be used in the blocking method
+    bkafi_criterion = 'feature_importance'  # 'std', 'feature_importance'
+    # Neighborhood-aware negative sampling
+    neighborhood_radius = 500.0   # meters (EPSG:7415) — radius for spatial negative sampling
+    neighborhood_neg_ratio = 0.7  # fraction of negatives drawn from within-radius neighbors vs. random
+
+
+class DataPartition:
+    grid_cell_size = 500.0   # meters (EPSG:7415) — side length of each spatial grid cell
+    train_ratio = 0.6        # fraction of grid cells assigned to training
+    contiguous_test = True   # If True, test cells form a spatially contiguous region (BFS from
+                             # a corner) so the demo app covers a coherent train-only area.
+
+
+class DisasterSimulation:
+    enabled = True
+    # CRS simulation — random rotation + large translation applied globally to all cands
+    crs_simulation = True    # simulate unknown CRS (no absolute reference)
+    # Damage simulation — per-building random height reduction
+    damage_probability = 0.8    # fraction of cand buildings to damage
+    min_damage_factor = 0.3     # minimum remaining height fraction (0.3 = 70% collapsed)
+    max_damage_factor = 0.95    # maximum remaining height fraction (near-undamaged)
+
+
+class Alignment:
+    enabled = True
+    min_anchor_pairs = 3          # minimum high-confidence matches required to attempt alignment
+    confidence_threshold = 0.8    # geometric classifier score threshold for anchor selection
+    max_residual_threshold = 50.0 # meters — reject alignment if mean anchor error exceeds this
+    alpha = 0.5                   # weight: 1.0 = geometric score only, 0.0 = spatial score only
+    output_crs = "EPSG:7415"      # index dataset CRS — output aligned CityJSON in this CRS
+    use_ransac = True             # use RANSAC to find robust transform instead of plain SVD
+    ransac_iterations = 1000      # number of RANSAC trials
+    ransac_inlier_threshold = 10.0  # meters — anchor is inlier if residual < this after applying R, t
+    spatial_sigma = 3.0           # meters — Gaussian decay length for post-alignment spatial score.
+                                  # spatial(d) = exp(-d²/(2·σ²)). σ ≈ median true-match residual;
+                                  # σ=3 m gives spatial(0)=1, spatial(3)=0.61, spatial(10)≈0.004.
+    post_align_knn_cutoff = 7.0   # meters — for --post-align-blocking mode in demo/inference.py.
+                                  # After alignment succeeds, replace BKAFI pool with per-cand 1-NN
+                                  # against full index; accept iff post-alignment distance ≤ cutoff.
+
+
+class Models:
+    load_trained_models = False
+    cv = 3
+    model_to_use = 'XGBClassifier'  # Used only for predict.py and feature_importances.py
+    model_list = ['XGBClassifier', 'GradientBoostingClassifier', 'BaggingClassifier',
+                  'RandomForestClassifier', 'AdaBoostClassifier', 'MLPClassifier']
+    blocking_model = 'RandomForestClassifier'  # Used only for blocking and for advanced evaluation
+    params_dict = {
+                    'RandomForestClassifier': {"n_estimators": [50],
+                                               "max_depth": [5],
+                                               "min_samples_split": [2],
+                                               "max_features": ["sqrt"]},
+
+                    'SVC': {'C': [0.1, 0.5],
+                           'kernel': ['rbf'],
+                           'gamma': ['scale'],
+                           'degree': [2]
+                            },
+
+                    'LogisticRegression': {'solver': ['lbfgs', 'saga'],
+                                          'multi_class': ['auto'],
+                                          'C': [0.01, 0.1, 1]
+                                           },
+
+                    'MLPClassifier': {'hidden_layer_sizes': [(64, 32)],
+                                      'activation': ['relu'],
+                                      'solver': ['adam'],
+                                      'batch_size': [16],
+                                      'max_iter': [500],
+                                      'early_stopping': [True],
+                                      'n_iter_no_change': [20],
+                                      },
+
+                    'AdaBoostClassifier': {'n_estimators': [100],
+                                           'learning_rate': [0.1],
+                                           'algorithm': ['SAMME']
+                                           },
+
+                    'GradientBoostingClassifier': {'loss': ['log_loss'],
+                                                   'learning_rate': [0.1],
+                                                   'n_estimators': [100],
+                                                   'max_depth': [3],
+                                                   'min_samples_split': [3],
+                                                   'max_features': ['sqrt']
+                                                   },
+
+                    'BaggingClassifier': {'n_estimators': [50],
+                                          'max_samples': [0.8],
+                                          'max_features': [0.8],
+                                          'bootstrap': [True]
+                                          },
+
+                    'XGBClassifier': {'max_depth': [4],
+                                      'objective': ['binary:logistic'],
+                                      'learning_rate': [0.1],
+                                      'n_estimators': [100],
+                                      'gamma': [0],
+                                      'tree_method': ['hist'],
+                                      'n_jobs': [4],
+                                      }
+    }
+
+
+

code/main.py

@@ -0,0 +1,41 @@
+import config
+import argparse
+from utils import *
+from pipelines import PipelineManager
+import warnings
+
+warnings.filterwarnings("ignore")
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--dataset_name', type=str, default=config.Constants.dataset_name)
+    parser.add_argument('--evaluation_mode', type=str, default=config.Constants.evaluation_mode)
+    parser.add_argument('--run_preparatory_phase', type=bool, default=config.TrainingPhase.run_preparatory_phase)
+    parser.add_argument('--blocking_method', type=str, default=config.Blocking.blocking_method)
+    parser.add_argument('--seeds_num', type=int, default=config.Constants.seeds_num)
+    parser.add_argument('--dataset_size_version', type=str, default=config.Constants.dataset_size_version)
+    parser.add_argument('--vector_normalization', type=str2bool, default=True)
+    parser.add_argument('--sdr_factor', type=str2bool, default=False)
+    parser.add_argument('--neg_samples_num', type=int, default=config.Constants.neg_samples_num)
+    parser.add_argument('--bkafi_criterion', type=str, default=config.Blocking.bkafi_criterion)
+    parser.add_argument('--run_blocker_train', type=str2bool, default=False)
+    parser.add_argument('--matching_cands_generation', type=str,
+                        default=config.Constants.matching_cands_generation)
+    parser.add_argument('--contamination_mode', type=str2bool, default=False)
+
+    args = parser.parse_args()
+    logger = define_logger()
+    print_config(logger, args)
+    result_dict = {}
+    for seed in range(1, args.seeds_num+1):
+        logger.info(f"Seed: {seed}")
+        logger.info(3*'--------------------------')
+        pipeline_manager_obj = PipelineManager(seed, logger, args)
+        result_dict[seed] = pipeline_manager_obj.result_dict
+    if not args.run_blocker_train:
+        generate_final_result_csv(result_dict, args)
+    logger.info("Done!")
+
+

code/pipelines.py

@@ -0,0 +1,910 @@
+import copy
+import json
+import os
+import config
+from utils import *
+from blocking import Blocker
+from collections import defaultdict
+from process_pairs import PairProcessor
+from object_properties import ObjectPropertiesProcessor
+import numpy as np
+from sklearn.model_selection import train_test_split
+from classifier import FlexibleClassifier
+from abc import ABC, abstractmethod
+from multiprocessing import Pool, cpu_count
+from disaster_simulation import DisasterSimulator
+from alignment import RigidAligner
+
+
+class PipelineManager:
+    def __init__(self, seed, logger, args, min_surfaces_num=10):
+        self.dataset_name = args.dataset_name
+        self.seed = seed
+        self.logger = logger
+        self.with_prep_training = args.run_preparatory_phase
+        self.min_surfaces_num = min_surfaces_num
+        self.evaluation_mode = args.evaluation_mode
+        self.blocking_method = args.blocking_method
+        self.dataset_size_version = args.dataset_size_version
+        self.neg_samples_num = args.neg_samples_num
+        self.vector_normalization = args.vector_normalization
+        self.sdr_factor = args.sdr_factor
+        self.bkafi_criterion = args.bkafi_criterion
+        self.matching_cands_generation = args.matching_cands_generation
+        self.run_blocker_train = args.run_blocker_train
+        self._simulator = None   # set by _read_objects when disaster simulation runs
+        self.dataset_dict = self._create_dataset_dict()
+        self.flexible_classifier_obj = self._train_and_evaluate()
+        self.result_dict = self._get_result_dict()
+
+    def _read_objects(self):
+        dataset_config = json.load(open('dataset_configs.json'))[self.dataset_name]
+        train_object_dict, test_object_dict = self._load_object_dict_wrapper()
+        partition_path = (f"{config.FilePaths.dataset_partition_path}"
+                          f"{self.dataset_name}_seed{self.seed}.pkl")
+        if not os.path.exists(partition_path):
+            self.logger.info(f"Partition file missing — generating for seed {self.seed}...")
+            import argparse
+            from data_partition import DataPartitionGenerator
+            partition_args = argparse.Namespace(
+                dataset_name=self.dataset_name,
+                train_neg_samples_list=[2, 5],
+                train_size_ratio_list={"small": 0.1, "medium": 0.4, "large": 0.6},
+                test_size_ratio_list={"small": 0.1, "medium": 0.5, "large": 1.0},
+                test_negative_samples_list=[2, 5],
+            )
+            gen = DataPartitionGenerator(partition_args)
+            gen.create_dataset_partition_dict(self.seed)
+        data_partition_dict = load_dataset_partition_dict(self.dataset_name, self.logger, self.seed)
+        if test_object_dict is not None and train_object_dict is not None:
+            return data_partition_dict, train_object_dict, test_object_dict
+        self.logger.info("Generating test object dict and train object dict")
+        # Raw-object cache: produced by preprocess_hague.py (run once).
+        # If missing, fall back to reading CityJSON files directly.
+        # Each seed deepcopies before simulation so the cached version is never mutated.
+        raw_cache_path = (f"{config.FilePaths.object_dict_path}"
+                          f"{self.dataset_name}_raw.joblib")
+        if os.path.exists(raw_cache_path):
+            self.logger.info(f"Loading preprocessed cache: {raw_cache_path}")
+            raw_object_dict = joblib.load(raw_cache_path)
+            self.logger.info(
+                f"  → {len(raw_object_dict['cands'])} cands, "
+                f"{len(raw_object_dict['index'])} index buildings"
+            )
+        else:
+            self.logger.info("No preprocessed cache found — running full read (slow).")
+            raw_object_dict = getattr(self, f'_read_objects_{self.dataset_name}')(dataset_config)
+            os.makedirs(os.path.dirname(raw_cache_path), exist_ok=True)
+            joblib.dump(raw_object_dict, raw_cache_path, compress=3)
+            self.logger.info(f"Raw object_dict cached to: {raw_cache_path}")
+        # Optional: restrict to the first N shared grid cells for quick testing
+        max_cells = config.Constants.max_grid_cells
+        if max_cells is not None and 'grid_meta' in raw_object_dict:
+            raw_object_dict = self._filter_to_grid_cells(raw_object_dict, max_cells)
+        # Work on a fresh copy so the cached version is never modified by simulation
+        object_dict = copy.deepcopy(raw_object_dict)
+        # Apply disaster simulation to cands before property extraction.
+        # load_object_dict must be False when disaster mode is active (cached dicts
+        # are pre-simulation and would produce incorrect features).
+        self._simulator = DisasterSimulator(config.DisasterSimulation, seed=self.seed)
+        object_dict = self._simulator.apply(object_dict)
+        train_object_dict, test_object_dict = self._partition_object_dict(object_dict, data_partition_dict)
+        if config.Constants.save_object_dict:
+            self._save_object_dicts(train_object_dict, test_object_dict, dataset_config)
+        return data_partition_dict, train_object_dict, test_object_dict
+
+    @staticmethod
+    def _filter_to_grid_cells(raw_object_dict, max_cells):
+        """
+        Restrict both cands and index to buildings in the `max_cells` most-populated
+        grid cells that are shared between both sources.
+        Picking by population (not coordinate order) maximises pair coverage from the
+        pre-built partition dict and ensures a spatially representative quick test.
+        """
+        from collections import Counter
+        cands_cells = set(b['grid_cell'] for b in raw_object_dict['cands'].values())
+        index_cells = set(b['grid_cell'] for b in raw_object_dict['index'].values())
+        shared = cands_cells & index_cells
+        # Sort shared cells by number of cands in descending order
+        cell_pop = Counter(b['grid_cell'] for b in raw_object_dict['cands'].values())
+        shared_cells = set(sorted(shared, key=lambda c: -cell_pop[c])[:max_cells])
+
+        filtered = dict(raw_object_dict)  # shallow copy of top-level keys
+        filtered['cands'] = {k: v for k, v in raw_object_dict['cands'].items()
+                             if v['grid_cell'] in shared_cells}
+        filtered['index'] = {k: v for k, v in raw_object_dict['index'].items()
+                             if v['grid_cell'] in shared_cells}
+
+        # Rebuild mapping dicts for filtered subset
+        filtered['mapping_dict']     = {}
+        filtered['inv_mapping_dict'] = {}
+        for src in ('cands', 'index'):
+            keys = sorted(filtered[src].keys())
+            filtered['mapping_dict'][src]     = {i: k for i, k in enumerate(keys)}
+            filtered['inv_mapping_dict'][src] = {k: i for i, k in enumerate(keys)}
+
+        import logging
+        logging.getLogger(__name__).info(
+            f"[grid filter] {max_cells} shared cells → "
+            f"{len(filtered['cands'])} cands, {len(filtered['index'])} index buildings"
+        )
+        return filtered
+
+    def _load_object_dict_wrapper(self):
+        test_object_dict, train_object_dict = None, None
+        train_full_path, test_full_path = self._get_object_dict_paths()
+        if config.Constants.load_object_dict:
+            train_object_dict = load_object_dict(self.logger, train_full_path, 'train_object_dict')
+            test_object_dict = load_object_dict(self.logger, test_full_path, 'test_object_dict')
+        return train_object_dict, test_object_dict
+
+    def _save_object_dicts(self, train_object_dict, test_object_dict, dataset_config):
+        self._print_object_dict_stats(train_object_dict, test_object_dict)
+        self.logger.info(f"Saving test object dict")
+        train_full_path, test_full_path = self._get_object_dict_paths()
+        self.logger.info(f"Saving train object dict to {train_full_path}")
+        joblib.dump(train_object_dict, train_full_path)
+        self.logger.info(f"Saving test object dict to {test_full_path}")
+        joblib.dump(test_object_dict, test_full_path)
+        return
+
+    @staticmethod
+    def _print_object_dict_stats(train_object_dict, test_object_dict):
+        print(f"Number of cands in train: {len(train_object_dict['cands'])}")
+        print(f"Number of index in train: {len(train_object_dict['index'])}")
+        print(f"Number of cands in test: {len(test_object_dict['cands'])}")
+        print(f"Number of index in test: {len(test_object_dict['index'])}")
+
+    def _get_object_dict_paths(self):
+        object_dict_path = f"{config.FilePaths.object_dict_path}{self.dataset_name}/"
+        if not os.path.exists(object_dict_path):
+            os.makedirs(object_dict_path)
+        if self.evaluation_mode == 'blocking':
+            train_full_path = f"{object_dict_path}train_blocking_{self.dataset_size_version}"
+            test_full_path = f"{object_dict_path}test_blocking_{self.dataset_size_version}"
+        else:
+            train_full_path = (f"{object_dict_path}train_matching_{self.dataset_size_version}_"
+                               f"neg_samples_num={self.neg_samples_num}")
+            test_full_path = f"{object_dict_path}test_matching_{self.matching_cands_generation}" \
+                             f"_{self.dataset_size_version}_neg_samples_num={self.neg_samples_num}"
+        return f"{train_full_path}_seed_{self.seed}.joblib", f"{test_full_path}_seed_{self.seed}.joblib"
+
+    def _partition_object_dict(self, object_dict, data_partition_dict):
+        if self.evaluation_mode == "blocking":
+            return self._clean_object_dict_blocking(object_dict, data_partition_dict)
+        else:
+            return self._clean_object_dict_matching(object_dict, data_partition_dict)
+
+    def _clean_object_dict_blocking(self, object_dict, data_partition_dict):
+        dataset_version = self.dataset_size_version
+        train_object_dict = {'cands': {}, 'index': {}}
+        test_object_dict = {'cands': {}, 'index': {}}
+        avail_cands = set(object_dict['cands'].keys())
+        avail_index = set(object_dict['index'].keys())
+        train_pairs = data_partition_dict['train']['negative_sampling'][dataset_version][2]
+        train_pairs = [p for p in train_pairs if p[0] in avail_cands and p[1] in avail_index]
+        test_data_partition = data_partition_dict['test']['blocking'][dataset_version]
+        test_cands_ids = [i for i in test_data_partition['cands'] if i in avail_cands]
+        test_index_ids = [i for i in test_data_partition['index'] if i in avail_index]
+        train_object_dict['cands'] = {pair[0]: object_dict['cands'][pair[0]] for pair in train_pairs}
+        train_object_dict['index'] = {pair[1]: object_dict['index'][pair[1]] for pair in train_pairs}
+        test_object_dict['cands'] = {object_id: object_dict['cands'][object_id] for object_id in test_cands_ids}
+        test_object_dict['index'] = {object_id: object_dict['index'][object_id] for object_id in test_index_ids}
+        return train_object_dict, test_object_dict
+
+    def _clean_object_dict_matching(self, object_dict, data_partition_dict):
+        train_object_dict = {'cands': {}, 'index': {}}
+        test_object_dict = {'cands': {}, 'index': {}}
+        dataset_version = self.dataset_size_version
+        neg_num = self.neg_samples_num
+        candidates_generation = self.matching_cands_generation
+        train_pairs = data_partition_dict['train'][self.matching_cands_generation][dataset_version][neg_num]
+        test_pairs = data_partition_dict['test']['matching'][candidates_generation][dataset_version][neg_num]
+        # Filter pairs to IDs that exist in the loaded object_dict (important for
+        # quick-test runs where max_files_per_source limits coverage)
+        avail_cands = set(object_dict['cands'].keys())
+        avail_index = set(object_dict['index'].keys())
+        train_pairs = [p for p in train_pairs if p[0] in avail_cands and p[1] in avail_index]
+        test_pairs  = [p for p in test_pairs  if p[0] in avail_cands and p[1] in avail_index]
+        self.logger.info(f"Filtered to {len(train_pairs)} train pairs, {len(test_pairs)} test pairs "
+                         f"(available cands={len(avail_cands)}, index={len(avail_index)})")
+        train_object_dict['cands'] = {pair[0]: object_dict['cands'][pair[0]] for pair in train_pairs}
+        train_object_dict['index'] = {pair[1]: object_dict['index'][pair[1]] for pair in train_pairs}
+        test_object_dict['cands'] = {pair[0]: object_dict['cands'][pair[0]] for pair in test_pairs}
+        test_object_dict['index'] = {pair[1]: object_dict['index'][pair[1]] for pair in test_pairs}
+        return train_object_dict, test_object_dict
+
+    @staticmethod
+    def _remove_train_objects_from_object_dict(object_dict, train_ids):
+        for objects_type in object_dict.keys():
+            object_dict[objects_type] = {
+                object_id: object_data
+                for object_id, object_data in object_dict[objects_type].items()
+                if object_id not in train_ids
+            }
+        return object_dict
+
+    @staticmethod
+    def _compute_object_centroid(vertices):
+        unique_vertices = np.array(vertices)
+        return unique_vertices.mean(axis=0)
+
+    @staticmethod
+    def _get_vertices(polygon_mesh):
+        return np.unique(np.array([coord for surface in polygon_mesh for coord in surface]), axis=0)
+
+    @staticmethod
+    def _get_polygon_mesh(data, obj_key, vertices, min_surfaces_num):
+        boundaries = data['CityObjects'][obj_key]['geometry'][0]['boundaries'][0]
+        if len(boundaries) < min_surfaces_num:
+            return None
+        polygon_mesh = []
+        for surface in boundaries:
+            polygon_mesh.append([vertices[i] for sub_surface_list in surface for i in sub_surface_list])
+        vertices = PipelineManager._get_vertices(polygon_mesh)
+        centroid = PipelineManager._compute_object_centroid(vertices)
+        return {'polygon_mesh': polygon_mesh, 'vertices': vertices, 'centroid': centroid}
+
+    def _insert_polygon_mesh(self, object_dict, obj_type, obj_data, obj_ind, min_surfaces_num=10):
+        vertices = obj_data['vertices']
+        obj_key = list(obj_data['CityObjects'].keys())[0]
+        polygon_mesh = self._get_polygon_mesh(obj_data, obj_key, vertices, min_surfaces_num)
+        if polygon_mesh is not None:
+            object_dict[obj_type][obj_ind] = polygon_mesh
+        return object_dict
+
+    def _read_objects_bo_em(self, dataset_config):
+        objects_path_dict = read_object_path_dict(dataset_config)
+        object_dict = defaultdict(dict)
+        for objects_type, objects_path in objects_path_dict.items():
+            file_list = [f for f in os.listdir(objects_path) if f.endswith('.json')]
+            for filename in file_list:
+                file_ind = int(filename.split('.')[0])
+                json_data = read_json(objects_path, file_ind)
+                object_dict = self._insert_polygon_mesh(object_dict, objects_type, json_data, file_ind)
+            object_dict[objects_type] = dict(sorted(object_dict[objects_type].items()))
+        return object_dict
+
+    def _read_objects_gpkg(self, dataset_config):
+        objects_path_dict = read_object_path_dict(dataset_config)
+        object_dict = defaultdict(dict)
+        for objects_type, objects_path in objects_path_dict.items():
+            file_list = [f for f in os.listdir(objects_path) if f.endswith('.json')]
+            for filename in file_list:
+                file_ind = int(filename.split('.')[0])
+                json_data = read_json(objects_path, file_ind)
+                json_data = json.loads(json_data)
+                object_dict = self._insert_polygon_mesh(object_dict, objects_type, json_data, file_ind)
+            object_dict[objects_type] = dict(sorted(object_dict[objects_type].items()))
+        return object_dict
+
+    def _read_objects_delivery3(self, dataset_config):
+        objects_path_dict = read_object_path_dict(dataset_config)
+        object_dict = defaultdict(dict)
+        mapping_dict = defaultdict(dict)
+        inv_mapping_dict = defaultdict(dict)
+        for objects_type, objects_path in objects_path_dict.items():
+            file_list = [f for f in os.listdir(objects_path) if f.endswith('.json')]
+            for file_ind, file_name in enumerate(file_list):
+                file_name = file_name.split('.')[0]
+                json_data = read_json(objects_path, file_name)
+                object_dict = self._insert_polygon_mesh(object_dict, objects_type, json_data, file_ind)
+                mapping_dict[objects_type][file_ind] = file_name
+                inv_mapping_dict[objects_type][file_name] = file_ind
+            object_dict[objects_type] = dict(sorted(object_dict[objects_type].items()))
+        object_dict['mapping_dict'] = mapping_dict
+        object_dict['inv_mapping_dict'] = inv_mapping_dict
+        return object_dict
+
+    def _read_objects_Hague(self, dataset_config):
+        """
+        Fallback reader used only when preprocess_hague.py has not been run.
+        Prefer running `python preprocess_hague.py` once to create the cache.
+        """
+        from preprocess_hague import preprocess
+        raw_cache_path = f"{config.FilePaths.object_dict_path}{self.dataset_name}_raw.joblib"
+        self.logger.info("Running preprocess_hague.preprocess() to build cache...")
+        return preprocess(
+            cands_path=dataset_config['cands_path'],
+            index_path=dataset_config['index_path'],
+            output_path=raw_cache_path,
+            cell_size=config.DataPartition.grid_cell_size,
+            min_surfaces=self.min_surfaces_num,
+        )
+
+    def _generate_object_dict_mappings(self, object_dict, objects_path_dict):
+        object_dict['mapping_dict'], object_dict['inv_mapping_dict'] = {}, {}
+        for object_type in objects_path_dict:
+            keys = list(object_dict[object_type].keys())
+            object_dict['mapping_dict'][object_type] = {i: k for i, k in enumerate(keys)}
+            object_dict['inv_mapping_dict'][object_type] = {k: i for i, k in enumerate(keys)}
+        return object_dict
+
+    @staticmethod
+    def _process_object_file(file_ind, file_path, object_type, min_surfaces_num):
+        print(f"Processing file {file_ind}")
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        vertices = data['vertices']
+        partial_dict = {}
+        for obj_key in data['CityObjects'].keys():
+            try:
+                new_obj_key = PipelineManager.standardize_obj_key(obj_key, object_type)
+                polygon_mesh_data = PipelineManager._get_polygon_mesh(data, obj_key, vertices,
+                                                                      min_surfaces_num=min_surfaces_num)
+                if polygon_mesh_data is not None:
+                    partial_dict[new_obj_key] = polygon_mesh_data
+            except:
+                continue
+        return partial_dict
+
+    @staticmethod
+    def standardize_obj_key(obj_key, object_type):
+        if object_type == 'cands':
+            return obj_key.split('bag_')[1]
+        elif object_type == 'index':
+            return obj_key.split('NL.IMBAG.Pand.')[1].split('-0')[0]
+        else:
+            raise ValueError('Invalid source')
+
+    @staticmethod
+    def read_objects_synthetic(self, dataset_config):
+        pass
+
+    # def _generate_training_pairs(self):
+    #     np.random.seed(self.seed)
+    #     index_ids = list(self.train_object_dict['index'].keys())
+    #     pos_pairs = [(obj_id, obj_id) for obj_id in self.train_object_dict['cands'].keys()]
+    #     neg_pairs = [(obj_id, np.random.choice(index_ids)) for obj_id in self.train_object_dict['cands'].keys()]
+    #     neg_pairs = [(cand_id, index_id) for cand_id, index_id in neg_pairs if cand_id != index_id]
+    #     return pos_pairs, neg_pairs
+
+    # def _run_blocker(self):
+    #     self.logger.info(f"Running blocking for training phase")
+    #     dummy_feature_importance_scores = self._get_dummy_feature_importance_scores()
+    #     dummy_property_ratios = self._get_dummy_property_ratios()
+    #     blocker = Blocker(self.dataset_name, self.train_object_dict, self.train_property_dict,
+    #                       dummy_feature_importance_scores, dummy_property_ratios, 'bkafi', 'train')
+    #     self.logger.info(f"The blocking process for the training phase ended successfully")
+    #     self.train_pos_pairs_dict, self.train_neg_pairs_dict = blocker.pos_pairs_dict, blocker.neg_pairs_dict
+    #     save_blocking_output(self.train_pos_pairs_dict, self.train_neg_pairs_dict, self.seed, self.logger, 'train')
+    #     return
+
+    @staticmethod
+    def _get_dummy_feature_importance_scores():
+        feature_names = get_feature_name_list(config.Features.operator)
+        dummy_model_name = config.Models.blocking_model
+        return {dummy_model_name: [(feature, 1) for feature in feature_names]}
+
+    def _get_dummy_property_ratios(self):
+        property_ratios = {prop: {'mean': 1.0, 'std': 0.0}
+                           for prop in self.train_property_dict.keys()}
+        return property_ratios
+
+    def _run_blocker(self, feature_importance_dict, train_property_ratios):
+        blocking_method = self.blocking_method
+        self.logger.info(f"Running blocking method {blocking_method}")
+        blocker = Blocker(self.dataset_name, self.test_object_dict, self.test_property_dict, feature_importance_dict,
+                          train_property_ratios,  self.blocking_method, self.sdr_factor, self.bkafi_criterion, 'test')
+        self.logger.info(f"The blocking process ended successfully")
+        self._save_blocking_output(blocker.pos_pairs_dict, blocker.neg_pairs_dict, blocker.blocking_execution_time)
+        self.blocking_result_dict = self._evaluate_blocking(blocker.pos_pairs_dict, blocker.blocking_execution_time)
+        return
+
+    def _run_blocker_train(self, feature_importance_dict, train_property_ratios):
+        blocking_method = self.blocking_method
+        self.logger.info(f"Running blocking method {blocking_method} for train set")
+        blocker = Blocker(self.dataset_name, self.train_object_dict, self.train_property_dict, feature_importance_dict,
+                          train_property_ratios,  self.blocking_method, self.sdr_factor, self.bkafi_criterion, 'test')
+        self.logger.info(f"The blocking process for train set ended successfully")
+        pos_pairs_dict, neg_pairs_dict, execution_time = (blocker.pos_pairs_dict, blocker.neg_pairs_dict,
+                                                          blocker.blocking_execution_time)
+        self._save_blocking_output(pos_pairs_dict, neg_pairs_dict, execution_time, train_set_mode=True)
+        return
+
+    def _save_blocking_output(self, pos_pairs, neg_pairs, blocking_execution_time, train_set_mode=False):
+        blocking_dict = {'pos_pairs': pos_pairs, 'neg_pairs': neg_pairs,
+                         'blocking_execution_time': blocking_execution_time}
+        blocking_output_path = self._get_blocking_output_path()
+        if train_set_mode:
+            blocking_output_path = blocking_output_path.replace('Operator', 'Train_Operator')
+        try:
+            joblib.dump(blocking_dict, blocking_output_path)
+            message = f"Blocking results were saved successfully to {blocking_output_path}"
+            self.logger.info(message)
+        except Exception as e:
+            self.logger.error(f"Error happened while saving blocking results: {e}")
+        return
+
+    def _get_blocking_output_path(self):
+        file_name = get_file_name()
+        blocking_results_path = config.FilePaths.results_path + 'blocking_output/'
+        vector_normalization = 'True' if self.vector_normalization else 'False'
+        sdr_factor = 'True' if self.sdr_factor else 'False'
+        if not os.path.exists(blocking_results_path):
+            os.makedirs(blocking_results_path)
+        blocking_results_path = (f"{blocking_results_path}{file_name}_"
+                                 f"{self.dataset_size_version}_neg_samples_num{self.neg_samples_num}"
+                                 f"_vector_normalization_{vector_normalization}_sdr_factor_{sdr_factor}_"
+                                 f"bkafi_criterion={self.bkafi_criterion}_seed={self.seed}.joblib")
+        return blocking_results_path
+
+
+    # def _get_property_dict_path(self, train_or_test):
+    #     file_name = get_file_name_property_dict()
+    #     property_dict_path = config.FilePaths.property_dict_path
+    #     vector_normalization = self.vector_normalization if self.vector_normalization is not None else 'None'
+    #     if not os.path.exists(property_dict_path):
+    #         os.makedirs(property_dict_path)
+    #     property_dict_path = (f"{property_dict_path}{file_name}_{train_or_test}_{self.evaluation_mode}_"
+    #                           f"{self.dataset_size_version}_neg_samples_num={self.neg_samples_num}_"
+    #                           f"vector_normalization={vector_normalization}_seed={self.seed}.joblib")
+    #     return property_dict_path
+
+    # def _save_blocking_evaluation(self, blocking_evaluation_dict, blocking_method_arg=None):
+    #     file_name = get_file_name(blocking_method_arg)
+    #     blocking_results_path = config.FilePaths.results_path
+    #     vector_normalization = config.Features.normalization
+    #     vector_normalization_str = vector_normalization if vector_normalization is not None else "None"
+    #     sdr_factor = config.Blocking.sdr_factor
+    #     sdr_factor_str = "True" if sdr_factor else "False"
+    #     bkafi_criterion = config.Blocking.bkafi_criterion
+    #     if not os.path.exists(blocking_results_path):
+    #         os.makedirs(blocking_results_path)
+    #     try:
+    #         blocking_results_path = (f"{blocking_results_path}blocking_evaluation_results_{file_name}_"
+    #                                  f"{self.dataset_size_version}_neg_samples_num{self.neg_samples_num}_"
+    #                                  f"vector_normalization={vector_normalization_str}_sdr_factor_{sdr_factor_str}_"
+    #                                  f"bkafi_criterion={bkafi_criterion}_seed={self.seed}.joblib")
+    #         joblib.dump(blocking_evaluation_dict, blocking_results_path)
+    #         self.logger.info(f"Blocking evaluation results were saved successfully")
+    #     except Exception as e:
+    #         self.logger.error(f"Error happened while saving blocking evaluation results: {e}")
+
+    def _evaluate_blocking(self, pos_pairs_dict, blocking_execution_time):
+        index_ids = set(self.test_object_dict['index'].keys())
+        cand_ids = set(self.test_object_dict['cands'].keys())
+        max_intersection = index_ids.intersection(cand_ids)
+        if 'bkafi' in self.blocking_method:
+            blocking_res_dict = self._evaluate_bkafi_blocking(max_intersection, pos_pairs_dict, blocking_execution_time)
+        else:
+            blocking_res_dict = self._evaluate_not_bkafi_blocking(max_intersection, pos_pairs_dict,
+                                                                  blocking_execution_time)
+        # self._save_blocking_evaluation(blocking_res_dict)
+        return blocking_res_dict
+
+    def _evaluate_bkafi_blocking(self, max_intersection, pos_pairs_dict, blocking_execution_time):
+        blocking_res_dict = defaultdict(dict)
+        for bkafi_dim in pos_pairs_dict.keys():
+            for cand_pairs_per_item in pos_pairs_dict[bkafi_dim].keys():
+                pos_pairs = set(pos_pairs_dict[bkafi_dim][cand_pairs_per_item])
+                blocking_recall = round(len(pos_pairs) / len(max_intersection), 3)
+                blocking_res_dict[bkafi_dim][cand_pairs_per_item] = {'blocking_recall': blocking_recall,
+                                                                     'blocking_execution_time':
+                                                                         blocking_execution_time[bkafi_dim]}
+                if cand_pairs_per_item == 10:
+                    self.logger.info(f"Blocking recall for {self.blocking_method}_dim {bkafi_dim} and "
+                                     f"cand_pairs_per_item {cand_pairs_per_item}: {blocking_recall}")
+                    self.logger.info(3*'- - - - - - - - - - - - -')
+        return blocking_res_dict
+
+    def _evaluate_not_bkafi_blocking(self, max_intersection, pos_pairs_dict, blocking_execution_time):
+        blocking_res_dict = defaultdict(dict)
+        for cand_pairs_per_item in pos_pairs_dict.keys():
+            pos_pairs = set(pos_pairs_dict[cand_pairs_per_item])
+            blocking_recall = round(len(pos_pairs) / len(max_intersection), 3)
+            blocking_res_dict[cand_pairs_per_item] = {'blocking_recall': blocking_recall,
+                                                      'blocking_execution_time': blocking_execution_time}
+            # self.logger.info(f"Blocking recall for {self.blocking_method}, cand_pairs_per_item "
+            #                  f"{cand_pairs_per_item}: {blocking_recall}")
+            # self.logger.info(3*'--------------------------')
+        return blocking_res_dict
+
+    def _create_dataset_dict(self):
+        dataset_dict = self._load_dataset_dict_wrapper()
+        if dataset_dict is not None:
+            return dataset_dict
+        data_partition_dict, self.train_object_dict, self.test_object_dict = self._read_objects()
+        self.train_pos_pairs, self.train_neg_pairs = self._extract_pairs(data_partition_dict, 'train')
+        self.train_property_dict = self._generate_property_dict('train')
+        if self.evaluation_mode == "matching":
+            self.test_pos_pairs, self.test_neg_pairs = self._extract_pairs(data_partition_dict, 'test')
+        self.test_property_dict = self._generate_property_dict('test')
+        feature_dict = self._generate_feature_dict()
+        dataset_dict = self._create_final_dict(feature_dict)
+        return dataset_dict
+
+    def _extract_pairs(self, data_partition_dict, train_or_test):
+        if self.evaluation_mode == "blocking":
+            pair_list = data_partition_dict[train_or_test]['negative_sampling'][self.dataset_size_version] \
+                [self.neg_samples_num]
+        else:
+            if train_or_test == 'train':
+                pair_list = data_partition_dict[train_or_test][self.matching_cands_generation] \
+                    [self.dataset_size_version][self.neg_samples_num]
+            else:
+                pair_list = data_partition_dict[train_or_test]['matching'][self.matching_cands_generation] \
+                    [self.dataset_size_version][self.neg_samples_num]
+        # Same filter as _clean_object_dict_matching: drop pairs whose IDs aren't in the
+        # loaded object dict, so PairProcessor never sees IDs missing from property_dict.
+        object_dict = self.train_object_dict if train_or_test == 'train' else self.test_object_dict
+        avail_cands = set(object_dict['cands'].keys())
+        avail_index = set(object_dict['index'].keys())
+        before = len(pair_list)
+        pair_list = [p for p in pair_list if p[0] in avail_cands and p[1] in avail_index]
+        dropped = before - len(pair_list)
+        if dropped:
+            self.logger.info(f"_extract_pairs[{train_or_test}]: dropped {dropped}/{before} pairs "
+                             f"with IDs not in object_dict (kept {len(pair_list)})")
+        pos_pairs = [pair for pair in pair_list if pair[0] == pair[1]]
+        neg_pairs = [pair for pair in pair_list if pair[0] != pair[1]]
+        return pos_pairs, neg_pairs
+
+    def _load_dataset_dict_wrapper(self):
+        dataset_dict = None
+        if config.Constants.load_dataset_dict:
+            dataset_dict = self._load_dataset_dict()
+            if dataset_dict is not None:
+                return dataset_dict
+        return dataset_dict
+
+    # def _get_pos_and_neg_pairs_for_training(self):
+    #     bkafi_dim = min(self.train_pos_pairs_dict.keys())
+    #     cand_pairs_per_item = min(self.test_pos_pairs_dict[bkafi_dim].keys())
+    #     pos_pairs = self.train_pos_pairs_dict[bkafi_dim][cand_pairs_per_item]
+    #     neg_pairs = self.train_neg_pairs_dict[bkafi_dim][cand_pairs_per_item]
+    #     return pos_pairs, neg_pairs
+
+    # def _get_pos_and_neg_pairs(self, train_or_test):
+    #     pos_pairs_dict = self.test_pos_pairs_dict if train_or_test == 'test' else self.train_pos_pairs_dict
+    #     neg_pairs_dict = self.test_neg_pairs_dict if train_or_test == 'test' else self.train_neg_pairs_dict
+    #     bkafi_dim = min(pos_pairs_dict.keys())
+    #     cand_pairs_per_item = min(pos_pairs_dict[bkafi_dim].keys())
+    #     pos_pairs = pos_pairs_dict[bkafi_dim][cand_pairs_per_item]
+    #     neg_pairs = neg_pairs_dict[bkafi_dim][cand_pairs_per_item]
+    #     return pos_pairs, neg_pairs
+
+    def _load_train_items(self):
+        feature_importance_dict, matching_pairs_property_ratios = None, None
+        try:
+            feature_importance_dict = load_feature_importance_dict(self.seed, self.logger)
+            matching_pairs_property_ratios = load_property_ratios(self.seed, self.logger)
+        except:
+            self.logger.info("Could not load training phase items. Running training phase pipeline")
+        return feature_importance_dict, matching_pairs_property_ratios
+
+    def _generate_property_dict(self, train_or_test):
+        rel_object_dict = self.train_object_dict if train_or_test == 'train' else self.test_object_dict
+        if config.Constants.load_property_dict:
+            property_dict = self._load_property_dict(train_or_test)
+            if property_dict is not None:
+                return property_dict
+        self.logger.info(f"Generating {train_or_test} property dictionary")
+        obj_property_processor = ObjectPropertiesProcessor(rel_object_dict, self.vector_normalization)
+        property_dict = obj_property_processor.prop_vals_dict
+        property_dict_generation_time = obj_property_processor.property_dict_generation_time
+        self.logger.info(f"Property dictionary generation time: {property_dict_generation_time}\n")
+        if config.Constants.save_property_dict:
+            self._save_property_dict(property_dict, train_or_test)
+        return property_dict
+
+    def _save_property_dict(self, property_dict, train_or_test):
+        try:
+            property_dict_path = self._get_property_dict_path(train_or_test)
+            joblib.dump(property_dict, property_dict_path)
+            self.logger.info(f"{train_or_test}_property_dict was saved successfully")
+            self.logger.info('')
+        except Exception as e:
+            self.logger.error(f"Error happened while saving {train_or_test}_property_dict: {e}")
+        return
+
+    def _load_property_dict(self, train_or_test):
+        property_dict_path = self._get_property_dict_path(train_or_test)
+        try:
+            property_dict = joblib.load(property_dict_path)
+            self.logger.info(f"{train_or_test}_property_dict was loaded successfully")
+            return property_dict
+        except Exception as e:
+            self.logger.error(f"Error happened while loading {train_or_test}_property_dict: {e}")
+            return None
+
+    def _get_property_dict_path(self, train_or_test):
+        file_name = get_file_name_property_dict()
+        property_dict_path = config.FilePaths.property_dict_path
+        vector_normalization = 'True' if self.vector_normalization else 'False'
+        if not os.path.exists(property_dict_path):
+            os.makedirs(property_dict_path)
+        property_dict_path = (f"{property_dict_path}{file_name}_{train_or_test}_{self.evaluation_mode}_"
+                              f"{self.dataset_size_version}_neg_samples_num={self.neg_samples_num}_"
+                              f"vector_normalization={vector_normalization}_seed={self.seed}.joblib")
+        return property_dict_path
+
+    def _generate_feature_dict(self):
+        feature_dict = {'train': {}, 'test': {}} if self.evaluation_mode == 'matching' else {'train': {}}
+        for train_or_test in feature_dict.keys():
+            pos_pairs, neg_pairs, property_dict = self._get_rel_pairs_and_property_dict(train_or_test)
+            self.logger.info(f"Generating {train_or_test} feature vectors")
+            for label, pairs_list in zip([0, 1], [neg_pairs, pos_pairs]):
+                feature_dict[train_or_test][label] = PairProcessor(property_dict, pairs_list).feature_vec
+        return feature_dict
+
+    def _get_rel_pairs_and_property_dict(self, train_or_test):
+        if train_or_test == 'train':
+            pos_pairs, neg_pairs = self.train_pos_pairs, self.train_neg_pairs
+            property_dict = self.train_property_dict
+        else:
+            pos_pairs, neg_pairs = self.test_pos_pairs, self.test_neg_pairs
+            property_dict = self.test_property_dict
+        return pos_pairs, neg_pairs, property_dict
+
+    def _create_final_dict(self, feature_dict):
+        np.random.seed(self.seed)
+        dataset_dict = {'train': {}, 'test': {}} if self.evaluation_mode == 'matching' else {'train': {}}
+        for train_or_test in dataset_dict.keys():
+            merged_features, merged_labels = self._merge_features_and_labels(feature_dict, train_or_test)
+            if train_or_test == 'test' and self.evaluation_mode == 'matching':
+                # Store pair IDs alongside X/Y so alignment can map scores to building IDs
+                merged_pairs = self.test_neg_pairs + self.test_pos_pairs
+                dataset_dict = self._prepare_dataset(dataset_dict, train_or_test,
+                                                     merged_features, merged_labels,
+                                                     merged_pairs=merged_pairs)
+            else:
+                dataset_dict = self._prepare_dataset(dataset_dict, train_or_test,
+                                                     merged_features, merged_labels)
+        if config.Constants.save_dataset_dict:
+            self._save_dataset_dict(dataset_dict)
+        return dataset_dict
+
+    def _save_dataset_dict(self, dataset_dict):
+        dataset_dict_path = self._get_dataset_dict_path()
+        saving_message = f"dataset_dict was saved successfully"
+        error_message = f"Error happened while saving dataset_dict: "
+        try:
+            joblib.dump(dataset_dict, dataset_dict_path)
+            self.logger.info(saving_message)
+            self.logger.info('')
+        except Exception as e:
+            self.logger.error(f"{error_message}{e}")
+        return
+
+    def _load_dataset_dict(self):
+        dataset_dict_path = self._get_dataset_dict_path()
+        try:
+            dataset_dict = joblib.load(dataset_dict_path)
+            self.logger.info(f"dataset_dict was loaded successfully")
+            return dataset_dict
+        except Exception as e:
+            self.logger.error(f"Error happened while loading dataset_dict: {e}")
+            return None
+
+    def _get_dataset_dict_path(self):
+        dataset_dict_dir = config.FilePaths.dataset_dict_path
+        file_name = get_file_name()
+        if not os.path.exists(dataset_dict_dir):
+            os.makedirs(dataset_dict_dir)
+        dataset_dict_path = (f"{dataset_dict_dir}{file_name}_{self.evaluation_mode}_{self.dataset_size_version}_"
+                             f"neg_samples={self.neg_samples_num}_seed={self.seed}.joblib")
+        return dataset_dict_path
+
+    def _merge_features_and_labels(self, feature_dict, train_or_test):
+        neg_feature_vecs, pos_feature_vecs = feature_dict[train_or_test][0], feature_dict[train_or_test][1]
+        merged_features = neg_feature_vecs + pos_feature_vecs
+        merged_labels = [0] * len(neg_feature_vecs) + [1] * len(pos_feature_vecs)
+        return merged_features, merged_labels
+
+    @staticmethod
+    def _prepare_dataset(dataset_dict, file_type, merged_features, merged_labels,
+                         merged_pairs=None):
+        """
+        Shuffle features/labels (and optionally pair IDs) together and store in dataset_dict.
+
+        merged_pairs : list of (cand_id, index_id), parallel to merged_features.
+            When provided, dataset_dict[file_type]['pairs'] is stored in the same
+            shuffled order as X/Y — required for mapping classifier scores back to
+            building IDs in the alignment step.
+        """
+        if merged_pairs is not None:
+            combined = list(zip(merged_features, merged_labels, merged_pairs))
+            np.random.shuffle(combined)
+            dataset_dict[file_type]['X'] = np.array([e[0] for e in combined])
+            dataset_dict[file_type]['Y'] = np.array([e[1] for e in combined])
+            dataset_dict[file_type]['pairs'] = [e[2] for e in combined]
+        else:
+            combined = list(zip(merged_features, merged_labels))
+            np.random.shuffle(combined)
+            dataset_dict[file_type]['X'] = np.array([e[0] for e in combined])
+            dataset_dict[file_type]['Y'] = np.array([e[1] for e in combined])
+        return dataset_dict
+
+    def _train_and_evaluate(self, ):
+        if self.evaluation_mode == 'blocking':
+            feature_importance_dict, train_property_ratios = self._train_for_blocking()
+            if self.run_blocker_train:
+                self._run_blocker_train(feature_importance_dict, train_property_ratios)
+            else:
+                self._run_blocker(feature_importance_dict, train_property_ratios)
+            flexible_classifier = None
+        else:
+            flexible_classifier = self._run_matching_pipeline()
+            self._run_alignment(flexible_classifier)
+        return flexible_classifier
+
+    def _run_alignment(self, flexible_classifier_obj):
+        """
+        Stage 4: Estimate rigid 3D transform from high-confidence matches and
+        re-score all test pairs combining geometric + spatial proximity.
+
+        Requires:
+          - evaluation_mode == 'matching'
+          - dataset_dict['test']['pairs'] populated by _create_final_dict
+          - config.Alignment.enabled == True
+        """
+        if not config.Alignment.enabled:
+            return
+        if flexible_classifier_obj is None:
+            return
+        test_split = self.dataset_dict.get('test', {})
+        if 'pairs' not in test_split:
+            self.logger.warning("[_run_alignment] No pair IDs in dataset_dict['test']. "
+                                "Ensure load_dataset_dict=False so pairs are freshly built.")
+            return
+
+        # Pick the primary model for scoring
+        model_name = config.Models.model_to_use
+        if model_name not in flexible_classifier_obj.best_model_dict:
+            model_name = next(iter(flexible_classifier_obj.best_model_dict))
+        best_model = flexible_classifier_obj.best_model_dict[model_name]['model']
+
+        X_test = test_split['X']
+        pairs  = test_split['pairs']   # list of (cand_id, index_id), same shuffle order as X
+
+        # Geometric scores: P(match=1)
+        proba = best_model.predict_proba(X_test)
+        match_class_idx = list(best_model.classes_).index(1)
+        geo_scores = proba[:, match_class_idx]
+
+        scored_pairs = [(cid, iid, float(s)) for (cid, iid), s in zip(pairs, geo_scores)]
+
+        self.logger.info(
+            f"[_run_alignment] {len(scored_pairs)} test pairs | "
+            f"model={model_name} | "
+            f"anchors with score>={config.Alignment.confidence_threshold}: "
+            f"{sum(1 for _,_,s in scored_pairs if s >= config.Alignment.confidence_threshold)}"
+        )
+
+        aligner = RigidAligner(config.Alignment, logger=self.logger)
+        ground_truth_R = getattr(self._simulator, 'R_crs', None)
+        ground_truth_t = getattr(self._simulator, 't_crs', None)
+
+        rescored_pairs = aligner.run(
+            self.test_object_dict,
+            scored_pairs,
+            suffix=f"seed{self.seed}",
+            ground_truth_R=ground_truth_R,
+            ground_truth_t=ground_truth_t,
+        )
+
+        # Log final score improvement summary
+        if aligner.alignment_succeeded:
+            top_geo    = sorted(scored_pairs,   key=lambda x: x[2], reverse=True)[:10]
+            top_final  = sorted(rescored_pairs, key=lambda x: x[2], reverse=True)[:10]
+            self.logger.info(
+                f"[_run_alignment] Top-10 mean geometric score: "
+                f"{np.mean([s for _,_,s in top_geo]):.3f} → "
+                f"final score: {np.mean([s for _,_,s in top_final]):.3f}"
+            )
+
+        # Precision / Recall / F1 before and after alignment
+        self._log_alignment_metrics(scored_pairs, rescored_pairs, self.test_object_dict)
+
+    def _log_alignment_metrics(self, scored_pairs, rescored_pairs, test_object_dict,
+                               score_threshold=0.5, dist_thresholds=(10.0, 25.0, 50.0)):
+        """
+        Log two sets of metrics:
+
+        1. Score-based (before alignment only) — classifier Precision/Recall/F1
+           at score_threshold.  Measures how well the geometric features identify matches.
+
+        2. Distance-based (after alignment) — for each matched candidate, check whether
+           its aligned centroid is within dist_threshold meters of its true match centroid.
+           This is the correct evaluation after alignment: if the transform is good,
+           every candidate should be physically co-located with its match.
+
+        Note: candidates with no true match in the index are never counted as false
+        negatives — recall is only over the intersection (buildings with a real match).
+        """
+        # --- 1. Score-based metrics (before alignment) ---
+        def _prf(pairs):
+            tp = sum(1 for cid, iid, s in pairs if s >= score_threshold and cid == iid)
+            fp = sum(1 for cid, iid, s in pairs if s >= score_threshold and cid != iid)
+            fn = sum(1 for cid, iid, s in pairs if s <  score_threshold and cid == iid)
+            precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+            recall    = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+            f1        = (2 * precision * recall / (precision + recall)
+                         if (precision + recall) > 0 else 0.0)
+            return round(precision, 3), round(recall, 3), round(f1, 3)
+
+        pre_p, pre_r, pre_f1 = _prf(scored_pairs)
+        self.logger.info(
+            f"[Metrics] Before alignment (score≥{score_threshold}) — "
+            f"Precision: {pre_p}  Recall: {pre_r}  F1: {pre_f1}"
+        )
+
+        # --- 2. Distance-based metrics (after alignment) ---
+        # After alignment, test_object_dict['cands'] centroids are already transformed.
+        # True matches are pairs where cand_id == index_id.
+        cands  = test_object_dict.get('cands', {})
+        index  = test_object_dict.get('index', {})
+        # All matched cands (ground truth positives in the test set)
+        matched_cands = {cid for cid, iid, _ in scored_pairs if cid == iid and cid in cands and iid in index}
+        n_matched = len(matched_cands)
+
+        if n_matched == 0:
+            self.logger.warning("[Metrics] No matched pairs found for distance evaluation.")
+            return
+
+        # Compute distance from each aligned cand centroid to its true match index centroid
+        distances = []
+        for cid in matched_cands:
+            c_centroid = np.asarray(cands[cid]['centroid'], dtype=np.float64)
+            i_centroid = np.asarray(index[cid]['centroid'], dtype=np.float64)
+            distances.append(np.linalg.norm(c_centroid - i_centroid))
+
+        distances = np.array(distances)
+        self.logger.info(
+            f"[Metrics] After alignment (distance-based, n={n_matched} matched buildings) — "
+            f"mean dist: {distances.mean():.1f} m  |  "
+            f"median dist: {np.median(distances):.1f} m  |  "
+            f"max dist: {distances.max():.1f} m"
+        )
+        for d_thresh in dist_thresholds:
+            recall_d = round((distances < d_thresh).sum() / n_matched, 3)
+            self.logger.info(
+                f"[Metrics] After alignment  distance recall@{d_thresh:.0f}m: {recall_d} "
+                f"({(distances < d_thresh).sum()}/{n_matched} buildings within {d_thresh:.0f} m of true match)"
+            )
+
+    def _train_for_blocking(self):
+        self.logger.info("Training for blocking")
+        if config.Constants.load_train_items:
+            feature_importance_dict, matching_pairs_property_ratios = self._load_train_items()
+            if feature_importance_dict is not None and matching_pairs_property_ratios is not None:
+                return feature_importance_dict, matching_pairs_property_ratios
+        params_dict = self._read_config_models()
+        load_trained_models = config.Models.load_trained_models
+        cv = config.Models.cv
+        flexible_classifier_obj = FlexibleClassifier(self.dataset_dict, self.train_property_dict, params_dict,
+                                                     self.seed, self.logger, self.dataset_name, 'blocking',
+                                                     self.dataset_size_version, self.neg_samples_num,
+                                                     load_trained_models, cv)
+        feature_importance_dict = flexible_classifier_obj.feature_importance_extraction()
+        train_property_ratios = flexible_classifier_obj.get_property_ratios()
+        return feature_importance_dict, train_property_ratios
+
+    def _run_matching_pipeline(self):
+        self.logger.info("Training for matching")
+        params_dict = self._read_config_models()
+        load_trained_models = config.Models.load_trained_models
+        cv = config.Models.cv
+        flexible_classifier_obj = FlexibleClassifier(self.dataset_dict, None, params_dict, self.seed, self.logger,
+                                                     self.dataset_name, 'matching', self.dataset_size_version,
+                                                     self.neg_samples_num, load_trained_models, cv)
+        return flexible_classifier_obj
+
+
+    def _read_config_models(self):
+        model_list = config.Models.model_list if self.evaluation_mode == 'matching' else [config.Models.blocking_model]
+        params_dict = dict()
+        for model in model_list:
+            params_dict[model] = config.Models.params_dict[model]
+        return params_dict
+
+    def _get_result_dict(self):
+        if self.evaluation_mode == 'blocking':
+            if self.run_blocker_train:
+                return None
+            return {'blocking': self.blocking_result_dict}
+        elif self.evaluation_mode == 'matching':
+            return {'matching': self.flexible_classifier_obj.result_dict}
+        else:
+            raise ValueError(f"Evaluation mode {self.evaluation_mode} is not supported")

code/ster_gi_idea3.py

@@ -0,0 +1,467 @@
+"""
+STER-GI Idea 3: Denoise-to-Sibling (去噪造兄弟)
+================================================
+- Train unconditional diffusion on ALL building property vectors (no labels)
+- Generate "sibling" buildings via SDEdit (partial noise + denoise)
+- Contrastive learning on (original, sibling) pairs
+- Zero-shot evaluation on test pairs: encode → cosine sim → threshold → match
+
+Baselines:
+  - real-only (raw property cosine): no training at all
+  - Idea 3 (denoise-to-sibling): diffusion + contrastive
+"""
+
+import os, sys, time, warnings, argparse
+import numpy as np
+import joblib, pickle as pkl
+import torch, torch.nn as nn, torch.nn.functional as F
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import precision_score, recall_score, f1_score, average_precision_score
+from collections import defaultdict
+
+warnings.filterwarnings("ignore")
+
+# ============================================================
+# Config
+# ============================================================
+PROPERTY_NAMES = [
+    "bounding_box_width", "bounding_box_length", "area", "perimeter",
+    "perimeter_ind", "volume", "convex_hull_area", "convex_hull_volume",
+    "ave_centroid_distance", "height_diff", "num_floors", "axes_symmetry",
+    "compactness_2d", "compactness_3d", "density", "elongation",
+    "shape_ind", "hemisphericality", "fractality", "cubeness",
+    "circumference", "aligned_bounding_box_width", "aligned_bounding_box_length",
+    "aligned_bounding_box_height", "num_vertices"
+]
+
+CFG = {
+    'diffusion_steps': 1000,
+    'diffusion_hidden': 256,
+    'diffusion_layers': 4,
+    'diffusion_epochs': 500,
+    'diffusion_lr': 1e-3,
+    'diffusion_batch_size': 512,
+    # SDEdit: how much noise to add (0=none, 1000=full)
+    'sdedit_t0': 200,
+    'num_siblings': 3,
+    # Encoder
+    'encoder_hidden': 128,
+    'encoder_dim': 64,
+    'contrastive_epochs': 200,
+    'contrastive_lr': 1e-3,
+    'contrastive_temp': 0.07,
+    'contrastive_batch': 1024,
+    # Eval: threshold sweep
+    'eval_thresholds': [0.5, 0.6, 0.7, 0.75, 0.8, 0.85, 0.9, 0.92, 0.95, 0.97, 0.99],
+    'device': 'cuda' if torch.cuda.is_available() else 'cpu',
+}
+
+# ============================================================
+# Data: Extract property vectors
+# ============================================================
+def extract_vectors(prop_dict, source, id_list=None):
+    """Extract property matrix for given source ('cands'/'index') and optional id filter"""
+    first_prop = PROPERTY_NAMES[0]
+    all_ids = list(prop_dict[first_prop][source].keys()) if id_list is None else id_list
+    X = np.zeros((len(all_ids), len(PROPERTY_NAMES)), dtype=np.float32)
+    valid_ids = []
+    for i, bid in enumerate(all_ids):
+        vec = []
+        ok = True
+        for pname in PROPERTY_NAMES:
+            val = prop_dict[pname][source].get(bid, None)
+            if val is None or (isinstance(val, float) and np.isnan(val)):
+                val = 0.0
+            vec.append(float(val))
+        X[i] = vec
+        valid_ids.append(bid)
+    return X, valid_ids
+
+
+def load_all_train_vectors(seed):
+    """Load property vectors for ALL training buildings (both cands and index)"""
+    train_path = (f"data/property_dicts/Hague_allmodels_v1_train_matching_medium_"
+                  f"neg_samples_num=2_vector_normalization=True_seed={seed}.joblib")
+    prop = joblib.load(train_path)
+
+    X_cands, ids_cands = extract_vectors(prop, 'cands')
+    X_index, ids_index = extract_vectors(prop, 'index')
+    X = np.concatenate([X_cands, X_index], axis=0)
+    all_ids = ids_cands + ids_index
+    print(f"Loaded {len(X)} train building vectors ({len(X_cands)} cands + {len(X_index)} index)")
+    return X, all_ids, prop
+
+
+def load_test_pairs(seed):
+    """Load test pairs with labels: list of (cand_id, index_id, label)"""
+    test_path = (f"data/property_dicts/Hague_allmodels_v1_test_matching_medium_"
+                 f"neg_samples_num=2_vector_normalization=True_seed={seed}.joblib")
+    prop = joblib.load(test_path)
+
+    partition = pkl.load(open(f"data/dataset_partitions/Hague_seed{seed}.pkl", 'rb'))
+    test_pairs = partition['test']['matching']['negative_sampling']['medium'][2]
+
+    # Build cand/index ID -> vector mappings
+    cand_map = {}
+    for bid in prop[PROPERTY_NAMES[0]]['cands'].keys():
+        vec = []
+        for pname in PROPERTY_NAMES:
+            val = prop[pname]['cands'].get(bid, None)
+            if val is None or (isinstance(val, float) and np.isnan(val)):
+                val = 0.0
+            vec.append(float(val))
+        cand_map[bid] = np.array(vec, dtype=np.float32)
+
+    index_map = {}
+    for bid in prop[PROPERTY_NAMES[0]]['index'].keys():
+        vec = []
+        for pname in PROPERTY_NAMES:
+            val = prop[pname]['index'].get(bid, None)
+            if val is None or (isinstance(val, float) and np.isnan(val)):
+                val = 0.0
+            vec.append(float(val))
+        index_map[bid] = np.array(vec, dtype=np.float32)
+
+    cand_vecs, index_vecs, labels = [], [], []
+    for cid, iid in test_pairs:
+        if cid in cand_map and iid in index_map:
+            cand_vecs.append(cand_map[cid])
+            index_vecs.append(index_map[iid])
+            labels.append(1 if cid == iid else 0)
+
+    cand_vecs = np.array(cand_vecs, dtype=np.float32)
+    index_vecs = np.array(index_vecs, dtype=np.float32)
+    labels = np.array(labels, dtype=np.int32)
+
+    print(f"Test pairs: {len(labels)} ({labels.sum()} pos, {(1-labels).sum()} neg)")
+    return cand_vecs, index_vecs, labels
+
+
+# ============================================================
+# Diffusion Model (DDPM on property vectors)
+# ============================================================
+class MLPDiffusion(nn.Module):
+    def __init__(self, dim, hidden=256, layers=4):
+        super().__init__()
+        self.time_embed = nn.Sequential(
+            nn.Linear(1, hidden), nn.SiLU(), nn.Linear(hidden, hidden))
+        net = [nn.Linear(dim + hidden, hidden), nn.SiLU()]
+        for _ in range(layers - 1):
+            net += [nn.Linear(hidden, hidden), nn.SiLU()]
+        net.append(nn.Linear(hidden, dim))
+        self.net = nn.Sequential(*net)
+
+    def forward(self, x, t):
+        t_emb = self.time_embed(t.unsqueeze(-1).float())
+        return self.net(torch.cat([x, t_emb], dim=-1))
+
+
+class DiffusionScheduler:
+    def __init__(self, steps=1000, beta_start=1e-4, beta_end=0.02):
+        self.steps = steps
+        self.betas = torch.linspace(beta_start, beta_end, steps)
+        self.alphas = 1 - self.betas
+        self.alpha_bars = torch.cumprod(self.alphas, dim=0)
+
+    def add_noise(self, x0, t):
+        ab = self.alpha_bars[t].view(-1, 1)
+        noise = torch.randn_like(x0)
+        return torch.sqrt(ab) * x0 + torch.sqrt(1 - ab) * noise, noise
+
+    @torch.no_grad()
+    def denoise_step(self, model, xt, t):
+        """Single DDPM reverse step"""
+        a = self.alphas[t].view(-1, 1)
+        ab = self.alpha_bars[t].view(-1, 1)
+        b = self.betas[t].view(-1, 1)
+        eps = model(xt, t.float())
+        x0_hat = (xt - torch.sqrt(1 - ab) * eps) / torch.sqrt(a)
+        if t.min() == 0:
+            return x0_hat
+        ab_prev = self.alpha_bars[t - 1].view(-1, 1)
+        mean = (torch.sqrt(ab_prev) * b / (1 - ab) * x0_hat +
+                torch.sqrt(a) * (1 - ab_prev) / (1 - ab) * xt)
+        var = b * (1 - ab_prev) / (1 - ab)
+        return mean + torch.sqrt(var) * torch.randn_like(xt)
+
+    @torch.no_grad()
+    def sdedit(self, model, x0, t0, device):
+        """Add noise to t0, then denoise back → sibling"""
+        n = x0.shape[0]
+        t0_t = torch.full((n,), t0, device=device, dtype=torch.long)
+        ab_t0 = self.alpha_bars[t0]
+        noise = torch.randn_like(x0)
+        xt = torch.sqrt(ab_t0) * x0 + torch.sqrt(1 - ab_t0) * noise
+        for t in range(t0, -1, -1):
+            tb = torch.full((n,), t, device=device, dtype=torch.long)
+            xt = self.denoise_step(model, xt, tb)
+        return xt
+
+
+# ============================================================
+# Contrastive Encoder
+# ============================================================
+class BuildingEncoder(nn.Module):
+    def __init__(self, dim, hidden=128, out_dim=64):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(dim, hidden), nn.BatchNorm1d(hidden), nn.ReLU(),
+            nn.Linear(hidden, hidden), nn.BatchNorm1d(hidden), nn.ReLU(),
+            nn.Linear(hidden, out_dim))
+
+    def forward(self, x):
+        return F.normalize(self.net(x), dim=-1)
+
+
+def info_nce_loss(embs, temp=0.07):
+    """embs: [2B, D] where (0,1), (2,3)... are positives"""
+    n = embs.shape[0] // 2
+    sim = embs @ embs.T / temp
+    # Mask self
+    sim = sim.masked_fill(torch.eye(2 * n, device=embs.device, dtype=torch.bool), -1e9)
+    # Labels: for row i, positive is i^1 (flip last bit)
+    labels = torch.arange(2 * n, device=embs.device)
+    labels = labels ^ 1  # (0->1, 1->0, 2->3, 3->2, ...)
+    return F.cross_entropy(sim, labels)
+
+
+# ============================================================
+# Training
+# ============================================================
+def train_diffusion(X, device):
+    print("\n" + "=" * 50)
+    print("Stage 1: Train Diffusion on Building Vectors")
+    print("=" * 50)
+    dim = X.shape[1]
+    model = MLPDiffusion(dim, CFG['diffusion_hidden'], CFG['diffusion_layers']).to(device)
+    sched = DiffusionScheduler(CFG['diffusion_steps'])
+    sched.betas = sched.betas.to(device)
+    sched.alphas = sched.alphas.to(device)
+    sched.alpha_bars = sched.alpha_bars.to(device)
+
+    opt = torch.optim.Adam(model.parameters(), lr=CFG['diffusion_lr'])
+    ds = TensorDataset(torch.FloatTensor(X))
+    dl = DataLoader(ds, batch_size=CFG['diffusion_batch_size'], shuffle=True)
+
+    model.train()
+    for ep in range(CFG['diffusion_epochs']):
+        total = 0
+        for (xb,) in dl:
+            xb = xb.to(device)
+            bs = xb.shape[0]
+            t = torch.randint(0, CFG['diffusion_steps'], (bs,), device=device)
+            xt, noise = sched.add_noise(xb, t)
+            loss = F.mse_loss(model(xt, t.float()), noise)
+            opt.zero_grad()
+            loss.backward()
+            opt.step()
+            total += loss.item() * bs
+        if (ep + 1) % 100 == 0:
+            print(f"  Epoch {ep+1}/{CFG['diffusion_epochs']} | Loss: {total/len(ds):.6f}")
+    print(f"  Done. Final loss: {total/len(ds):.6f}")
+    return model, sched
+
+
+def generate_siblings(model, sched, X, device):
+    print("\n" + "=" * 50)
+    print(f"Stage 2: Generate Siblings (t0={CFG['sdedit_t0']})")
+    print("=" * 50)
+    model.eval()
+    origs, sibs = [], []
+    bs = CFG['diffusion_batch_size']
+    for i in range(0, len(X), bs):
+        xb = torch.FloatTensor(X[i:i+bs]).to(device)
+        for _ in range(CFG['num_siblings']):
+            sib = sched.sdedit(model, xb, CFG['sdedit_t0'], device)
+            origs.append(xb.cpu().numpy())
+            sibs.append(sib.cpu().numpy())
+
+    origs = np.concatenate(origs, axis=0)
+    sibs = np.concatenate(sibs, axis=0)
+    l2 = np.mean(np.linalg.norm(origs - sibs, axis=1))
+    print(f"  Generated {len(origs)} pairs | Mean L2 diff: {l2:.4f}")
+    return origs, sibs
+
+
+def train_encoder(origs, sibs, device):
+    print("\n" + "=" * 50)
+    print("Stage 3: Contrastive Encoder Training")
+    print("=" * 50)
+    dim = origs.shape[1]
+    encoder = BuildingEncoder(dim, CFG['encoder_hidden'], CFG['encoder_dim']).to(device)
+    opt = torch.optim.Adam(encoder.parameters(), lr=CFG['contrastive_lr'])
+
+    # Interleave: [orig1, sib1, orig2, sib2, ...]
+    n = len(origs)
+    data = np.zeros((n * 2, dim), dtype=np.float32)
+    data[0::2] = origs
+    data[1::2] = sibs
+    ds = TensorDataset(torch.FloatTensor(data))
+    dl = DataLoader(ds, batch_size=CFG['contrastive_batch'], shuffle=True)
+
+    encoder.train()
+    for ep in range(CFG['contrastive_epochs']):
+        total = 0
+        for (xb,) in dl:
+            xb = xb.to(device)
+            emb = encoder(xb)
+            loss = info_nce_loss(emb, CFG['contrastive_temp'])
+            opt.zero_grad()
+            loss.backward()
+            opt.step()
+            total += loss.item() * xb.shape[0]
+        if (ep + 1) % 50 == 0:
+            print(f"  Epoch {ep+1}/{CFG['contrastive_epochs']} | Loss: {total/len(ds):.4f}")
+    print(f"  Done. Final loss: {total/len(ds):.4f}")
+    return encoder
+
+
+# ============================================================
+# Evaluation
+# ============================================================
+@torch.no_grad()
+def eval_zero_shot(encoder, cand_vecs, index_vecs, labels, device, tag="Model"):
+    """Zero-shot pair classification via cosine similarity"""
+    encoder.eval()
+    ct = torch.FloatTensor(cand_vecs).to(device)
+    it = torch.FloatTensor(index_vecs).to(device)
+    ce = encoder(ct).cpu().numpy()
+    ie = encoder(it).cpu().numpy()
+
+    # Cosine sim for each pair
+    sims = np.sum(ce * ie, axis=1)  # [N]
+
+    # Sweep thresholds
+    best_f1, best_thresh, best_res = 0, 0.5, None
+    for th in CFG['eval_thresholds']:
+        pred = (sims >= th).astype(np.int32)
+        p = precision_score(labels, pred, zero_division=0)
+        r = recall_score(labels, pred, zero_division=0)
+        f = f1_score(labels, pred, zero_division=0)
+        if f > best_f1:
+            best_f1, best_thresh, best_res = f, th, (p, r, f)
+
+    print(f"\n  {tag} (best threshold={best_thresh:.2f}):")
+    print(f"    Precision: {best_res[0]:.4f}")
+    print(f"    Recall:    {best_res[1]:.4f}")
+    print(f"    F1:        {best_res[2]:.4f}")
+
+    # Also AP score
+    ap = average_precision_score(labels, sims)
+    print(f"    AvgPrecision: {ap:.4f}")
+
+    return {'precision': best_res[0], 'recall': best_res[1], 'f1': best_res[2],
+            'ap': ap, 'threshold': best_thresh}
+
+
+def eval_real_only(cand_vecs, index_vecs, labels):
+    """Baseline: raw property cosine similarity, no training"""
+    # Normalize
+    cn = cand_vecs / (np.linalg.norm(cand_vecs, axis=1, keepdims=True) + 1e-8)
+    i_n = index_vecs / (np.linalg.norm(index_vecs, axis=1, keepdims=True) + 1e-8)
+    sims = np.sum(cn * i_n, axis=1)
+
+    best_f1, best_thresh, best_res = 0, 0.5, None
+    for th in CFG['eval_thresholds']:
+        pred = (sims >= th).astype(np.int32)
+        p = precision_score(labels, pred, zero_division=0)
+        r = recall_score(labels, pred, zero_division=0)
+        f = f1_score(labels, pred, zero_division=0)
+        if f > best_f1:
+            best_f1, best_thresh, best_res = f, th, (p, r, f)
+
+    ap = average_precision_score(labels, sims)
+    print(f"\n  Baseline Real-Only (best th={best_thresh:.2f}):")
+    print(f"    P={best_res[0]:.4f} R={best_res[1]:.4f} F1={best_res[2]:.4f} AP={ap:.4f}")
+
+    return {'precision': best_res[0], 'recall': best_res[1], 'f1': best_res[2],
+            'ap': ap, 'threshold': best_thresh}
+
+
+# ============================================================
+# Main
+# ============================================================
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--seed', type=int, default=1)
+    parser.add_argument('--t0', type=int, default=200, help='SDEdit noise level')
+    parser.add_argument('--skip_diff', action='store_true')
+    parser.add_argument('--skip_enc', action='store_true')
+    args = parser.parse_args()
+
+    CFG['sdedit_t0'] = args.t0
+    device = CFG['device']
+    seed = args.seed
+    print(f"Device: {device} | t0: {args.t0} | Seed: {seed}")
+
+    # ---- Load data ----
+    X_train, train_ids, train_prop = load_all_train_vectors(seed)
+    cand_vecs, idx_vecs, labels = load_test_pairs(seed)
+
+    # Normalize (fit on train, apply to test)
+    scaler = StandardScaler()
+    X_train_s = scaler.fit_transform(X_train)
+    cand_s = scaler.transform(cand_vecs)
+    idx_s = scaler.transform(idx_vecs)
+
+    # ---- Stage 1+2: Diffusion → Siblings ----
+    diff_path = f"saved_model_files/diff_idea3_s{seed}_t{args.t0}.pt"
+    sib_path = f"saved_model_files/siblings_idea3_s{seed}_t{args.t0}.npz"
+
+    if args.skip_diff and os.path.exists(diff_path):
+        print(f"Loading cached diffusion model: {diff_path}")
+        ck = torch.load(diff_path, map_location=device)
+        model = MLPDiffusion(X_train_s.shape[1], CFG['diffusion_hidden'],
+                            CFG['diffusion_layers']).to(device)
+        model.load_state_dict(ck['model'])
+        sched = DiffusionScheduler(CFG['diffusion_steps'])
+        sched.betas = sched.betas.to(device)
+        sched.alphas = sched.alphas.to(device)
+        sched.alpha_bars = sched.alpha_bars.to(device)
+    else:
+        model, sched = train_diffusion(X_train_s, device)
+        torch.save({'model': model.state_dict()}, diff_path)
+
+    if os.path.exists(sib_path):
+        print(f"Loading cached siblings: {sib_path}")
+        data = np.load(sib_path)
+        origs, sibs = data['origs'], data['sibs']
+    else:
+        origs, sibs = generate_siblings(model, sched, X_train_s, device)
+        np.savez_compressed(sib_path, origs=origs, sibs=sibs)
+
+    # ---- Stage 3: Contrastive Encoder ----
+    enc_path = f"saved_model_files/enc_idea3_s{seed}_t{args.t0}.pt"
+
+    if args.skip_enc and os.path.exists(enc_path):
+        print(f"Loading cached encoder: {enc_path}")
+        ck = torch.load(enc_path, map_location=device)
+        encoder = BuildingEncoder(X_train_s.shape[1], CFG['encoder_hidden'],
+                                  CFG['encoder_dim']).to(device)
+        encoder.load_state_dict(ck['encoder'])
+    else:
+        encoder = train_encoder(origs, sibs, device)
+        torch.save({'encoder': encoder.state_dict()}, enc_path)
+
+    # ---- Evaluation ----
+    print("\n" + "=" * 50)
+    print("RESULTS")
+    print("=" * 50)
+
+    r_base = eval_real_only(cand_s, idx_s, labels)
+    r_idea3 = eval_zero_shot(encoder, cand_s, idx_s, labels, device,
+                              f"Idea 3 (t0={args.t0})")
+
+    print("\n" + "=" * 50)
+    print(f"SUMMARY (seed={seed}, t0={args.t0})")
+    print("=" * 50)
+    print(f"  Baseline (real-only):    F1={r_base['f1']:.4f}  AP={r_base['ap']:.4f}")
+    print(f"  Idea 3  (denoise-sib):   F1={r_idea3['f1']:.4f}  AP={r_idea3['ap']:.4f}")
+    print(f"  ΔF1: {r_idea3['f1'] - r_base['f1']:.4f}  ΔAP: {r_idea3['ap'] - r_base['ap']:.4f}")
+
+    return r_base, r_idea3
+
+
+if __name__ == '__main__':
+    main()

code/ster_gi_idea3_v2.py

@@ -0,0 +1,262 @@
+"""
+STER-GI Idea 3: Denoise-to-Sibling
+- Train: diffusion + contrastive on ALL building vectors (NO labels)
+- Eval: ALL train+test pairs, zero-shot cosine similarity → F1
+"""
+import numpy as np, joblib, pickle as pkl, torch, torch.nn as nn, torch.nn.functional as F, time, os, argparse
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import precision_score, recall_score, f1_score
+
+PROPS = ["bounding_box_width","bounding_box_length","area","perimeter","perimeter_ind",
+    "volume","convex_hull_area","convex_hull_volume","ave_centroid_distance","height_diff",
+    "num_floors","axes_symmetry","compactness_2d","compactness_3d","density","elongation",
+    "shape_ind","hemisphericality","fractality","cubeness","circumference",
+    "aligned_bounding_box_width","aligned_bounding_box_length","aligned_bounding_box_height","num_vertices"]
+
+CFG = {'diff_steps':1000,'diff_hidden':256,'diff_layers':4,'diff_epochs':100,'diff_lr':1e-3,'diff_bs':512,
+       't0':200,'n_sib':2,'enc_hidden':128,'enc_dim':64,'ctr_epochs':100,'ctr_lr':1e-3,'ctr_temp':0.07,'ctr_bs':1024}
+
+# ---------- Data ----------
+def get_vecs(prop_dict, source):
+    ids = list(prop_dict[PROPS[0]][source].keys())
+    X = np.zeros((len(ids), len(PROPS)), dtype=np.float32)
+    for i, bid in enumerate(ids):
+        for j, pn in enumerate(PROPS):
+            v = prop_dict[pn][source].get(bid, None)
+            X[i,j] = float(v) if v is not None and not (isinstance(v,float) and np.isnan(v)) else 0.0
+    return X, ids
+
+def load_all_data(seed):
+    """Load ALL building vectors (train+test) and ALL pairs (train+test)"""
+    # Train buildings
+    tp = f"data/property_dicts/Hague_allmodels_v1_train_matching_medium_neg_samples_num=2_vector_normalization=True_seed={seed}.joblib"
+    trp = joblib.load(tp)
+    Xtc, id_tc = get_vecs(trp, 'cands')
+    Xti, id_ti = get_vecs(trp, 'index')
+    X_all = np.concatenate([Xtc, Xti], axis=0)
+    print(f"Train buildings: {len(Xtc)} cands + {len(Xti)} index = {len(X_all)}", flush=True)
+
+    # Test buildings
+    ep = f"data/property_dicts/Hague_allmodels_v1_test_matching_medium_neg_samples_num=2_vector_normalization=True_seed={seed}.joblib"
+    epd = joblib.load(ep)
+    Xec, id_ec = get_vecs(epd, 'cands')
+    Xei, id_ei = get_vecs(epd, 'index')
+
+    # Combine ALL building vectors (for diffusion training)
+    X_all = np.concatenate([X_all, Xec, Xei], axis=0)
+    print(f"All buildings for diffusion: {len(X_all)}", flush=True)
+
+    # ALL pairs (train+test) for evaluation
+    part = pkl.load(open(f"data/dataset_partitions/Hague_seed{seed}.pkl", 'rb'))
+    train_pairs = part['train']['negative_sampling']['medium'][2]
+    test_pairs = part['test']['matching']['negative_sampling']['medium'][2]
+    all_pairs = list(train_pairs) + list(test_pairs)
+
+    # Build lookup for all buildings
+    cand_map = {}
+    for src_prop, src_ids in [(trp,id_tc), (epd,id_ec)]:
+        for bid in src_ids:
+            if bid not in cand_map:
+                v = [float(src_prop[pn]['cands'].get(bid,0) or 0) for pn in PROPS]
+                cand_map[bid] = np.array(v, dtype=np.float32)
+    index_map = {}
+    for src_prop, src_ids in [(trp,id_ti), (epd,id_ei)]:
+        for bid in src_ids:
+            if bid not in index_map:
+                v = [float(src_prop[pn]['index'].get(bid,0) or 0) for pn in PROPS]
+                index_map[bid] = np.array(v, dtype=np.float32)
+
+    # Build pair vectors + labels
+    cv, iv, lbs = [], [], []
+    for cid, iid in all_pairs:
+        if cid in cand_map and iid in index_map:
+            cv.append(cand_map[cid])
+            iv.append(index_map[iid])
+            lbs.append(1 if cid == iid else 0)
+    cv, iv, lbs = np.array(cv,dtype=np.float32), np.array(iv,dtype=np.float32), np.array(lbs,dtype=np.int32)
+    print(f"All eval pairs: {len(lbs)} ({lbs.sum()} pos, {(1-lbs).sum()} neg)", flush=True)
+    return X_all, cv, iv, lbs
+
+# ---------- Diffusion ----------
+class DiffMLP(nn.Module):
+    def __init__(self,d,h=256,L=4):
+        super().__init__()
+        self.te = nn.Sequential(nn.Linear(1,h),nn.SiLU(),nn.Linear(h,h))
+        net = [nn.Linear(d+h,h),nn.SiLU()]
+        for _ in range(L-1): net += [nn.Linear(h,h),nn.SiLU()]
+        net.append(nn.Linear(h,d))
+        self.net = nn.Sequential(*net)
+    def forward(self,x,t):
+        return self.net(torch.cat([x,self.te(t.unsqueeze(-1).float())],-1))
+
+class DiffSched:
+    def __init__(self,S=1000):
+        self.S=S; self.b=torch.linspace(1e-4,0.02,S); self.a=1-self.b; self.ab=torch.cumprod(self.a,0)
+    def noise(self,x0,t):
+        ab=self.ab[t].view(-1,1); eps=torch.randn_like(x0)
+        return torch.sqrt(ab)*x0+torch.sqrt(1-ab)*eps, eps
+    @torch.no_grad()
+    def step(self,m,xt,t):
+        a=self.a[t].view(-1,1); ab=self.ab[t].view(-1,1); b_=self.b[t].view(-1,1)
+        e=m(xt,t.float()); x0h=(xt-torch.sqrt(1-ab)*e)/torch.sqrt(a)
+        if t.min()==0: return x0h
+        abp=self.ab[t-1].view(-1,1)
+        mu=torch.sqrt(abp)*b_/(1-ab)*x0h+torch.sqrt(a)*(1-abp)/(1-ab)*xt
+        return mu+torch.sqrt(b_*(1-abp)/(1-ab))*torch.randn_like(xt)
+    @torch.no_grad()
+    def sdedit(self,m,x0,t0,dev):
+        n=x0.shape[0]; abt=self.ab[t0]
+        xt=torch.sqrt(abt)*x0+torch.sqrt(1-abt)*torch.randn_like(x0)
+        for t in range(t0,-1,-1):
+            xt=self.step(m,xt,torch.full((n,),t,device=dev,dtype=torch.long))
+        return xt
+
+# ---------- Encoder ----------
+class Encoder(nn.Module):
+    def __init__(self,d,h=128,o=64):
+        super().__init__()
+        self.net=nn.Sequential(nn.Linear(d,h),nn.BatchNorm1d(h),nn.ReLU(),
+                               nn.Linear(h,h),nn.BatchNorm1d(h),nn.ReLU(),nn.Linear(h,o))
+    def forward(self,x): return F.normalize(self.net(x),-1)
+
+def infonce(emb,temp=0.07):
+    n=emb.shape[0]//2; sim=emb@emb.T/temp
+    sim=sim.masked_fill(torch.eye(2*n,device=emb.device,dtype=torch.bool),-1e9)
+    return F.cross_entropy(sim,torch.arange(2*n,device=emb.device)^1)
+
+# ---------- Eval ----------
+def eval_pairs(encoder, cv, iv, lbs, dev, tag=""):
+    encoder.eval()
+    with torch.no_grad():
+        ce = encoder(torch.FloatTensor(cv).to(dev)).cpu().numpy()
+        ie = encoder(torch.FloatTensor(iv).to(dev)).cpu().numpy()
+    sims = np.sum(ce * ie, axis=1)
+    best_f1, best_th = 0, 0
+    for th in np.arange(0.3, 1.0, 0.02):
+        pred = (sims >= th).astype(np.int32)
+        f = f1_score(lbs, pred, zero_division=0)
+        if f > best_f1: best_f1, best_th = f, th
+    p = precision_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0)
+    r = recall_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0)
+    print(f"  {tag}: P={p:.4f} R={r:.4f} F1={best_f1:.4f} (th={best_th:.2f})", flush=True)
+    return best_f1
+
+def baseline_raw(cv, iv, lbs):
+    cn = cv/(np.linalg.norm(cv,axis=1,keepdims=True)+1e-8)
+    i_n = iv/(np.linalg.norm(iv,axis=1,keepdims=True)+1e-8)
+    sims = np.sum(cn * i_n, axis=1)
+    best_f1, best_th = 0, 0
+    for th in np.arange(0.3, 1.0, 0.02):
+        pred = (sims >= th).astype(np.int32)
+        f = f1_score(lbs, pred, zero_division=0)
+        if f > best_f1: best_f1, best_th = f, th
+    p = precision_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0)
+    r = recall_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0)
+    print(f"  Baseline Raw: P={p:.4f} R={r:.4f} F1={best_f1:.4f} (th={best_th:.2f})", flush=True)
+    return best_f1
+
+# ---------- Main ----------
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--seed',type=int,default=1)
+    p.add_argument('--t0',type=int,default=200)
+    p.add_argument('--skip_diff',action='store_true')
+    p.add_argument('--skip_enc',action='store_true')
+    a = p.parse_args()
+    CFG['t0']=a.t0
+    dev = 'cuda' if torch.cuda.is_available() else 'cpu'
+    print(f"Device: {dev} | t0: {a.t0} | Seed: {a.seed}", flush=True)
+
+    # Load
+    X_all, cv, iv, lbs = load_all_data(a.seed)
+    sc = StandardScaler(); Xs = sc.fit_transform(X_all)
+    cv_s, iv_s = sc.transform(cv), sc.transform(iv)
+
+    # Baseline
+    print("\n=== Zero-Shot Baseline ===")
+    b_raw = baseline_raw(cv_s, iv_s, lbs)
+
+    # Diffusion
+    diff_path = f"saved_model_files/diff_i3_s{a.seed}_t{a.t0}.pt"
+    sib_path = f"saved_model_files/sib_i3_s{a.seed}_t{a.t0}.npz"
+    if a.skip_diff and os.path.exists(diff_path):
+        ck = torch.load(diff_path, map_location=dev)
+        model = DiffMLP(Xs.shape[1], CFG['diff_hidden'], CFG['diff_layers']).to(dev)
+        model.load_state_dict(ck['m'])
+        sched = DiffSched(CFG['diff_steps'])
+        for attr in ['b','a','ab']: setattr(sched, attr, getattr(sched, attr).to(dev))
+    else:
+        print("\n=== Training Diffusion ===")
+        model = DiffMLP(Xs.shape[1], CFG['diff_hidden'], CFG['diff_layers']).to(dev)
+        sched = DiffSched(CFG['diff_steps'])
+        for attr in ['b','a','ab']: setattr(sched, attr, getattr(sched, attr).to(dev))
+        opt = torch.optim.Adam(model.parameters(), lr=CFG['diff_lr'])
+        ds = TensorDataset(torch.FloatTensor(Xs)); dl = DataLoader(ds, batch_size=CFG['diff_bs'], shuffle=True)
+        model.train()
+        for ep in range(CFG['diff_epochs']):
+            tot = 0
+            for (xb,) in dl:
+                xb = xb.to(dev); bs = xb.shape[0]
+                t = torch.randint(0, CFG['diff_steps'], (bs,), device=dev)
+                xt, noise = sched.noise(xb, t)
+                loss = F.mse_loss(model(xt, t.float()), noise)
+                opt.zero_grad(); loss.backward(); opt.step(); tot += loss.item()*bs
+            if (ep+1)%10==0: print(f"  Diff ep {ep+1}/{CFG['diff_epochs']}: loss={tot/len(ds):.6f}", flush=True)
+        print(f"  Done: loss={tot/len(ds):.6f}", flush=True)
+        torch.save({'m':model.state_dict()}, diff_path)
+
+    # Siblings
+    if os.path.exists(sib_path):
+        d = np.load(sib_path); origs, sibs = d['o'], d['s']
+    else:
+        print("\n=== Generating Siblings ===")
+        model.eval(); origs, sibs = [], []
+        with torch.no_grad():
+            for i in range(0, len(Xs), CFG['diff_bs']):
+                xb = torch.FloatTensor(Xs[i:i+CFG['diff_bs']]).to(dev)
+                for _ in range(CFG['n_sib']):
+                    sib = sched.sdedit(model, xb, CFG['t0'], dev)
+                    origs.append(xb.cpu().numpy()); sibs.append(sib.cpu().numpy())
+        origs = np.concatenate(origs); sibs = np.concatenate(sibs)
+        print(f"  {len(origs)} pairs, mean L2 diff: {np.mean(np.linalg.norm(origs-sibs,axis=1)):.4f}", flush=True)
+        np.savez_compressed(sib_path, o=origs, s=sibs)
+
+    # Encoder
+    enc_path = f"saved_model_files/enc_i3_s{a.seed}_t{a.t0}.pt"
+    if a.skip_enc and os.path.exists(enc_path):
+        ck = torch.load(enc_path, map_location=dev)
+        encoder = Encoder(Xs.shape[1], CFG['enc_hidden'], CFG['enc_dim']).to(dev)
+        encoder.load_state_dict(ck['e'])
+    else:
+        print("\n=== Training Encoder ===")
+        encoder = Encoder(Xs.shape[1], CFG['enc_hidden'], CFG['enc_dim']).to(dev)
+        opt = torch.optim.Adam(encoder.parameters(), lr=CFG['ctr_lr'])
+        n = len(origs)
+        # Shuffle pairs (not individual samples) to keep (orig, sib) adjacent
+        pair_idx = np.random.permutation(n)
+        origs_shuffled = origs[pair_idx]
+        sibs_shuffled = sibs[pair_idx]
+        data = np.zeros((n*2, Xs.shape[1]), dtype=np.float32)
+        data[0::2]=origs_shuffled; data[1::2]=sibs_shuffled
+        ds = TensorDataset(torch.FloatTensor(data)); dl = DataLoader(ds, batch_size=CFG['ctr_bs'], shuffle=False)
+        encoder.train()
+        for ep in range(CFG['ctr_epochs']):
+            tot = 0
+            for (xb,) in dl:
+                xb = xb.to(dev); emb = encoder(xb); loss = infonce(emb, CFG['ctr_temp'])
+                opt.zero_grad(); loss.backward(); opt.step(); tot += loss.item()*xb.shape[0]
+            if (ep+1)%10==0: print(f"  Enc ep {ep+1}/{CFG['ctr_epochs']}: loss={tot/len(ds):.4f}", flush=True)
+        print(f"  Done: loss={tot/len(ds):.4f}", flush=True)
+        torch.save({'e':encoder.state_dict()}, enc_path)
+
+    # Eval
+    print("\n=== Results ===")
+    eval_pairs(encoder, cv_s, iv_s, lbs, dev, f"Idea3 (t0={a.t0})")
+    print(f"\n  Baseline (raw props):    F1={b_raw:.4f}", flush=True)
+    print(f"  Supervised XGBoost ref:  F1=0.982", flush=True)
+
+# Patched
+if __name__=='__main__': main()
+        sibs_shuffled = sibs[pair_idx]
+in()

code/ster_gi_idea3_v3.py

@@ -0,0 +1,221 @@
+"""STER-GI Idea 3: Denoise-to-Sibling — Zero-Shot 3D GER"""
+import numpy as np, joblib, pickle as pkl, torch, torch.nn as nn, torch.nn.functional as F, time, os, argparse, sys
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import precision_score, recall_score, f1_score
+
+PROPS = ["bounding_box_width","bounding_box_length","area","perimeter","perimeter_ind",
+    "volume","convex_hull_area","convex_hull_volume","ave_centroid_distance","height_diff",
+    "num_floors","axes_symmetry","compactness_2d","compactness_3d","density","elongation",
+    "shape_ind","hemisphericality","fractality","cubeness","circumference",
+    "aligned_bounding_box_width","aligned_bounding_box_length","aligned_bounding_box_height","num_vertices"]
+
+# ===== Data =====
+def get_vecs(prop_dict, source):
+    ids = list(prop_dict[PROPS[0]][source].keys())
+    X = np.zeros((len(ids), len(PROPS)), dtype=np.float32)
+    for i, bid in enumerate(ids):
+        for j, pn in enumerate(PROPS):
+            v = prop_dict[pn][source].get(bid, None)
+            X[i,j] = float(v) if v is not None and not (isinstance(v,float) and np.isnan(v)) else 0.0
+    return X, ids
+
+def load_all(seed):
+    tp = f"data/property_dicts/Hague_allmodels_v1_train_matching_medium_neg_samples_num=2_vector_normalization=True_seed={seed}.joblib"
+    ep = f"data/property_dicts/Hague_allmodels_v1_test_matching_medium_neg_samples_num=2_vector_normalization=True_seed={seed}.joblib"
+    trp = joblib.load(tp); epd = joblib.load(ep)
+    Xtc, id_tc = get_vecs(trp, 'cands'); Xti, id_ti = get_vecs(trp, 'index')
+    Xec, id_ec = get_vecs(epd, 'cands'); Xei, id_ei = get_vecs(epd, 'index')
+    X_all = np.concatenate([Xtc, Xti, Xec, Xei], axis=0)
+    print(f"Buildings: {len(X_all)} (train cands={len(Xtc)} index={len(Xti)} test cands={len(Xec)} index={len(Xei)})", flush=True)
+
+    part = pkl.load(open(f"data/dataset_partitions/Hague_seed{seed}.pkl", 'rb'))
+    all_pairs = list(part['train']['negative_sampling']['medium'][2]) + list(part['test']['matching']['negative_sampling']['medium'][2])
+
+    cand_map, index_map = {}, {}
+    for sp, ids in [(trp,id_tc),(epd,id_ec)]:
+        for bid in ids:
+            if bid not in cand_map:
+                cand_map[bid] = np.array([float(sp[pn]['cands'].get(bid,0) or 0) for pn in PROPS], dtype=np.float32)
+    for sp, ids in [(trp,id_ti),(epd,id_ei)]:
+        for bid in ids:
+            if bid not in index_map:
+                index_map[bid] = np.array([float(sp[pn]['index'].get(bid,0) or 0) for pn in PROPS], dtype=np.float32)
+
+    cv, iv, lbs = [], [], []
+    for cid, iid in all_pairs:
+        if cid in cand_map and iid in index_map:
+            cv.append(cand_map[cid]); iv.append(index_map[iid]); lbs.append(1 if cid == iid else 0)
+    cv, iv, lbs = np.array(cv,dtype=np.float32), np.array(iv,dtype=np.float32), np.array(lbs,dtype=np.int32)
+    print(f"Eval pairs: {len(lbs)} ({lbs.sum()} pos, {(1-lbs).sum()} neg)", flush=True)
+    return X_all, cv, iv, lbs
+
+# ===== Diffusion =====
+class DiffMLP(nn.Module):
+    def __init__(self,d,h=256,L=4):
+        super().__init__()
+        self.te = nn.Sequential(nn.Linear(1,h),nn.SiLU(),nn.Linear(h,h))
+        net = [nn.Linear(d+h,h),nn.SiLU()]
+        for _ in range(L-1): net += [nn.Linear(h,h),nn.SiLU()]
+        net.append(nn.Linear(h,d)); self.net = nn.Sequential(*net)
+    def forward(self,x,t): return self.net(torch.cat([x,self.te(t.unsqueeze(-1).float())],-1))
+
+class DiffSched:
+    def __init__(self,S=1000):
+        self.S=S; self.b=torch.linspace(1e-4,0.02,S); self.a=1-self.b; self.ab=torch.cumprod(self.a,0)
+    def noise(self,x0,t):
+        ab=self.ab[t].view(-1,1); eps=torch.randn_like(x0)
+        return torch.sqrt(ab)*x0+torch.sqrt(1-ab)*eps, eps
+    @torch.no_grad()
+    def step(self,m,xt,t):
+        a=self.a[t].view(-1,1); ab=self.ab[t].view(-1,1); b_=self.b[t].view(-1,1)
+        e=m(xt,t.float()); x0h=(xt-torch.sqrt(1-ab)*e)/torch.sqrt(a)
+        if t.min()==0: return x0h
+        abp=self.ab[t-1].view(-1,1)
+        mu=torch.sqrt(abp)*b_/(1-ab)*x0h+torch.sqrt(a)*(1-abp)/(1-ab)*xt
+        return mu+torch.sqrt(b_*(1-abp)/(1-ab))*torch.randn_like(xt)
+    @torch.no_grad()
+    def sdedit(self,m,x0,t0,dev):
+        n=x0.shape[0]; xt=torch.sqrt(self.ab[t0])*x0+torch.sqrt(1-self.ab[t0])*torch.randn_like(x0)
+        for t in range(t0,-1,-1): xt=self.step(m,xt,torch.full((n,),t,device=dev,dtype=torch.long))
+        return xt
+
+# ===== Encoder =====
+class Encoder(nn.Module):
+    def __init__(self,d,h=128,o=64):
+        super().__init__()
+        self.net=nn.Sequential(nn.Linear(d,h),nn.BatchNorm1d(h),nn.ReLU(),
+                               nn.Linear(h,h),nn.BatchNorm1d(h),nn.ReLU(),nn.Linear(h,o))
+    def forward(self,x): z = self.net(x); return z / (torch.norm(z, dim=-1, keepdim=True).clamp(min=1e-8))
+
+def infonce(emb,temp=0.07):
+    n=emb.shape[0]//2; sim=emb@emb.T/temp
+    sim=sim.masked_fill(torch.eye(2*n,device=emb.device,dtype=torch.bool),-1e9)
+    return F.cross_entropy(sim,torch.arange(2*n,device=emb.device)^1)
+
+# ===== Eval =====
+def eval_pairs(encoder, cv, iv, lbs, dev, tag=""):
+    encoder.eval()
+    with torch.no_grad():
+        ce = encoder(torch.FloatTensor(cv).to(dev)).cpu().numpy()
+        ie = encoder(torch.FloatTensor(iv).to(dev)).cpu().numpy()
+    sims = np.sum(ce * ie, axis=1)
+    best_f1, best_th = 0, 0
+    for th in np.arange(0.3, 1.0, 0.02):
+        pred = (sims >= th).astype(np.int32)
+        f = f1_score(lbs, pred, zero_division=0)
+        if f > best_f1: best_f1, best_th = f, th
+    p = precision_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0)
+    r = recall_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0)
+    print(f"  {tag}: P={p:.4f} R={r:.4f} F1={best_f1:.4f} (th={best_th:.2f})", flush=True)
+    return best_f1
+
+def baseline_raw(cv, iv, lbs):
+    cn = cv/(np.linalg.norm(cv,axis=1,keepdims=True)+1e-8)
+    i_n = iv/(np.linalg.norm(iv,axis=1,keepdims=True)+1e-8)
+    sims = np.sum(cn * i_n, axis=1)
+    best_f1, best_th = 0, 0
+    for th in np.arange(0.3, 1.0, 0.02):
+        pred = (sims >= th).astype(np.int32)
+        f = f1_score(lbs, pred, zero_division=0)
+        if f > best_f1: best_f1, best_th = f, th
+    p = precision_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0)
+    r = recall_score(lbs, (sims>=best_th).astype(np.int32), zero_division=0)
+    print(f"  Baseline Raw: P={p:.4f} R={r:.4f} F1={best_f1:.4f} (th={best_th:.2f})", flush=True)
+    return best_f1
+
+# ===== Main =====
+def main():
+    a = argparse.ArgumentParser()
+    a.add_argument('--seed',type=int,default=1); a.add_argument('--t0',type=int,default=200)
+    a.add_argument('--skip_diff',action='store_true'); a.add_argument('--skip_enc',action='store_true')
+    a.add_argument('--diff_ep',type=int,default=100); a.add_argument('--enc_ep',type=int,default=100)
+    args = a.parse_args()
+    dev = 'cpu'
+    print(f"Device: {dev} | t0: {args.t0} | Seed: {args.seed}", flush=True)
+
+    X_all, cv, iv, lbs = load_all(args.seed)
+    sc = StandardScaler(); Xs = sc.fit_transform(X_all)
+    cv_s, iv_s = sc.transform(cv), sc.transform(iv)
+
+    print("\n=== Baseline ===", flush=True)
+    b_raw = baseline_raw(cv_s, iv_s, lbs)
+
+    # Diffusion
+    diff_path = f"saved_model_files/diff_i3_s{args.seed}_t{args.t0}.pt"
+    sib_path = f"saved_model_files/sib_i3_s{args.seed}_t{args.t0}.npz"
+    if args.skip_diff and os.path.exists(diff_path):
+        print(f"Loading cached diffusion: {diff_path}", flush=True)
+        ck = torch.load(diff_path, map_location=dev)
+        model = DiffMLP(Xs.shape[1]).to(dev); model.load_state_dict(ck['m'])
+        sched = DiffSched(); [setattr(sched,x,getattr(sched,x).to(dev)) for x in ['b','a','ab']]
+    else:
+        print(f"\n=== Diffusion ({args.diff_ep} epochs) ===", flush=True)
+        model = DiffMLP(Xs.shape[1]).to(dev); sched = DiffSched()
+        [setattr(sched,x,getattr(sched,x).to(dev)) for x in ['b','a','ab']]
+        opt = torch.optim.Adam(model.parameters(), lr=1e-3)
+        ds = TensorDataset(torch.FloatTensor(Xs)); dl = DataLoader(ds, batch_size=512, shuffle=True)
+        model.train(); t0_t = time.time()
+        for ep in range(args.diff_ep):
+            tot = 0
+            for (xb,) in dl:
+                xb = xb.to(dev); bs = xb.shape[0]
+                t = torch.randint(0, 1000, (bs,), device=dev)
+                xt, noise = sched.noise(xb, t)
+                loss = F.mse_loss(model(xt, t.float()), noise)
+                opt.zero_grad(); loss.backward(); opt.step(); tot += loss.item()*bs
+            if (ep+1)%10==0: print(f"  Diff ep {ep+1}/{args.diff_ep}: loss={tot/len(ds):.6f} t={time.time()-t0_t:.0f}s", flush=True)
+        print(f"  Done: loss={tot/len(ds):.6f}", flush=True)
+        torch.save({'m':model.state_dict()}, diff_path)
+
+    # Siblings
+    if os.path.exists(sib_path):
+        d = np.load(sib_path); origs, sibs = d['o'], d['s']
+        print(f"Loaded cached siblings: {len(origs)} pairs", flush=True)
+    else:
+        print("\n=== Generating Siblings ===", flush=True)
+        model.eval(); origs, sibs = [], []
+        with torch.no_grad():
+            for i in range(0, len(Xs), 512):
+                xb = torch.FloatTensor(Xs[i:i+512]).to(dev)
+                for _ in range(2):  # 2 siblings per building
+                    origs.append(xb.cpu().numpy()); sibs.append(sched.sdedit(model, xb, args.t0, dev).cpu().numpy())
+        origs = np.concatenate(origs); sibs = np.concatenate(sibs)
+        l2 = np.mean(np.linalg.norm(origs - sibs, axis=1))
+        print(f"  {len(origs)} pairs, mean L2 diff: {l2:.4f}", flush=True)
+        np.savez_compressed(sib_path, o=origs, s=sibs)
+
+    # Encoder
+    enc_path = f"saved_model_files/enc_i3_s{args.seed}_t{args.t0}.pt"
+    if args.skip_enc and os.path.exists(enc_path):
+        print(f"Loading cached encoder: {enc_path}", flush=True)
+        ck = torch.load(enc_path, map_location=dev)
+        encoder = Encoder(Xs.shape[1]).to(dev); encoder.load_state_dict(ck['e'])
+    else:
+        print(f"\n=== Encoder ({args.enc_ep} epochs) ===", flush=True)
+        encoder = Encoder(Xs.shape[1]).to(dev)
+        opt = torch.optim.Adam(encoder.parameters(), lr=1e-4)
+        # Build paired data: shuffle at pair level (NOT sample level)
+        n = len(origs); idx = np.random.permutation(n)
+        data = np.zeros((n*2, Xs.shape[1]), dtype=np.float32)
+        data[0::2] = origs[idx]; data[1::2] = sibs[idx]
+        ds = TensorDataset(torch.FloatTensor(data)); dl = DataLoader(ds, batch_size=1024, shuffle=False)
+        encoder.train(); t0_t = time.time()
+        for ep in range(args.enc_ep):
+            tot = 0
+            for (xb,) in dl:
+                xb = xb.to(dev); emb = encoder(xb); loss = infonce(emb, 0.07)
+                opt.zero_grad(); loss.backward(); torch.nn.utils.clip_grad_norm_(encoder.parameters(), 1.0); opt.step(); tot += loss.item()*xb.shape[0]
+            if (ep+1)%10==0: print(f"  Enc ep {ep+1}/{args.enc_ep}: loss={tot/len(ds):.4f} t={time.time()-t0_t:.0f}s", flush=True)
+        print(f"  Done: loss={tot/len(ds):.4f}", flush=True)
+        torch.save({'e':encoder.state_dict()}, enc_path)
+
+    # Results
+    print("\n=== RESULTS ===", flush=True)
+    f1_i3 = eval_pairs(encoder, cv_s, iv_s, lbs, dev, f"Idea3 (t0={args.t0})")
+    print(f"\n  Baseline (raw):        F1={b_raw:.4f}")
+    print(f"  Idea3 (denoise-sib):   F1={f1_i3:.4f}")
+    print(f"  Supervised XGBoost:    F1=0.982 (reference)")
+    print(f"  Δ over baseline:       {f1_i3-b_raw:+.4f}", flush=True)
+
+if __name__=='__main__': main()