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")