Собственные векторы матрицы numpy (4 видео)

numpy.linalg.eig

Функция linalg.eig() вычисляет собственные числа (значения) и собственные векторы квадратной матрицы.

Собственное число квадратной матрицы a и ее собственный вектор связаны равенством np.dot(a, v) = w*v .

Если у матрицы несколько собственных чисел и соответственно несколько собственных векторов, то данная функция возвращает массив собственных значений и массив собственных векторов (необязательно упорядоченных). В этом случае выполняются равенства np.dot(a[. ], v[:,i]) = w[i] * v[:,i] , для всех i из интервала [0, . M — 1] , где M — размер матрицы.

Параметры: a — массив NumPy или подобнй массиву объект. Это может быть толко «квадратный» двумерный массив, т.е. квадратная матрица. Если это многомерный массив, то две его последние оси должны быть равны, в этом случае он рассматривается как массив матриц и все вычисления выполняются отдельно для каждой из них. Возвращает: w — массив NumPy Собственные числа входной матрицы. v — массив NumPy Собственные векторы входной матрицы.

Содержание

Замечание
Примеры
numpy.linalg.eig¶
Игра в собственные
Собственно, собственные
Эрмитовы матрицы
Симметричный MNIST
Эксперимент
Пару слов напоследок
🎦 Видео

Видео:#11. Произведение матриц и векторов, элементы линейной алгебры | NumPy урокиСкачать

Замечание

Видео:Собственные векторы и собственные значения матрицыСкачать

Примеры

Иногда, визуально кажется, что вышеописанные равенства не выполняются:

Однако, значения первых столбцов равны, а значения второго и третьего столбцов настолько малы, что могут быть приравнены к 0.

Всегда следует помнить об ошибках округления:

Но на самом деле w = [1.000000001, 0.999999999] .

Видео:Собственные векторы и собственные числа линейного оператораСкачать

numpy.linalg.eig¶

Compute the eigenvalues and right eigenvectors of a square array.

Parameters a (…, M, M) array

Matrices for which the eigenvalues and right eigenvectors will be computed

Returns w (…, M) array

The eigenvalues, each repeated according to its multiplicity. The eigenvalues are not necessarily ordered. The resulting array will be of complex type, unless the imaginary part is zero in which case it will be cast to a real type. When a is real the resulting eigenvalues will be real (0 imaginary part) or occur in conjugate pairs

v (…, M, M) array

The normalized (unit “length”) eigenvectors, such that the column v[:,i] is the eigenvector corresponding to the eigenvalue w[i] .

If the eigenvalue computation does not converge.

eigenvalues of a non-symmetric array.

eigenvalues and eigenvectors of a real symmetric or complex Hermitian (conjugate symmetric) array.

eigenvalues of a real symmetric or complex Hermitian (conjugate symmetric) array.

Similar function in SciPy that also solves the generalized eigenvalue problem.

Best choice for unitary and other non-Hermitian normal matrices.

New in version 1.8.0.

Broadcasting rules apply, see the numpy.linalg documentation for details.

This is implemented using the _geev LAPACK routines which compute the eigenvalues and eigenvectors of general square arrays.

The number w is an eigenvalue of a if there exists a vector v such that a @ v = w * v . Thus, the arrays a, w, and v satisfy the equations a @ v[:,i] = w[i] * v[:,i] for (i in ) .

The array v of eigenvectors may not be of maximum rank, that is, some of the columns may be linearly dependent, although round-off error may obscure that fact. If the eigenvalues are all different, then theoretically the eigenvectors are linearly independent and a can be diagonalized by a similarity transformation using v, i.e, inv(v) @ a @ v is diagonal.

For non-Hermitian normal matrices the SciPy function scipy.linalg.schur is preferred because the matrix v is guaranteed to be unitary, which is not the case when using eig . The Schur factorization produces an upper triangular matrix rather than a diagonal matrix, but for normal matrices only the diagonal of the upper triangular matrix is needed, the rest is roundoff error.

