code/generate_partitions.py

#!/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 ===")