如何获取不同维度对称矩阵中值超阈值的元素原矩阵索引

直接在提取上三角元素的过程中，同步记录每个元素对应的原矩阵在score中的索引以及矩阵内的行、列坐标，这样筛选阈值后就能直接拿到目标位置，完全不用事后映射，比你原来的方法更直观可靠。

完整代码示例 #

import numpy as np

# 用户提供的score数组
score = [np.array([[1.        , 0.01279797],
        [0.01279797, 1.        ]]), np.array([[1.        , 0.03574311],
        [0.03574311, 1.        ]]), np.array([[1.        , 0.0239954 , 0.02817505],
        [0.0239954 , 1.        , 0.99474305],
        [0.02817505, 0.99474305, 1.        ]]), np.array([[1.        , 0.36028866, 0.04977658],
        [0.36028866, 1.        , 0.3766213 ],
        [0.04977658, 0.3766213 , 1.        ]]), np.array([[1.        , 0.01812659],
        [0.01812659, 1.        ]]), np.array([[1.        , 0.06357861, 0.03934581, 0.04123461],
        [0.06357861, 1.        , 0.28277748, 0.09248888],
        [0.03934581, 0.28277748, 1.        , 0.47969105],
        [0.04123461, 0.09248888, 0.47969105, 1.        ]]), np.array([[1.        , 0.03861763],
        [0.03861763, 1.        ]]), np.array([[1.        , 0.24099389],
        [0.24099389, 1.        ]]), np.array([[1.        , 0.86898379],
        [0.86898379, 1.        ]]), np.array([[1.        , 0.18477927],
        [0.18477927, 1.        ]])]

# 初始化列表，分别存储元素值和对应的位置信息
values = []
positions = []

# 遍历每个矩阵，记录位置和值
for mat_idx, mat in enumerate(score):
    # 获取上三角（排除对角线，k=1）的索引
    triu_i, triu_j = np.triu_indices(mat.shape[0], k=1)
    # 遍历每个上三角元素的索引对
    for i, j in zip(triu_i, triu_j):
        values.append(mat[i, j])
        positions.append( (mat_idx, i, j) )

# 转成numpy数组方便筛选
values_np = np.array(values)
# 设置阈值，这里用0.99（用户示例中第三个矩阵的0.9947会命中）
threshold = 0.99
# 找到超过阈值的元素索引
mask = values_np > threshold

# 输出结果：对应的原矩阵索引、行、列，以及元素值
print("符合条件的元素信息：")
for pos, val in zip(np.array(positions)[mask], values_np[mask]):
    print(f"矩阵索引：{pos[0]}，位置({pos[1]}, {pos[2]})，值：{val:.6f}")

代码说明 #

1. 遍历矩阵时记录位置：用enumerate拿到每个矩阵在score中的索引mat_idx，再通过np.triu_indices获取上三角的行、列索引对，把每个元素的(矩阵索引, 行, 列)和值分别存入列表。
2. 筛选阈值：把值转成numpy数组后，用布尔掩码筛选出超过阈值的元素，直接从positions列表中取出对应的位置信息。
3. 适配任意维度矩阵：不管是2×2、3×3还是更大的矩阵，这个方法都能准确记录位置，不用单独处理不同维度的情况。

如果非要事后映射（不推荐） #

如果坚持用你原来的扁平化存储方式，需要先计算每个矩阵贡献的上三角元素数量，然后累加找到目标元素所在的矩阵，再在该矩阵的上三角索引中找到对应的(i,j)。比如：

# 先计算每个矩阵的上三角元素数量
elem_counts = [len(np.triu_indices(mat.shape[0], k=1))[0] for mat in score]
# 计算累加和，用于定位矩阵
cum_counts = np.cumsum(elem_counts)

# 假设df1是你得到的扁平化数组中的索引（比如df1 = np.where(x > 0.99)[0]）
df1 = np.where(np.array(data) > 0.99)[0]
for idx in df1:
    # 找到对应的矩阵索引
    mat_idx = np.argmax(cum_counts > idx)
    # 找到该元素在矩阵上三角中的位置
    within_mat_idx = idx - (cum_counts[mat_idx-1] if mat_idx >0 else 0)
    # 获取该矩阵的上三角索引
    triu_i, triu_j = np.triu_indices(score[mat_idx].shape[0], k=1)
    # 得到原位置
    i, j = triu_i[within_mat_idx], triu_j[within_mat_idx]
    print(f"矩阵索引：{mat_idx}，位置({i}, {j})，值：{score[mat_idx][i,j]:.6f}")

这个方法需要额外计算累加和，出错概率更高，不如第一种方法直接。

内容的提问来源于stack exchange，提问作者ASking