Когда я должен использовать 'sparse'?

Я не эксперт в использовании sparse матрицы, однако Mathworks имеет документация относящийся к эффективности деятельности и вычисления.

их описание сложности вычислений:

вычислительная сложность разреженных операций пропорционально nnz, число ненулевых элементов в матрице. Вычислительный сложность также линейно зависит от размера строки m и размера столбца n матрицы, но независимо от продукта m*n, общее число нулевых и ненулевых элементов.

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

без них скучно вы с алгоритмическими деталями,другого ответа предполагает, что вы не должны беспокоиться о разреженном массиве, который составляет всего 25% ненулей. Они предлагают какой-то код для тестирования. См. их сообщение для деталей.

A = sprand(2000,2000,0.25);
tic,B = A*A;toc
Elapsed time is 1.771668 seconds.

Af = full(A);
tic,B = Af*Af;toc
Elapsed time is 0.499045 seconds.

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

ваши разреженные векторы должны иметь фактически постоянное количество ненулевых записей

что для матриц означает

код N x N разреженная матрица должна иметь <= c * N ненулевые записи, где c является константой "намного меньше", чем N.

давайте дадим псевдо-теоретическое объяснение этому правилу. Рассмотрим достаточно простую задачу создания скалярного (или точечного) произведения двух векторов с двузначными координатами. Теперь, если у вас есть два плотных вектора одинаковой длины N, ваш код будет выглядеть как

//define vectors vector, wector as double arrays of length N 
double sum = 0;
for (int i = 0; i < N; i++)
{
    sum += vector[i] * wector[i];
}

этой суммы в N дополнения N умножений и N conditinal ветви (операции цикла). Самый дорогостоящая операция здесь-условная ветвь, настолько дорогостоящая, что мы можем пренебречь умножениями и тем более добавлениями. Причина, почему это так дорого, объясняется в ответе на этот вопрос.

UPD: на самом деле, в for цикл, вы рискуете выбрать неправильную ветвь только один раз, в конце вашего цикла, так как по определению ветвь по умолчанию для выбора будет идти в цикл. Это составляет не более 1 перезапуска конвейера на скалярный продукт операция.

Давайте теперь посмотрим, как разреженные векторы реализуются в BLAS. Там каждый вектор кодируется двумя массивами: одним из значений и одним из соответствующих индексов, что-то вроде

1.7    -0.8    3.6
171     83     215

(плюс одно целое число, указывающее предполагаемую длину N). В документации BLAS указано, что порядок индексов здесь не играет никакой роли, так что данные

-0.8    3.6    1.7
 83     215    171

кодирует тот же вектор. Это замечание дает достаточно информация для восстановления алгоритма скалярного произведения. Учитывая два разреженных вектора, закодированных данными int[] indices, double[] values и int[] jndices, double[] walues, одно будет вычислить их скалярное произведение в строках этого кода:

double sum = 0;
for (int i = 0; i < indices.length; i++)
{
    for (int j = 0; j < jndices.length; j++)
    {
        if(indices[i] == jndices[j])
        {
            sum += values[indices[i]] * walues[jndices[j]];
        }
    }
}

что дает нам общую сумму indices.length * jndices.length * 2 + indices.length условных ветвей. Это означает, что только для того, чтобы справиться с плотным алгоритм, векторы должны иметь не более sqrt(N) ненулевые элементы. Дело здесь в зависимости от N уже нелинейно, так что есть нет смысла спрашивать, нужна ли вам 1% или 10% или 25% заполнением. 10% идеально подходит для векторов длины 10, все еще в порядке для длины 50 и уже полное разрушение для длины 100.

UPD. В этом фрагменте кода, у вас есть if ветвь, и вероятность принять неправильный путь 50%. Таким образом, скалярное произведение двух разреженных векторов будет примерно в 0,5-1 раз превышать среднее число ненулевых записей на разреженный вектор) конвейер перезапускается, в зависимости от того, насколько разрежен ваши векторы . Числа должны быть скорректированы: в if заявление без else, самая короткая инструкция будет принята сперва, которая "ничего не делать", но все же.

обратите внимание, что наиболее эффективной операцией является скалярное произведение разреженного и плотного вектора. Учитывая разреженный вектор indices и values и плотный вектор dense, ваш код будет выглядеть как

double sum = 0;
for (int i = 0; i < indices.length; i++)
{
    sum += values[indices[i]] * dense[indices[i]];
}

то есть у вас будет indices.length условных ветвлений, это хорошо.

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

теперь, при умножении матрицы на вектор, вы в основном берете скалярные произведения # строк векторов. Матрица умножения c матричными суммами в взятие # ((ненулевых) столбцов во второй матрице) матрицы векторными умножениями. Вы можете выяснить сложность самостоятельно.

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

вы "всегда" будете иметь преимущество в скорости, если вы умножите матрицу, построенную из разреженных строк с плотной матрицей, или матрицу плотных столбцов. Вы можете сохранить свои разреженные матричные данные как плотные векторы диагоналей-так и в случае сверточные нейронные сети - и тогда вам понадобятся совершенно другие алгоритмы. Возможно, вы захотите сделать свою матрицу блочной матрицей - как и BLAS - и получить разумный импульс вычислений. Вы можете хранить ваши данные в виде двух матриц-скажем, диагональной и разреженной, что имеет место для метод конечных элементов. Вы можете использовать разреженность для общих нейронных сетей (например. перемотай вперед, экстремальная обучающая машина или echo state network) если вы всегда умножаете матрицу, хранящуюся в строке, на вектор столбца, но избегаете умножения матриц. И вы" всегда " получите преимущество, используя разреженные матрицы, если будете следовать эмпирическому правилу - это справедливо для конечных элемент и сверточные сети, но не удается для вычисления резервуара.