Finally, it is emphasized that v consists of the right (as in right-hand side) eigenvectors of a. A vector y satisfying y.T @ a = z * y.T for some number z is called a left eigenvector of a, and, in general, the left and right eigenvectors of a matrix are not necessarily the (perhaps conjugate) transposes of each other.

G. Strang, Linear Algebra and Its Applications, 2nd Ed., Orlando, FL, Academic Press, Inc., 1980, Various pp.

(Almost) trivial example with real e-values and e-vectors.

Real matrix possessing complex e-values and e-vectors; note that the e-values are complex conjugates of each other.

Видео:Основы NumPy Python | Массивы, Матрицы И Операции Над НимиСкачать

Игра в собственные

Имеем набор данных в виде совокупности квадратных матриц, которые используются — вместе с известным выходом — в качестве тренировочного набора для нейронной сети. Можно ли обучить нейронную сеть, используя только собственные значения матриц? Во избежание проблем с комплексными значениями, упор делаем на симметричные матрицы. Для иллюстрации используем набор данных MNIST. Понятно, что невозможно восстановить матрицу по ее собственными значениям — для этого понадобится еще кое-что, о чем мы поговорим далее. Поэтому трудно ожидать некоего прорыва на данном пути, хотя известно, что можно говорить о чем угодно, строить грандиозные планы, пока не пришло время платить. О деньгах мы здесь не говорим, просто задаем глупый вопрос, на который постараемся получить осмысленный ответ, тем более что в процессе познания расширим свои научные горизонты. Например, сначала мы познакомимся с тем, как находить собственные векторы и собственные значения (eigenvalues and eigenvectors) для заданной квадратной матрицы, затем плавно выкатим на эрмитовы и унитарные матрицы. Все иллюстративные примеры сопровождаются простыми кодами. Далее возьмем MNIST , преобразуем в набор собственных значений симметричных матриц и используем молоток от Keras. Как говорят в Японии: “Торчащий гвоздь забивают”. Закроем глаза и начнем бить, а на результат можно и не смотреть: получится как всегда. Сразу скажу, что изложение будет проведено как можно ближе к тому, как я это дело понимаю для себя, не обращаясь к строгому обоснованию, которое обычно не используется в повседневной жизни. Иными словами, что понятно одному глупцу, понятно и другому. Все мы невежественны, но, к счастью, не в одинаковой степени. С другой стороны, предполагаю, что многие, хоть и в гимназиях не обучались, но имеют представление — по своему опыту обучения, — что значит впихнуть невпихуемое.

Собственно, собственные

Итак, пусть у нас задана произвольная квадратная матрица с компонентами . Мы ставим запятую между индексами, имея в виду оформление массивов в большинстве языков программирования; обычно так не делается, но мы делаем так, как нам хочется, да и выглядит все более разреженным и удобочитаемым. Мы можем умножить матрицу на произвольный вектор , руководствуясь правилом умножения матриц (строка на столбец), . По повторяющимся индексам производится суммирование; все получится, если размерность первой (нумерация с нуля) оси матрицы совпадает с размерностью вектора. Если будет желание, когда я что-то упускаю из виду, можно заглянуть в мои заметки . Вдруг приключилось так, что , тогда говорят: — собственное значение, — собственный вектор. Опять же, возвращаясь к глубокомысленной дискуссии о запятых в индексах, здесь мы используем точку, когда переходим от компонент к матрицам, имея в виду замечательную функцию dot() в превосходном NumPy. Теперь проведем ряд очевидных манипуляций

