如何获取条件子集值的原始索引及梯度上升中邻居的原矩阵索引

Hey there! Let's break down your two questions with practical, actionable solutions—both boil down to keeping track of indices alongside values instead of separating them, which avoids the headaches you're worried about.

The key mistake to avoid here is filtering values first and then trying to map them back to the original array. That's risky if there are duplicate values, or if you've modified the array in any way. Instead, pair each value with its original index from the start.

Example with a regular Python list: #

Suppose you have an array and want indices of elements greater than 10:

original_arr = [10, 2, 15, 7, 20]
# Filter while preserving indices
filtered_indices = [idx for idx, val in enumerate(original_arr) if val > 10]
filtered_values = [val for idx, val in enumerate(original_arr) if val > 10]

print(filtered_indices)  # Output: [2, 4] (the original positions of 15 and 20)

Example with NumPy arrays (even easier): #

NumPy's np.where directly returns the indices of elements that match your condition:

import numpy as np
arr = np.array([10, 2, 15, 7, 20])
mask = arr > 10
original_indices = np.where(mask)[0]  # [2, 4]

By handling the filtering and index tracking in one step, you eliminate any chance of mismatching values to their original positions.

Your concern about searching for the maximum value later is totally valid—duplicate values could lead to picking the wrong index. The fix is simple: store each neighbor's coordinates along with its value when you sample them, instead of just collecting values.

Let's walk through a concrete example with a 2D NumPy matrix:

import numpy as np

# Sample matrix
matrix = np.array([
    [3, 5, 2],
    [8, 1, 4],
    [6, 7, 9]
])

# Random starting index (replace with np.random.randint for true randomness)
start_i, start_j = 1, 1

# Define the four direct neighbor directions: up, down, left, right
directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

# Collect valid neighbors (coordinates + value)
neighbors = []
for di, dj in directions:
    ni, nj = start_i + di, start_j + dj
    # Make sure the neighbor is within the matrix bounds
    if 0 <= ni < matrix.shape[0] and 0 <= nj < matrix.shape[1]:
        neighbors.append( ((ni, nj), matrix[ni, nj]) )

# Find the neighbor with the maximum value
if neighbors:
    # Use max() with a key to sort by the neighbor's value
    max_neighbor = max(neighbors, key=lambda x: x[1])
    max_index, max_value = max_neighbor
    print(f"Max neighbor index: {max_index}, value: {max_value}")  # Output: (1, 0), 8
else:
    print("No valid neighbors (start is on a corner/edge with no adjacent cells)")

Handling ties (multiple neighbors with the same max value): #

If there's a tie for the maximum value, you can collect all matching indices instead of just the first one:

if neighbors:
    max_val = max(neigh[1] for neigh in neighbors)
    all_max_indices = [neigh[0] for neigh in neighbors if neigh[1] == max_val]
    print(f"All max value indices: {all_max_indices}")

This approach works even if you're using nested loops to check start_i ±1 and start_j ±1—the core idea is always to keep the index tied to its value from the moment you sample the neighbor. No more guessing which index corresponds to your max value!

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