ProDiff/utils/utils.py

from math import sin, cos, sqrt, atan2, radians, asin
import numpy as np
import torch
import os
from torch.distributed import init_process_group, destroy_process_group
import torch.nn.functional as F
import random
def resample_trajectory(x, length=200):
    """
    Resamples a trajectory to a new length.

    Parameters:
        x (np.ndarray): original trajectory, shape (N, 2)
        length (int): length of resampled trajectory

    Returns:
        np.ndarray: resampled trajectory, shape (length, 2)
    """
    len_x = len(x)
    time_steps = np.arange(length) * (len_x - 1) / (length - 1)
    x = x.T
    resampled_trajectory = np.zeros((2, length))
    for i in range(2):
        resampled_trajectory[i] = np.interp(time_steps, np.arange(len_x), x[i])
    return resampled_trajectory.T


def time_warping(x, length=200):
    """
    Resamples a trajectory to a new length.
    """
    len_x = len(x)
    time_steps = np.arange(length) * (len_x - 1) / (length - 1)
    x = x.T
    warped_trajectory = np.zeros((2, length))
    for i in range(2):
        warped_trajectory[i] = np.interp(time_steps, np.arange(len_x), x[i])
    return warped_trajectory.T


def gather(consts: torch.Tensor, t: torch.Tensor):
    """
    Gather consts for $t$ and reshape to feature map shape
    :param consts: (N, 1, 1)
    :param t: (N, H, W)
    :return: (N, H, W)
    """
    c = consts.gather(-1, t)
    return c.reshape(-1, 1, 1)


def q_xt_x0(x0, t, alpha_bar):
    # get mean and variance of xt given x0
    mean = gather(alpha_bar, t) ** 0.5 * x0
    var = 1 - gather(alpha_bar, t)
    # sample xt from q(xt | x0)
    eps = torch.randn_like(x0).to(x0.device)
    xt = mean + (var ** 0.5) * eps
    return xt, eps  # also return noise


def compute_alpha(beta, t):
    beta = torch.cat([torch.zeros(1).to(beta.device), beta], dim=0)
    a = (1 - beta).cumprod(dim=0).index_select(0, t + 1).view(-1, 1, 1)
    return a


def p_xt(xt, noise, t, next_t, beta, eta=0):
    at = compute_alpha(beta.cuda(), t.long())
    at_next = compute_alpha(beta, next_t.long())
    x0_t = (xt - noise * (1 - at).sqrt()) / at.sqrt()
    c1 = (eta * ((1 - at / at_next) * (1 - at_next) / (1 - at)).sqrt())
    c2 = ((1 - at_next) - c1 ** 2).sqrt()
    eps = torch.randn(xt.shape, device=xt.device)
    xt_next = at_next.sqrt() * x0_t + c1 * eps + c2 * noise
    return xt_next


def divide_grids(boundary, grids_num):
    lati_min, lati_max = boundary['lati_min'], boundary['lati_max']
    long_min, long_max = boundary['long_min'], boundary['long_max']
    # Divide the latitude and longitude into grids_num intervals.
    lati_interval = (lati_max - lati_min) / grids_num
    long_interval = (long_max - long_min) / grids_num
    # Create arrays of latitude and longitude values.
    latgrids = np.arange(lati_min, lati_max, lati_interval)
    longrids = np.arange(long_min, long_max, long_interval)
    return latgrids, longrids


# calculate the distance between two points
def distance(lat1, lon1, lat2, lon2):
    """
    Calculate the great circle distance between two points 
    on the earth (specified in decimal degrees)
    """
    # convert decimal degrees to radians
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
    # haversine formula
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * asin(sqrt(a))
    r = 6371  # Radius of earth in kilometers. Use 3956 for miles
    return c * r * 1000

def set_seed(seed):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed(seed)
        torch.cuda.manual_seed_all(seed)
        torch.backends.cudnn.deterministic = True
        torch.backends.cudnn.benchmark = False
        
def ddp_setup():
    init_process_group(backend="nccl")
    torch.cuda.set_device(int(os.environ['LOCAL_RANK']))


def destroy_process_group():
    destroy_process_group()


import torch