где — символ Кронекера, — единичная матрица, 0 — нулевой вектор. Условие нетривиальности решения, , для собственного вектора приводит к характеристическому уравнению . Если размер матрицы равен n, получим алгебраическое уравнение n-й степени, которое имеет n корней (действительных или комплексных) — собственных значений (eigenvalues) . Каждому собственному значению соответствует собственный вектор (eigenvectors) (например, ). Совокупность собственных векторов образует матрицу с компонентами , где нулевая ось — компоненты вектора, а первая — нумерация собственных векторов. Теперь уравнение на собственные значения выглядит следующим образом: . Раз есть вектор, есть его длина, которая равна сумме квадратов компонент (квадрат длины). Например, для квадрата длины третьего вектора (нумерация с нуля) имеем

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

где звездочка обозначает обычное комплексное сопряжение. Следует заметить, что — эрмитово-сопряжённая матрица. Длина вектора — число, отсюда открывается возможность выделить собственное значение путем умножения на собственный вектор. В результате для выделенного собственного значения получим

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

Действительно, характеристическое уравнение имеет решения , где — мнимая единица. Столбцы матрицы — собственные векторы и .

Эрмитовы матрицы

Мы научились находить eigendecomposition для произвольной квадратной матрицы. Пока не будем говорить о вырожденных матрицах , которых, по возможности, будем в дальнейшем избегать. Итак, в чем состоит загвоздка. С собственными значениями — все в порядке, а вот собственные векторы изрядно подгуляли. Дело в том, что они не ортогональны друг другу. Посмотрим, какие условия на матрицу нам потребуется наложить, чтобы добиться ортогональности, заодно откроем для себя ряд новых возможностей в деле познания собственных способностей.

Пусть из всего набора мы произвольно выделили два участника и , где, напомним, второй индекс нумерует собственные вектора. Берем первое соотношение и умножаем его на , а второе — на , в результате имеем

Далее выполним комплексное сопряжение второго уравнения в (5)

Поскольку индексы в последнем уравнении “немые” (по ним производится суммирование) , их можно назвать как угодно. Таким образом, после замены получим

где — эрмитово-сопряжённая матрица, элементы которой определяются как . Теперь из первого уравнения (5) вычитаем (6). В результате получим следующее замечательное выражение:

Пока мы не накладывали никаких ограничений на матрицу. Первое, что приходит на ум: положим , определяя тем самым эрмитову матрицу Следует отметить: все что мы наблюдаем в окружающем нас мире связано, так или иначе, с собственными значениями эрмитовых матриц. Шарль Эрмит — вот кто Создатель Вселенных (см. превосходную биографию, Ожигова Е.П. Шарль Эрмит. — Л.:Наука, 1982.). Да, было время, когда математики занимались реальным миром, не то, что нынешнее племя.

Шарль Эрмит, 1822-1901

Итак, для эрмитовых матриц получаем выражение , которое связано с двумя важнейшими событиями для каждого, кто изучал квантовую механику. Во-первых, собственные значения эрмитовых матриц являются действительными величинами , поскольку при из условия 0″ alt=»v_^*v_>0″ src=»https://habrastorage.org/getpro/habr/upload_files/d8c/47c/bbb/d8c47cbbbf641fa3ff4843e155e4fd7c.svg»/>имеем . Во- вторых, если и , получаем свойство ортогональности собственных векторов . Для эрмитовых матриц собственные значения — действительные величины, а собственные векторы — ортогональны друг другу, вернее, ортонормированы, поскольку удобно включать условие нормировки. Таким образом, мы стремились к аналогии с обычным пространством, с единичными векторами по ортогональным осям, мы это и получили.

Теперь соорудим эрмитову матрицу. Для этого сгенерируем пару случайных матриц и , затем сложим их, умножив одну из матриц на мнимую единицу , . Затем возьмем полученную матрицу и сложим ее с эрмитово-сопряженной. Действительно, , так что — эрмитова матрица.

Пришло время окунуться в мутные воды искусственного интеллекта. Внести, так сказать, свой слабый голос в общий хор.

Собственные значения (values) получились с едва заметной мнимой частью, которую мы отрезаем по идеологическим соображениям. Для этого мы оставили только действительную часть. Напомним, что

