File size: 9,285 Bytes
dc54818 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 | #!/usr/bin/env python3
"""
Generate 3dSAGER-compatible partition files for all 18 STER cities.
For each city:
1. Downloads object_dict_raw.joblib
2. Splits buildings into train/test (80/20) respecting spatial distribution
3. Generates positive pairs (same building ID)
4. Generates negative pairs (random mismatches)
5. Saves {city}_seed{1,2,3}.pkl
Format matches 3dSAGER DataPartitionGenerator output:
{
'train': {
'negative_sampling': {
'small': {2: [(cand_idx, index_idx), ...], 5: [...]},
'large': {2: [...], 5: [...]}
}
},
'test': {
'matching': {
'negative_sampling': {...},
'blocking-based': {...}
},
'blocking': {
'small': {'cands': set(), 'index': set()},
'large': {'cands': set(), 'index': set()}
}
}
}
"""
import os, sys, pickle, argparse, logging
import numpy as np
from collections import defaultdict
from huggingface_hub import hf_hub_download, HfApi
logger = logging.getLogger("partition_gen")
logger.setLevel(logging.INFO)
h = logging.StreamHandler(sys.stdout)
h.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s'))
logger.addHandler(h)
NEG_SAMPLE_COUNTS = [2, 5]
SEEDS = [1, 2, 3]
TRAIN_RATIO = 0.8
TEST_RATIO = 0.2
GRID_SIZE = 3 # 3x3 spatial grid
REPO = "eduzrh/STER"
def download_object_dict(city):
"""Download SIGMOD-format object_dict for a city."""
path = hf_hub_download(REPO, f"data/{city}/object_dict_raw.joblib", repo_type="dataset")
import joblib
return joblib.load(path)
def spatial_train_test_split(cand_ids, index_ids, od, test_ratio=0.2, grid_size=3, seed=42):
"""
Split buildings spatially using grid-based partitioning.
Returns (train_cand_ids, train_index_ids, test_cand_ids, test_index_ids).
"""
rng = np.random.RandomState(seed)
# Get centroids for spatial partitioning
centroids = {}
for bid in cand_ids:
rec = od['cands'].get(bid, {})
c = rec.get('centroid', np.zeros(3))
centroids[bid] = np.asarray(c)
if len(centroids) == 0:
return set(), set(), set(), set()
# Collect all centroids
pts = np.array([centroids[bid][:2] for bid in cand_ids if bid in centroids])
ids_arr = np.array([bid for bid in cand_ids if bid in centroids])
if len(pts) < 10:
# Too few buildings, random split
n = len(ids_arr)
n_test = max(1, int(n * test_ratio))
idx = rng.permutation(n)
test_ids = set(ids_arr[idx[:n_test]])
train_ids = set(ids_arr[idx[n_test:]])
return train_ids, train_ids, test_ids, test_ids
# Grid-based binning
x_min, y_min = pts.min(axis=0)
x_max, y_max = pts.max(axis=0)
x_bins = np.linspace(x_min, x_max, grid_size + 1)
y_bins = np.linspace(y_min, y_max, grid_size + 1)
x_idx = np.digitize(pts[:, 0], x_bins) - 1
y_idx = np.digitize(pts[:, 1], y_bins) - 1
x_idx = np.clip(x_idx, 0, grid_size - 1)
y_idx = np.clip(y_idx, 0, grid_size - 1)
cells = defaultdict(list)
for i, bid in enumerate(ids_arr):
cells[(x_idx[i], y_idx[i])].append(bid)
# Sample test buildings from each cell proportionally
test_ids = set()
train_ids = set()
for cell_ids in cells.values():
cell_ids = list(cell_ids)
n_cell_test = max(1, int(len(cell_ids) * test_ratio))
rng.shuffle(cell_ids)
test_ids.update(cell_ids[:n_cell_test])
train_ids.update(cell_ids[n_cell_test:])
return train_ids, train_ids, test_ids, test_ids
def generate_pairs(cand_ids, index_ids, inv_map_cands, inv_map_index, neg_count, rng, cand_map, index_map):
"""
Generate positive and negative pairs.
Positive: same building ID → (cand_idx, index_idx)
Negative: random mismatched buildings
"""
common = sorted(set(cand_ids) & set(index_ids))
pos_pairs = []
for bid in common:
ci = inv_map_cands.get(bid)
ii = inv_map_index.get(bid)
if ci is not None and ii is not None:
pos_pairs.append((ci, ii))
n_pos = len(pos_pairs)
neg_pairs = []
if n_pos > 0 and neg_count > 0:
# Shuffle cands to create mismatches
cand_idx_list = [inv_map_cands[bid] for bid in common if bid in inv_map_cands]
index_idx_list = [inv_map_index[bid] for bid in common if bid in inv_map_index]
for _ in range(neg_count * n_pos):
ci = rng.choice(cand_idx_list)
ii = rng.choice(index_idx_list)
# Ensure negative: different building ID
cand_bid = cand_map.get(ci, '')
index_bid = index_map.get(ii, '')
if cand_bid != index_bid:
neg_pairs.append((ci, ii))
if len(neg_pairs) >= neg_count * n_pos:
break
return pos_pairs, neg_pairs
def generate_partition(city, od, seed):
"""Generate a full partition dict for one city/seed."""
rng = np.random.RandomState(seed)
cand_ids = set(od['cands'].keys())
index_ids = set(od['index'].keys())
inv_map_cands = od['inv_mapping_dict']['cands']
inv_map_index = od['inv_mapping_dict']['index']
# Split into train/test
train_cand, train_idx, test_cand, test_idx = spatial_train_test_split(
list(cand_ids), list(index_ids), od, TEST_RATIO, GRID_SIZE, seed
)
common = sorted(cand_ids & index_ids)
n_total = len(common)
n_train = int(n_total * TRAIN_RATIO)
# 'large' = all buildings, 'small' = subset (~30%)
n_small = max(int(n_total * 0.3), 10)
# Build partition dict
part = {
'train': {'negative_sampling': {}},
'test': {
'matching': {'negative_sampling': {}, 'blocking-based': {}},
'blocking': {}
}
}
for size_name, subset_ids in [('small', set(sorted(common)[:n_small])),
('large', set(common))]:
for neg in NEG_SAMPLE_COUNTS:
pos, neg_pairs = generate_pairs(subset_ids, subset_ids, inv_map_cands, inv_map_index, neg, rng, od['mapping_dict']['cands'], od['mapping_dict']['index'])
part['train']['negative_sampling'].setdefault(size_name, {})[neg] = pos + neg_pairs
# Test matching
test_common = sorted(test_cand & test_idx)
for size_name, subset_ids in [('small', set(test_common[:max(1, len(test_common)//3)])),
('large', set(test_common))]:
for neg in NEG_SAMPLE_COUNTS:
pos, neg_pairs = generate_pairs(subset_ids, subset_ids, inv_map_cands, inv_map_index, neg, rng, od['mapping_dict']['cands'], od['mapping_dict']['index'])
part['test']['matching']['negative_sampling'].setdefault(size_name, {})[neg] = pos + neg_pairs
# blocking-based test pairs (all pos, no neg)
pos_all, _ = generate_pairs(subset_ids, subset_ids, inv_map_cands, inv_map_index, 0, rng, od['mapping_dict']['cands'], od['mapping_dict']['index'])
part['test']['matching']['blocking-based'][size_name] = {2: pos_all, 5: pos_all}
# Test blocking
for size_name, subset_ids in [('small', set(sorted(test_common)[:max(1, len(test_common)//3)])),
('large', set(test_common))]:
part['test']['blocking'][size_name] = {
'cands': {inv_map_cands[bid] for bid in subset_ids if bid in inv_map_cands},
'index': {inv_map_index[bid] for bid in subset_ids if bid in inv_map_index},
}
return part
def process_city(city, api):
"""Generate partitions for all seeds for one city."""
import joblib
logger.info(f"[{city}] Loading object_dict...")
try:
od = download_object_dict(city)
except Exception as e:
logger.error(f"[{city}] Download failed: {e}")
return False
logger.info(f"[{city}] {len(od['cands'])} buildings")
for seed in SEEDS:
fname = f"{city}_seed{seed}.pkl"
local = f"/root/autodl-tmp/{fname}"
logger.info(f"[{city}] Generating seed={seed}...")
part = generate_partition(city, od, seed)
with open(local, 'wb') as f:
pickle.dump(part, f)
mb = os.path.getsize(local) / 1e6
logger.info(f"[{city}] seed={seed}: {mb:.1f} MB, uploading...")
api.upload_file(
path_or_fileobj=local,
path_in_repo=f"data/{city}/{fname}",
repo_id=REPO,
repo_type="dataset"
)
os.unlink(local)
return True
if __name__ == "__main__":
ap = argparse.ArgumentParser()
ap.add_argument('--city', type=str, default=None)
args = ap.parse_args()
api = HfApi()
CITIES = [
"amsterdam","rotterdam","hague","utrecht","eindhoven","groningen","maastricht",
"chiyoda","shinjuku","setagaya","chuo","ota","minato","bunkyo","koto",
"kyoto","osaka","sakai"
]
if args.city:
CITIES = [args.city]
for city in CITIES:
try:
process_city(city, api)
except Exception as e:
logger.error(f"[{city}] FAILED: {e}", exc_info=True)
logger.info("=== ALL DONE ===")
|