主流的编辑距离算法之外的社会距离计算 2.3：欧几里得和卡方计算中，TraMineR 的窗口处理与 Python 实现的差异

[1–4], [3–6], [5–8], [7–10], [9–12]

[1–3], [1–4], [3–6], [5–8], [7–10], [9–12], [11–12]

[[1]]  1  3
[[2]]  1  4
[[3]]  3  6
[[4]]  5  8
[[5]]  7 10
[[6]]  9 12
[[7]] 11 12

TraMineR (overlap=TRUE) =
    [头段] +
    [主段1, 主段1移位段] +
    [主段2, 主段2移位段] +
    [主段3, 主段3移位段?] +
    ...直到打满结尾

[1–4], [3–6], [5–8], [7–10], [9–12]

def generate_windows(length, step=4, overlap=True):
    stride = step // 2 if overlap else step
    windows = []
    for start in range(0, length - step + 1, stride):
        windows.append((start, start + step - 1))
    return windows

[(0, 3), (2, 5), (4, 7), (6, 9), (8, 11)]

def generate_windows(length, step=4, overlap=True):
    """
    将一个序列长度切成若干时间段窗口，用于后续状态分布计算。

    参数：
        length (int): 序列长度（即时间点数量）
        step (int): 每个窗口的长度
        overlap (bool): 是否重叠（滑窗）

    返回：
        List[Tuple[int, int]]: 每个窗口的起止索引（从0开始，含头含尾）
    """
    windows = []
    stride = step // 2 if overlap else step
    for start in range(0, length - step + 1, stride):
        windows.append((start, start + step - 1))
    return windows

generate_windows(length=12, step=4, overlap=True)
# 输出：[(0, 3), (2, 5), (4, 7), (6, 9), (8, 11)]

from collections import Counter

def state_distribution(window_seq, state_set):
    """
    将一个窗口内的状态序列转换为状态比例向量。

    参数：
        window_seq (List[str]): 这个窗口中的状态列表
        state_set (List[str]): 所有可能状态的全集（确保顺序统一）

    返回：
        List[float]: 每种状态的比例（向量）
    """
    counter = Counter(window_seq)
    total = len(window_seq)
    return [counter[state] / total for state in state_set]

state_distribution(['A', 'A', 'B', 'C'], ['A', 'B', 'C'])
# 输出：[0.5, 0.25, 0.25]

def sequence_to_vector(seq, state_set, step=4, overlap=True):
    """
    把整个状态序列转换成一个拼接好的超长状态向量。

    参数：
        seq (List[str]): 原始状态序列
        state_set (List[str]): 所有可能状态
        step, overlap: 切段控制

    返回：
        List[float]: 超长拼接状态比例向量
    """
    windows = generate_windows(len(seq), step, overlap)
    segments = []
    for start, end in windows:
        window_seq = seq[start:end + 1]
        dist = state_distribution(window_seq, state_set)
        segments.extend(dist)
    return segments

sequence_to_vector(['A', 'A', 'B', 'C', 'B', 'B', 'C', 'C', 'A', 'A', 'B', 'C'], ['A', 'B', 'C'])

seq = ['A', 'A', 'B', 'C', 'B', 'B', 'C', 'C', 'A', 'A', 'B', 'C']
state_set = ['A', 'B', 'C']
step = 4
overlap = True

[0–3] → A A B C
[2–5] → B C B B
[4–7] → B B C C
[6–9] → C C A A
[8–11] → A A B C

[0.5, 0.25, 0.25,
 0.0, 0.75, 0.25,
 0.0, 0.5, 0.5,
 0.5, 0.0, 0.5,
 0.5, 0.25, 0.25]

[0.5, 0.25, 0.25, 0.0, 0.75, 0.25, 0.0, 0.5, 0.5, 0.5, 0.0, 0.5, 0.5, 0.25, 0.25]

def show_window_vectors(seq, state_set, step=4, overlap=True):
    windows = generate_windows(len(seq), step, overlap)
    for i, (start, end) in enumerate(windows):
        window_seq = seq[start:end+1]
        vec = state_distribution(window_seq, state_set)
        print(f"[{start+1}-{end+1}] {window_seq} -> {vec}")

show_window_vectors(seq, ['A', 'B', 'C'], step=4, overlap=True)

import numpy as np

def euclidean_distance(vec1, vec2):
    return np.linalg.norm(np.array(vec1) - np.array(vec2))

euclidean_distance([0.5, 0.3, 0.2], [0.3, 0.5, 0.2])
# 输出 ≈ 0.28

def compute_distance_matrix(sequences, state_set, step=4, overlap=True):
    """
    计算所有个体状态序列之间的欧几里得距离矩阵。

    参数：
        sequences (List[List[str]]): 所有个体的状态序列列表
        state_set (List[str]): 状态全集

    返回：
        2D NumPy array: 距离矩阵
    """
    vectors = [sequence_to_vector(seq, state_set, step, overlap) for seq in sequences]
    n = len(vectors)
    matrix = np.zeros((n, n))
    for i in range(n):
        for j in range(i + 1, n):
            dist = euclidean_distance(vectors[i], vectors[j])
            matrix[i][j] = matrix[j][i] = dist
    return matrix