где — единичная матрица (по диагонали единицы ). Проверим в коде

Опять же получим почти единичную матрицу, но ничего округлять не будем. Теперь пришло время для громкого заявления : матрица, для которой выполняется (8) — унитарная матрица . Таким образом, эрмитово-сопряжённая унитарная матрица совпадает с обратной. К слову, эволюция во времени нашего мира осуществляется с помощью унитарных преобразований, хотя этот факт теряется во множестве событий. Не удивительно, что унитарную эволюцию попытались использовать (см. статью) и в машинном обучении, но для рекуррентной нейронной сети. Для многих концепция унитарности заставляет ощутить священный трепет познания. Но это одна среда обитания. В политическом же питательном бульоне тоже есть концепция унитарности, о которой можно думать все что угодно, и которая не связана ни с каким познанием.

Симметричный MNIST

Итак, в предыдущем разделе мы говорили о произвольных о эрмитовых матрицах. Если же мы имеем дело с действительными матрицами, комплексное сопряжение выпадает, поэтому эрмитовы — это просто симметричные матрицы, .

В этом разделе мы возьмем набор данных MNIST и попробуем поработать с каждым элементом как с матрицей. Каждое рукописное изображение цифр (от 0 до 9) — матрица с формой (28,28), каждый элемент которой — число от 0 до 255 (8-битная шкала серого). Загрузим и посмотрим (рекомендую начать новый блокнот).

База данных MNIST состоит тренировочного и тестового наборов, где — набор рукописных изображений цифр(матриц), которые подаем на вход, а — набор правильных ответов (числа от 0 до 9); тестовый набор выделен для удобства. Теперь посмотрим, сколько их там, и что они из себя представляют. Для этого подключим “рисовалку”.

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

Сразу можно отметить (посмотрите сами), что слишком много нулей. Это вырожденная матрица, определитель ее равен нулю.

Если попробуем вычислить собственные значения, никакого сбоя не случится, просто некоторые из них будут равны нулю.

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

Итак, хочется поскорее избавиться от комплексных чисел. Мы знаем, что эрмитовы матрицы обладают действительными собственными значениями. Поскольку матрица изображения полностью состоит из действительных чисел, то эрмитова матрица — просто симметричная матрица. Иными словами, нам потребуется соорудить симметричную матрицу, но перед этим избавиться от множества нулей. Для этого “закрасим” пикселями, выбирая их значения случайным образом.

Пятерочки для закраски вполне достаточно, поскольку вероятность совпадения элементов в строке или столбце просто мизерная. Детерминант, конечно, громадный, но Python все стерпит, а пока закроем на это глаза. Если посмотрим на картинку, то поверьте, там все нормально: наша тройка практически не изменилась.

Итак, перейдем к симметричной матрице и посмотрим, что там нарисовано.

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

Если с собственными значениями все в порядке, то собственные векторы малость подгуляли: мало того, что они комплексные (как обычно и бывает), так восстановление первоначальной матрицы по собственным векторам и собственным значениям может привести к комплексной матрице. Python не знает, что это не правильно, поэтому и вытянет наружу комплексные остатки. Само собой, можно от них избавиться с помощью метода np.real(), оставляя только действительную часть. Но пока попробуем в лоб, проверим прозорливость создателей NumPy на примере восстановления матрицы по собственным значениям и собственным векторам. Чтобы подготовить почву, необходимо вернуться к уравнениям (8), которые справедливы и для нашей матрицы , в которой столбцы — собственные векторы матрицы (см. выше). Таким образом, . Следует напомнить, что, несмотря на повторяющийся индекс , в правой части нет суммирования (берем фиксированное ). Далее имеем

где — диагональная матрица собственных значений (по диагонали — собственные значения). Умножая последнее уравнение с правой стороны на , получим

в котором использовали (8) . Теперь проверим в коде

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

Эксперимент

