Использование списка списков индексов для разрезания столбцов и получения длины вектора по строкам

Можешь попробовать:

my_arr = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])
my_idxs = [[0, 1], [2]]

out = np.c_[*[np.linalg.norm(my_arr[:, i], axis=1) for i in my_idxs]]
print(out)

Распечатки:

[[2.23606798 3.        ]
 [2.23606798 3.        ]
 [2.23606798 3.        ]]

Вы хотите вычислить построчные нормы векторов, сформированных путем выбора столбцов из массива NumPy, используя списки индексов различной длины. Вы стремитесь достичь этого эффективно, желательно без использования явных циклов над наборами индексов.

Решение: Вы можете использовать понимание списка, чтобы решить проблему, связанную с наборами индексов различной длины. Хотя это не единственная операция нарезки (что невозможно из-за неправильной формы), это лаконичный подход, использующий возможности операций NumPy.

Вот как это можно реализовать:

import numpy as np

# Define your array
my_arr = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])

# Define your list of index sets
my_idxs = [[0, 1], [2]]

# Compute the norm for each set of indices using a list comprehension
result = np.array([np.linalg.norm(my_arr[:, idx], axis=1) for idx in my_idxs]).T

# Print the result
print(result)

Выход:

 [[2.23606798 3.        ]
 [2.23606798 3.        ]
 [2.23606798 3.        ]]

Объяснение:

Понимание списка: циклически перебирает каждый набор индексов в my_idxs. Для каждого набора он выбирает соответствующие столбцы из my_arr и вычисляет норму по строкам (ось = 1).

Транспонирование (T): Результатом понимания списка является список, в котором каждый элемент представляет собой массив, представляющий нормы, рассчитанные для каждого набора индексов. np.array(...) преобразует этот список в 2D-массив NumPy. Затем применяется транспонирование для правильного выравнивания выходных данных, чтобы каждая строка соответствовала исходным строкам my_arr, а каждый столбец представлял результаты нормы для каждого набора индексов.

Этот подход эффективно удовлетворяет вашим требованиям по вычислению векторных норм на основе подмножеств столбцов массива, даже если подмножества различаются по длине. Он максимально использует возможности NumPy, чтобы избежать явного снижения производительности, связанного с циклическим перебором строк массива.

Заключение: Хотя прямое разделение индексов различной длины на одну операцию невозможно из-за возникающих в результате неоднородных размеров, предоставленное решение достигает вашей цели с помощью компактной и эффективной строки кода Python.

Вот ответ без цикла – вроде. Основная идея состоит в том, чтобы заменить списки индексов my_idxs эквивалентными «логическими масками» my_masks, где содержащиеся индексы отмечены 1, а другие - 0. Затем можно рассчитать норму после взвешивания по маскам. Таким образом, решение может выглядеть следующим образом:

import numpy as np

my_arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# Replace index lists with boolean masks: [0, 1] → [1, 1, 0], [2] → [0, 0, 1]
my_masks = [[1, 1, 0], [0, 0, 1]]

result = np.linalg.norm(my_arr[:, np.newaxis, :] * my_masks, axis=-1)
print(result)
# >>> [[ 2.23606798  3.        ]
#      [ 6.40312424  6.        ]
#      [10.63014581  9.        ]]

Обратите внимание, что я заменил ваши значения в my_arr разными значениями для каждой строки, чтобы подтвердить, что подход действительно работает так, как ожидалось. Более того, я совершенно уверен, что эквивалентное решение можно реализовать с использованием маскированных массивов.

В любом случае, вот в чем загвоздка: я не нашел подхода, который бы не использовал цикл for для преобразования ваших списков индексов в мои маски. Так что, в каком-то смысле, я просто перемещаю проблему. Однако, в зависимости от того, как вы в первую очередь определяете свои списки индексов, использование масок вместо них все равно может быть решением, которое стоит рассмотреть.