class IterativeKMeans:
    def __init__(self, num_clusters, device, num_iters=100, tol=1e-4):
        self.num_clusters = num_clusters
        self.num_iters = num_iters
        self.tol = tol
        self.cluster_centers = None
        self.labels = None
        self.device = device

    def fit(self, X):
        # X = torch.tensor(X, dtype=torch.float32).to(self.device)
        X = X.clone().detach().to(self.device)
        num_samples, num_features = X.shape
        indices = torch.randperm(num_samples)[:self.num_clusters]
        self.cluster_centers = X[indices].clone().detach()
        self.labels = torch.argmin(torch.cdist(X, self.cluster_centers), dim=1).cpu().numpy()

        for _ in range(self.num_iters):
            distances = torch.cdist(X, self.cluster_centers)
            labels = torch.argmin(distances, dim=1)
            # new_cluster_centers = torch.stack([X[labels == i].mean(dim=0) for i in range(self.num_clusters)])
            new_cluster_centers = torch.stack([X[labels == i].mean(dim=0) if (labels == i).sum() > 0 else self.cluster_centers[i] for i in range(self.num_clusters)])
            center_shift = torch.norm(new_cluster_centers - self.cluster_centers, dim=1).sum().item()
            if center_shift < self.tol:
                break
            self.cluster_centers = new_cluster_centers

        self.labels = labels.cpu().numpy()
        return self.cluster_centers, self.labels

    def update(self, new_X, original_X):
        combined_X = torch.cat([original_X, new_X], dim=0)
        combined_X = combined_X.clone().detach().to(self.device)

        for _ in range(self.num_iters):
            distances = torch.cdist(combined_X, self.cluster_centers)
            labels = torch.argmin(distances, dim=1)
            new_cluster_centers = torch.stack([combined_X[labels == i].mean(dim=0) if (labels == i).sum() > 0 else self.cluster_centers[i] for i in range(self.num_clusters)])
            center_shift = torch.norm(new_cluster_centers - self.cluster_centers, dim=1).sum().item()
            if center_shift < self.tol:
                break
            self.cluster_centers = new_cluster_centers

        self.labels = labels.cpu().numpy()
        return self.cluster_centers, self.labels

    def predict(self, X):
        # X = torch.tensor(X, dtype=torch.float32).to(self.device)
        X = X.clone().detach().to(self.device)
        distances = torch.cdist(X, self.cluster_centers)
        labels = torch.argmin(distances, dim=1)
        return labels

    def to(self, device):
        self.device = device
        if self.cluster_centers is not None:
            self.cluster_centers = self.cluster_centers.to(device)
        return self


def assign_labels(prototypes, features):
    # Calculate pairwise distances between all features and prototypes
    distances = F.pairwise_distance(features.unsqueeze(1), prototypes.unsqueeze(0))
    # Find the index of the prototype with the minimum distance (on the second dimension)
    labels = torch.argmin(distances, dim=-1)

    return labels


def get_positive_negative_pairs(prototypes, samples):
    positive_pairs = []
    negative_pairs = []
    for sample in samples:
        distances = F.pairwise_distance(sample.unsqueeze(0), prototypes)
        pos_idx = torch.argmin(distances).item()
        neg_idx = torch.argmax(distances).item()
        positive_pairs.append(prototypes[pos_idx])
        negative_pairs.append(prototypes[neg_idx])
    return torch.stack(positive_pairs), torch.stack(negative_pairs)



def mask_data_general(x: torch.Tensor):
    """Mask the input data""" 
    mask = torch.ones_like(x)
    mask[:, :, 1:-1] = 0
    return x * mask.float()


def continuous_mask_data(x: torch.Tensor, mask_ratio: float = 0.5):
    """
    Mask a continuous block of the input data.
    It keeps the first and last elements unmasked.
    """
    mask = torch.ones_like(x)
    
    traj_length = x.shape[2]
    if traj_length <= 2:
        return x * mask.float()

    masked_length = int((traj_length - 2) * mask_ratio)
    if masked_length == 0:
        return x * mask.float()

    # The start of the mask is between the first and the last but one element.
    # The selection ensures that the mask does not run over the second to last element.
    mask_start = random.randint(1, traj_length - 2 - masked_length)
    mask_end = mask_start + masked_length

    mask[:, :, mask_start:mask_end] = 0
    return x * mask.float()


def update_npy(file_path, data):
    if os.path.exists(file_path):
        existing_data = np.load(file_path, allow_pickle=True).item()
        existing_data.update(data)
    else:
        existing_data = data
    np.save(file_path, existing_data)