Итак, теперь мы умеем манипулировать симметричными матрицами, используя в качестве полигона базу данных MNIST. Теперь мы попытаемся представить набор данных как симметричные матрицы, затем вычислить собственные значения, на основе которых построить нейронную сеть по примеру обращения с обычным набором. Сразу скажу, что надежд на удачный исход мало. Действительно, как мы выяснили ранее, для того чтобы восстановить матрицу собственных значений недостаточно, для этого необходим набор собственных векторов, объединенных в матрицу , которая сама по себе имеет размер исходной матрицы. Так что, с первого взгляда, мы ничего не выигрываем. Тем не менее, есть надежда, что распределение и свойства собственных значений обладают необходимыми свойствами, чтобы их классифицировать по классам. Иными словами, собственные значения несут информацию о классах рукописных цифр. Распределением собственных значений мы займемся в следующей публикации, а сейчас будем использовать наивный подход, а именно : 1) представим набор MNIST в виде симметричных матриц (28*28); 2) для каждого экземпляра вычислим собственные значения (28 штук); 3) используем Keras. Первые шаги мы уже сделали в предыдущем разделе, а над последним особо заморачиваться не будем, поскольку мы просто ставим эксперименты.

Начинаем новый блокнот:

Теперь напишем функцию, которая будет “закрашивать” матрицы из набора данных. Отмечу, что использую доморощенные функции, которые предпочитаю писать самостоятельно, чем искать на мутных форумах.

Используем эту функцию, затем масштабируем (это не обязательно).

На следующем шаге нам понадобится функция, которая делает симметричные матрицы и возвращает только собственные значения.

Включаем и смотрим.

Как видно, вполне приемлемые значения, с которыми можно и поработать. Для этого возьмем продвинутый молоток от Keras.

За основу мы берем код из Глубокое обучение на Python. Если осмысленно побалуетесь с цифрами, что-то получите. Точность, которая едва-едва заваливает за 0,5 (за 100 эпох. ), подкачала по сравнению с оригиналом (accuracy: 0.9897 за Epoch 5), когда используется полная матрица изображения, но хотя бы мы не множили сущности. Для обсуждения не требуется глубокомысленных обобщений, просто, как я наивно думал, если зайца долго бить по голове, он научится спички зажигать. Но оказалось, что этот принцип в глубоком обучении не всегда срабатывает. Возиться дальше — интересно, но бессмысленно. Самое главное, по пути к этому мутному результату можно много чему научиться.

Пару слов напоследок

Итак, пришло время подводить итоги. Понятно, что говорить пока не о чем. Мы попытались на собственных значениях матриц построить работающую схему. Не получилось. Но известно, что отрицательный результат — куда более значимое событие, чем положительный, поскольку при этом у нас открываются новые перспективы. Если бы у нас все получилось, настало бы время для рутинной работы, а так — продолжим идти дальше. Правда и ложь — два взгляда на одну и ту же реальность. Но мы, по крайней мере, не лгали. Просто посмотрели с другого ракурса, заодно открыли для себя новые возможности. К примеру, почему бы не найти преобразование, позволяющее связать все изображения одного класса без использования внешнего наблюдателя для подтверждения события? Иными словами, из одной цифры получить почти полную совокупность из данного набора данных; из “тройки” почти все “тройки”, и т.д.. Сразу приходит на ум конформное отображение двумерных поверхностей: локальные вращения и растяжения с сохранением углов между кривыми, а значит с сохранением формы бесконечно малых фигур. Заодно мы могли бы проследить за трансформацией собственных значений, дабы по их расположению выйти на классификацию по классам. И не обязательно использовать действительные собственные значения. Конечно, переход в комплексную область потребует дополнительных усилий, но там уже существует путь в один путь, многое успешно отработано.

Что касается реальных, на настоящий момент, дел, то это классификация собственных значений по примеру распределения уровней сложных систем. Опять же MNIST животворящий. Но это тема следующей публикации.