def haversine(lat1, lon1, lat2, lon2):
    # Convert degrees to radians
    lat1, lon1, lat2, lon2 = map(np.radians, [lat1, lon1, lat2, lon2])

    # Haversine formula
    dlat = lat2 - lat1
    dlon = lon2 - lon1
    a = np.sin(dlat / 2.0)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon / 2.0)**2
    c = 2 * np.arcsin(np.sqrt(a))
    r = 6371  # Radius of Earth in kilometers
    return c * r * 1000  # Return distance in meters


def continuous_time_based_mask(x: torch.Tensor, points_to_mask: int):
    """
    Mask a continuous block of the input data based on a fixed number of points.
    It keeps the first and last elements unmasked.
    
    Args:
        x (torch.Tensor): Input tensor of shape (batch, features, length).
        points_to_mask (int): The number of continuous points to mask.
    """
    mask = torch.ones_like(x)
    
    traj_length = x.shape[2]
    # 确保有足够的点可以遮蔽 (首尾点+遮蔽段)
    if traj_length <= points_to_mask + 2:
        # 如果轨迹太短，无法满足遮蔽要求，则不进行遮蔽
        return x * mask.float()

    # 随机选择遮蔽的起始位置
    # 起始位置必须在第一个点之后，并确保遮蔽段不会超出倒数第二个点
    mask_start = random.randint(1, traj_length - 1 - points_to_mask)
    mask_end = mask_start + points_to_mask

    mask[:, :, mask_start:mask_end] = 0
    return x * mask.float()


def mask_multiple_segments(x: torch.Tensor, points_per_segment: list):
    """
    Mask multiple non-overlapping continuous segments in the input data.
    Keeps the first and last elements unmasked.

    Args:
        x (torch.Tensor): Input tensor of shape (batch, features, length).
        points_per_segment (list of int): List containing the length of each segment to mask.
    """
    mask = torch.ones_like(x)
    traj_length = x.shape[2]
    
    # Sort segments by length, descending, to place larger gaps first
    segments = sorted(points_per_segment, reverse=True)
    total_mask_points = sum(segments)

    # Check if there's enough space for all masks and endpoints
    if traj_length < total_mask_points + 2:
        return x * mask.float()

    # Generate a list of all possible start indices for masking
    # Exclude first and last points: [1, ..., traj_length-2]
    possible_indices = list(range(1, traj_length - 1))
    
    masked_intervals = []

    for seg_length in segments:
        # Find valid start positions for the current segment
        valid_starts = []
        for i in possible_indices:
            # A start is valid if the segment [i, i + seg_length) does not overlap with existing masked intervals
            # and does not go out of bounds
            if i + seg_length > traj_length - 1:
                continue
            
            is_valid = True
            for start, end in masked_intervals:
                # Check for overlap: [i, i+seg_length) vs [start, end)
                if not (i + seg_length <= start or i >= end):
                    is_valid = False
                    break
            if is_valid:
                valid_starts.append(i)
        
        if not valid_starts:
            # Not enough space for this segment, continue to next (smaller) one
            continue

        # Choose a random start position and apply the mask
        start_pos = random.choice(valid_starts)
        end_pos = start_pos + seg_length
        mask[:, :, start_pos:end_pos] = 0
        
        # Record the masked interval and remove these indices from possible choices
        masked_intervals.append((start_pos, end_pos))
        
        # Update possible_indices by removing the masked range
        indices_to_remove = set(range(start_pos, end_pos))
        possible_indices = [idx for idx in possible_indices if idx not in indices_to_remove]

    return x * mask.float()

def get_data_paths(data_config, for_train=True):
    """Get the file paths for training or testing data for TKY-like structure.
    Assumes data_config.traj_path1 points to a directory containing train.h5 and test.h5.
    """

    base_path = data_config.traj_path1
    if not isinstance(base_path, str):
        base_path = str(base_path)

    # Check if we're using temporal split data
    if hasattr(data_config, 'dataset') and 'temporal' in data_config.dataset:
        if for_train:
            file_path = os.path.join(base_path, "train_temporal.h5")
        else:
            file_path = os.path.join(base_path, "test_temporal.h5")
    else:
        # Use the original file names
        if for_train:
            file_path = os.path.join(base_path, "train.h5")
        else:
            file_path = os.path.join(base_path, "test.h5")
    

    return [file_path]