- linalg.eig(a)[source]#
-
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
columnv[:,i]is the eigenvector corresponding to the
eigenvaluew[i].
- Raises:
-
- LinAlgError
-
If the eigenvalue computation does not converge.
See also
eigvals-
eigenvalues of a non-symmetric array.
eigh-
eigenvalues and eigenvectors of a real symmetric or complex Hermitian (conjugate symmetric) array.
eigvalsh-
eigenvalues of a real symmetric or complex Hermitian (conjugate symmetric) array.
scipy.linalg.eig-
Similar function in SciPy that also solves the generalized eigenvalue problem.
scipy.linalg.schur-
Best choice for unitary and other non-Hermitian normal matrices.
Notes
New in version 1.8.0.
Broadcasting rules apply, see the
numpy.linalgdocumentation for
details.This is implemented using the
_geevLAPACK 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 thata @ v = w * v. Thus, the arrays a, w, and
v satisfy the equationsa @ v[:,i] = w[i] * v[:,i]
for (i in {0,…,M-1}).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 @ vis 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 usingeig. 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.Tfor 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.References
G. Strang, Linear Algebra and Its Applications, 2nd Ed., Orlando, FL,
Academic Press, Inc., 1980, Various pp.Examples
>>> from numpy import linalg as LA
(Almost) trivial example with real e-values and e-vectors.
>>> w, v = LA.eig(np.diag((1, 2, 3))) >>> w; v array([1., 2., 3.]) array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]])
Real matrix possessing complex e-values and e-vectors; note that the
e-values are complex conjugates of each other.>>> w, v = LA.eig(np.array([[1, -1], [1, 1]])) >>> w; v array([1.+1.j, 1.-1.j]) array([[0.70710678+0.j , 0.70710678-0.j ], [0. -0.70710678j, 0. +0.70710678j]])
Complex-valued matrix with real e-values (but complex-valued e-vectors);
note thata.conj().T == a, i.e., a is Hermitian.>>> a = np.array([[1, 1j], [-1j, 1]]) >>> w, v = LA.eig(a) >>> w; v array([2.+0.j, 0.+0.j]) array([[ 0. +0.70710678j, 0.70710678+0.j ], # may vary [ 0.70710678+0.j , -0. +0.70710678j]])
Be careful about round-off error!
>>> a = np.array([[1 + 1e-9, 0], [0, 1 - 1e-9]]) >>> # Theor. e-values are 1 +/- 1e-9 >>> w, v = LA.eig(a) >>> w; v array([1., 1.]) array([[1., 0.], [0., 1.]])
Improve Article
Save Article
Like Article
Improve Article
Save Article
Like Article
In NumPy we can compute the eigenvalues and right eigenvectors of a given square array with the help of numpy.linalg.eig(). It will take a square array as a parameter and it will return two values first one is eigenvalues of the array and second is the right eigenvectors of a given square array.
Syntax: numpy.linalg.eig()
Parameter: An square array.
Return: It will return two values first is eigenvalues and second is eigenvectors.
Example 1:
Python
import numpy as np
mat = np.mat("1 -2;1 3")
print(mat)
print("")
evalue, evect = np.linalg.eig(mat)
print(evalue)
print("")
print(evect)
Output:
[[ 1 -2] [ 1 3]] [2.+1.j 2.-1.j] [[ 0.81649658+0.j 0.81649658-0.j ] [-0.40824829-0.40824829j -0.40824829+0.40824829j]]
Example 2:
Python
import numpy as np
mat = np.mat("1 2 3;1 3 4;3 2 1")
print(mat)
print("")
evalue, evect = np.linalg.eig(mat)
print(evalue)
print("")
print(evect)
Output:
[[1 2 3] [1 3 4] [3 2 1]] [ 6.70156212 0.29843788 -2. ] [[-0.5113361 -0.42932334 -0.40482045] [-0.69070311 0.7945835 -0.52048344] [-0.5113361 -0.42932334 0.75180941]]
Last Updated :
10 Aug, 2020
Like Article
Save Article
Содержание
- NumPy: матрицы и операции над ними
- 1. Создание матриц
- 2. Индексирование
- 3. Векторы, вектор-строки и вектор-столбцы
- 4. Datatypes
- 5. Математические операции
- 6. Умножение матриц и столбцов
- 7. Объединение массивов
- Задания: (Блок 1)
- Задание 1:
- Задание 2:
- Задания: (Блок 1)
- 8. Транспонирование матриц
- 9. Определитель матрицы
- 10. Ранг матрицы
- 11. Системы линейных уравнений
- 12. Обращение матриц
- 13. Собственные числа и собственные вектора матрицы
- 14. Расстояния между векторами
- p-норма
- ℓ1 норма
- ℓ2 норма
- 15. Расстояния между векторами
- 16. Скалярное произведение и угол между векторами
- 17. Комплексные числа в питоне
- Задания: (Блок 2)
- Задание 3:
- Задания: (Блок 2)
NumPy: матрицы и операции над ними
Ссылка на jupyter notebook
В этом ноутбуке из сторонних библиотек нам понадобится только NumPy.
Для удобства импортируем ее под более коротким именем:
import numpy as np
1. Создание матриц
Приведем несколько способов создания матриц в NumPy.
Самый простой способ — с помощью функции
numpy.array(list, dtype=None, …).
В качестве первого аргумента ей надо передать итерируемый объект,
элементами которого являются другие итерируемые объекты одинаковой длины
и содержащие данные одинакового типа.
Второй аргумент является опциональным и определяет тип данных матрицы.
Его можно не задавать, тогда тип данных будет определен из типа
элементов первого аргумента. При задании этого параметра будет
произведена попытка приведения типов.
Например, матрицу из списка списков целых чисел можно создать следующим
образом:
a = np.array([1, 2, 3]) # Создаем одномерный массив print(type(a)) # Prints "<class 'numpy.ndarray'>" print(a.shape) # Prints "(3,)" - кортеж с размерностями print(a[0], a[1], a[2]) # Prints "1 2 3" a[0] = 5 # Изменяем значение элемента массива print(a) # Prints "[5, 2, 3]" b = np.array([[1,2,3],[4,5,6]]) # Создаем двухмерный массив print(b.shape) # Prints "(2, 3)" print(b[0, 0], b[0, 1], b[1, 0]) # Prints "1 2 4" print(np.arange(1, 5)) #Cоздает вектор с эелементами от 1 до 4
<class 'numpy.ndarray'> (3,) 1 2 3 [5 2 3] (2, 3) 1 2 4 [1 2 3 4]
matrix = np.array([[1, 2, 3], [2, 5, 6], [6, 7, 4]]) print ("Матрица:n", matrix)
Матрица: [[1 2 3] [2 5 6] [6 7 4]]
Второй способ создания — с помощью встроенных функций
numpy.eye(N, M=None, …), numpy.zeros(shape, …),
numpy.ones(shape, …).
Первая функция создает единичную матрицу размера N×M;
если M не задан, то M = N.
Вторая и третья функции создают матрицы, состоящие целиком из нулей или
единиц соответственно. В качестве первого аргумента необходимо задать
размерность массива — кортеж целых чисел. В двумерном случае это набор
из двух чисел: количество строк и столбцов матрицы.
Примеры:
b = np.eye(5) print ("Единичная матрица:n", b)
Единичная матрица: [[1. 0. 0. 0. 0.] [0. 1. 0. 0. 0.] [0. 0. 1. 0. 0.] [0. 0. 0. 1. 0.] [0. 0. 0. 0. 1.]]
c = np.ones((7, 5)) print ("Матрица, состоящая из одних единиц:n", c)
Матрица, состоящая из одних единиц: [[1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.]]
d = np.full((2,2), 7) # Создает матрицу (1, 2) заполненую заданным значением print(d) # Prints "[[ 7. 7.] # [ 7. 7.]]" e = np.random.random((2,2)) # Создает еденичную матрицу (2, 2) заполненую случаными числами (0, 1) print(e) # Might print "[[ 0.91940167 0.08143941] # [ 0.68744134 0.87236687]]"
[[7 7] [7 7]] [[0.25744383 0.48056466] [0.13767881 0.40578168]]
Обратите внимание: размерность массива задается не двумя аргументами
функции, а одним — кортежем!
Вот так — np.ones(7, 5) — создать массив не получится, так как
функции в качестве параметра shape передается 7, а не кортеж
(7, 5).
И, наконец, третий способ — с помощью функции
numpy.arange([start, ]stop, [step, ], …), которая создает
одномерный массив последовательных чисел из промежутка
[start, stop) с заданным шагом step, и метода
array.reshape(shape).
Параметр shape, как и в предыдущем примере, задает размерность
матрицы (кортеж чисел). Логика работы метода ясна из следующего примера:
v = np.arange(0, 24, 2) print ("Вектор-столбец:n", v)
Вектор-столбец: [ 0 2 4 6 8 10 12 14 16 18 20 22]
d = v.reshape((3, 4)) print ("Матрица:n", d)
Матрица: [[ 0 2 4 6] [ 8 10 12 14] [16 18 20 22]]
Более подробно о том, как создавать массивы в NumPy, см.
документацию.
2. Индексирование
Для получения элементов матрицы можно использовать несколько способов.
Рассмотрим самые простые из них.
Для удобства напомним, как выглядит матрица d:
print ("Матрица:n", d)
Матрица: [[ 0 2 4 6] [ 8 10 12 14] [16 18 20 22]]
Элемент на пересечении строки i и столбца j можно
получить с помощью выражения array[i, j].
Обратите внимание: строки и столбцы нумеруются с нуля!
print ("Второй элемент третьей строки матрицы:", d[2, 1])
Второй элемент третьей строки матрицы: 18
Из матрицы можно получать целые строки или столбцы с помощью выражений
array[i, :] или array[:, j] соответственно:
print ("Вторая строка матрицы d:n", d[1, :]) print ("Четвертый столбец матрицы d:n", d[:, 3])
Вторая строка матрицы d: [ 8 10 12 14] Четвертый столбец матрицы d: [ 6 14 22]
Еще один способ получения элементов — с помощью выражения
array[list1, list2], где list1, list2 —
некоторые списки целых чисел. При такой адресации одновременно
просматриваются оба списка и возвращаются элементы матрицы с
соответствующими координатами. Следующий пример более понятно объясняет
механизм работы такого индексирования:
print ("Элементы матрицы d с координатами (1, 2) и (0, 3):n", d[[1, 0], [2, 3]])
Элементы матрицы d с координатами (1, 2) и (0, 3): [12 6]
# Slicing # Создадим матрицу (3, 4) # [[ 1 2 3 4] # [ 5 6 7 8] # [ 9 10 11 12]] a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) # Используя слайсинг, созадим матрицу b из элементов матрицы а # будем использовать 0 и 1 строку, а так же 1 и 2 столебц # [[2 3] # [6 7]] b = a[:2, 1:3] print(b) # ОБРАТИТЕ ВНИМАНИЕ НА ИЗМЕНЕНИЕ ИСХОДОЙ МАТРИЦЫ print(a[0, 1]) # Prints "2" b[0, 0] = 77 # b[0, 0] is the same piece of data as a[0, 1] print(a[0, 1]) # Prints "77"
[[2 3] [6 7]] 2 77
# Integer array indexing a = np.array([[1,2], [3, 4], [5, 6]]) print(a) print() # Пример Integer array indexing # В результате получится массив размерности (3,) # Обратите внимание, что до запятой идут индексы строк, после - столбцов print(a[[0, 1, 2], [0, 1, 0]]) # Prints "[1 4 5]" print() # По-другому пример можно записать так print(np.array([a[0, 0], a[1, 1], a[2, 0]])) # Prints "[1 4 5]"
[[1 2] [3 4] [5 6]] [1 4 5] [1 4 5]
Примеры использования слайсинга:
# Создадим новый маассив, из которого будем выбирать эллементы a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]]) print(a) # prints "array([[ 1, 2, 3], # [ 4, 5, 6], # [ 7, 8, 9], # [10, 11, 12]])" # Создадим массив индексов b = np.array([0, 2, 0, 1]) # Выберем из каждой строки элемент с индексом из b (индекс столбца берется из b) print(a[np.arange(4), b]) # Prints "[ 1 6 7 11]" print() # Добавим к этим элементам 10 a[np.arange(4), b] += 10 print(a) # prints "array([[11, 2, 3], # [ 4, 5, 16], # [17, 8, 9], # [10, 21, 12]])
[[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]] [ 1 6 7 11] [[11 2 3] [ 4 5 16] [17 8 9] [10 21 12]]
a = np.array([[1,2], [3, 4], [5, 6]]) bool_idx = (a > 2) # Найдем эллементы матрицы a, которые больше 2 # В результате получим матрицу b, такой же размерности, как и a print(bool_idx) # Prints "[[False False] print() # [ True True] # [ True True]]" # Воспользуемся полученным массивом для создания нового массива, ранга 1 print(a[bool_idx]) # Prints "[3 4 5 6]" # Аналогично print(a[a > 2]) # Prints "[3 4 5 6]"
[[False False] [ True True] [ True True]] [3 4 5 6] [3 4 5 6]
#Помните, что вы можете пользоваться сразу несколькими типами индексирования a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) row_r1 = a[1, :] row_r2 = a[1:2, :] print(row_r1, row_r1.shape) # Prints "[5 6 7 8] (4,)" print(row_r2, row_r2.shape) # Prints "[[5 6 7 8]] (1, 4)"
[5 6 7 8] (4,) [[5 6 7 8]] (1, 4)
Более подробно о различных способах индексирования в массивах см.
документацию.
3. Векторы, вектор-строки и вектор-столбцы
Следующие два способа задания массива кажутся одинаковыми:
a = np.array([1, 2, 3]) b = np.array([[1], [2], [3]])
Однако, на самом деле, это задание одномерного массива (то есть
вектора) и двумерного массива:
print ("Вектор:n", a) print ("Его размерность:n", a.shape) print ("Двумерный массив:n", b) print ("Его размерность:n", b.shape)
Вектор: [1 2 3] Его размерность: (3,) Двумерный массив: [[1] [2] [3]] Его размерность: (3, 1)
Обратите внимание: вектор (одномерный массив) и вектор-столбец
или вектор-строка (двумерные массивы) являются различными объектами в
NumPy, хотя математически задают один и тот же объект. В случае
одномерного массива кортеж shape состоит из одного числа и имеет
вид (n,), где n — длина вектора. В случае двумерных
векторов в shape присутствует еще одна размерность, равная
единице.
В большинстве случаев неважно, какое представление использовать, потому
что часто срабатывает приведение типов. Но некоторые операции не
работают для одномерных массивов. Например, транспонирование (о нем
пойдет речь ниже):
a = a.T b = b.T
print ("Вектор не изменился:n", a) print ("Его размерность также не изменилась:n", a.shape) print ("Транспонированный двумерный массив:n", b) print ("Его размерность изменилась:n", b.shape)
Вектор не изменился: [1 2 3] Его размерность также не изменилась: (3,) Транспонированный двумерный массив: [[1 2 3]] Его размерность изменилась: (1, 3)
4. Datatypes
Все элементы в массиве numpy принадлежат одному типу. В этом плане
массивы ближе к C, чем к привычным вам листам питона. Numpy имеет
множество встренных типов, подходящих для решения большинства задач.
x = np.array([1, 2]) # Автоматический выбор типа print(x.dtype) # Prints "int64" x = np.array([1.0, 2.0]) # Автоматический выбор типа print(x.dtype) # Prints "float64" x = np.array([1, 2], dtype=np.int64) # Принудительное выставление типа print(x.dtype) # Prints "int64"
int32 float64 int64
5. Математические операции
К массивам (матрицам) можно применять известные вам математические
операции. Следут понимать, что при этом у элементов должны быть схожие
размерности. Поведение в случае не совпадения размерностей хорошо
описанно в документации numpy.
x = np.array([[1,2],[3,4]], dtype=np.float64) y = np.array([[5,6],[7,8]], dtype=np.float64) arr = np.array([1, 2])
# Сложение происходит поэлеметно # [[ 6.0 8.0] # [10.0 12.0]] print(x + y) print() print(np.add(x, y)) print('С числом') print(x + 1) print('C массивом другой размерности') print(x + arr)
[[ 6. 8.] [10. 12.]] [[ 6. 8.] [10. 12.]] С числом [[2. 3.] [4. 5.]] C массивом другой размерности [[2. 4.] [4. 6.]]
# Вычитание print(x - y) print(np.subtract(x, y))
[[-4. -4.] [-4. -4.]] [[-4. -4.] [-4. -4.]]
# Деление # [[ 0.2 0.33333333] # [ 0.42857143 0.5 ]] print(x / y) print(np.divide(x, y))
[[0.2 0.33333333] [0.42857143 0.5 ]] [[0.2 0.33333333] [0.42857143 0.5 ]]
# Другие функции # [[ 1. 1.41421356] # [ 1.73205081 2. ]] print(np.sqrt(x))
[[1. 1.41421356] [1.73205081 2. ]]
6. Умножение матриц и столбцов
Напоминание теории. Операция умножения определена для двух
матриц, таких что число столбцов первой равно числу строк второй.
Пусть матрицы A и B таковы, что
A ∈ ℝn×k и
B ∈ ℝk×m. Произведением матриц
A и B называется матрица C, такая что
cij = ∑kr = 1airbrj, где cij —
элемент матрицы C, стоящий на пересечении строки с номером
i и столбца с номером j.
В NumPy произведение матриц вычисляется с помощью функции
numpy.dot(a, b, …) или с помощью метода
array1.dot(array2), где array1 и array2 —
перемножаемые матрицы.
a = np.array([[1, 0], [0, 1]]) b = np.array([[4, 1], [2, 2]]) r1 = np.dot(a, b) r2 = a.dot(b)
print ("Матрица A:n", a) print ("Матрица B:n", b) print ("Результат умножения функцией:n", r1) print ("Результат умножения методом:n", r2)
Матрица A: [[1 0] [0 1]] Матрица B: [[4 1] [2 2]] Результат умножения функцией: [[4 1] [2 2]] Результат умножения методом: [[4 1] [2 2]]
Матрицы в NumPy можно умножать и на векторы:
c = np.array([1, 2]) r3 = b.dot(c)
print ("Матрица:n", b) print ("Вектор:n", c) print ("Результат умножения:n", r3)
Матрица: [[4 1] [2 2]] Вектор: [1 2] Результат умножения: [6 6]
Обратите внимание: операция * производит над матрицами
покоординатное умножение, а не матричное!
r = a * b
print ("Матрица A:n", a) print ("Матрица B:n", b) print ("Результат покоординатного умножения через операцию умножения:n", r)
Матрица A: [[1 0] [0 1]] Матрица B: [[4 1] [2 2]] Результат покоординатного умножения через операцию умножения: [[4 0] [0 2]]
Более подробно о матричном умножении в NumPy см.
документацию.
7. Объединение массивов
Массивы можно Объединенять. Есть горизонтальное и вертикальное
объединение.
a = np.floor(10*np.random.random((2,2))) b = np.floor(10*np.random.random((2,2))) print(a) print(b) print() print(np.vstack((a,b))) print() print(np.hstack((a,b)))
[[4. 0.] [1. 4.]] [[9. 7.] [2. 6.]] [[4. 0.] [1. 4.] [9. 7.] [2. 6.]] [[4. 0. 9. 7.] [1. 4. 2. 6.]]
Массивы можно переформировать при помощи метода, который задает новый
многомерный массив. Следуя следующему примеру, мы переформатируем
одномерный массив из десяти элементов во двумерный массив, состоящий из
пяти строк и двух столбцов:
a = np.array(range(10), float) print(a) print() # Превратим в матрицу a = a.reshape((5, 2)) print(a) print() # Вернем обратно print(a.flatten()) # Другой вариант print(a.reshape((-1))) # Превратим в марицу (9, 1) print(a.reshape((-1, 1))) # Превратим в марицу (1, 9) print(a.reshape((1, -1)))
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] [[0. 1.] [2. 3.] [4. 5.] [6. 7.] [8. 9.]] [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] [[0.] [1.] [2.] [3.] [4.] [5.] [6.] [7.] [8.] [9.]] [[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]]
Задания: (Блок 1)
Задание 1:
Решите без использования циклов средставми NumPy (каждый пункт решается
в 1-2 строчки)
- Создайте вектор с элементами от 12 до 42
- Создайте вектор из нулей длины 12, но его пятый елемент должен быть равен 1
- Создайте матрицу (3, 3), заполненую от 0 до 8
- Найдите все положительные числа в np.array([1,2,0,0,4,0])
- Умножьте матрицу размерности (5, 3) на (3, 2)
- Создайте матрицу (10, 10) так, чтобы на границе были 0, а внтури 1
- Создайте рандомный вектор и отсортируйте его
- Каков эквивалент функции enumerate для numpy массивов?
- *Создайте рандомный вектор и выполните нормализацию столбцов (из каждого столбца вычесть среднее этого столбца, из каждого столбца вычесть sd этого столбца)
- *Для заданного числа найдите ближайший к нему элемент в векторе
- *Найдите N наибольших значений в векторе
# ваш код здесь
Задание 2:
Напишите полностью векторизованный вариант
Дан трёхмерный массив, содержащий изображение, размера (height, width,
numChannels), а также вектор длины numChannels. Сложить каналы
изображения с указанными весами, и вернуть результат в виде матрицы
размера (height, width). Считать реальное изображение можно при помощи
функции
scipy.misc.imread
(если изображение не в формате png,
установите пакет pillow:
conda install pillow
). Преобразуйте
цветное изображение в оттенки серого, использовав коэффициенты
np.array([0.299, 0.587, 0.114]).
# ваш код здесь
8. Транспонирование матриц
Напоминание теории. Транспонированной матрицей AT
называется матрица, полученная из исходной матрицы A заменой
строк на столбцы. Формально: элементы матрицы AT определяются
как aTij = aji, где aTij — элемент
матрицы AT, стоящий на пересечении строки с номером i
и столбца с номером j.
В NumPy транспонированная матрица вычисляется с помощью функции
numpy.transpose() или с помощью метода array.T, где
array — нужный двумерный массив.
a = np.array([[1, 2], [3, 4]]) b = np.transpose(a) c = a.T
print ("Матрица:n", a) print ("Транспонирование функцией:n", b) print ("Транспонирование методом:n", c)
Матрица: [[1 2] [3 4]] Транспонирование функцией: [[1 3] [2 4]] Транспонирование методом: [[1 3] [2 4]]
См. более подробно о
numpy.transpose()
и
array.T
в NumPy.
В следующих разделах активно используется модуль numpy.linalg,
реализующий некоторые приложения линейной алгебры. Более подробно о
функциях, описанных ниже, и различных других функциях этого модуля можно
посмотреть в его
документации.
9. Определитель матрицы
Напоминание теории. Для квадратных матриц существует понятие
определителя.
Пусть A — квадратная матрица. Определителем (или
детерминантом) матрицы A ∈ ℝn×n назовем
число
detA = ∑α1, α2, …, αn( − 1)N(α1, α2, …, αn)⋅aα11⋅⋅⋅aαnn,
где α1, α2, …, αn — перестановка
чисел от 1 до n,
N(α1, α2, …, αn) — число инверсий в
перестановке, суммирование ведется по всем возможным перестановкам длины
n.
Не стоит расстраиваться, если это определение понятно не до конца — в
дальнейшем в таком виде оно не понадобится.
Например, для матрицы размера 2×2 получается:
det⎛⎜⎝
a11
a12
a21
a22
⎞⎟⎠ = a11a22 − a12a21
Вычисление определителя матрицы по определению требует порядка
n! операций, поэтому разработаны методы, которые позволяют
вычислять его быстро и эффективно.
В NumPy определитель матрицы вычисляется с помощью функции
numpy.linalg.det(a), где a — исходная матрица.
a = np.array([[1, 2, 1], [1, 1, 4], [2, 3, 6]], dtype=np.float32) det = np.linalg.det(a)
print ("Матрица:n", a) print ("Определитель:n", det)
Матрица: [[1. 2. 1.] [1. 1. 4.] [2. 3. 6.]] Определитель: -1.0
Рассмотрим одно интересное свойство определителя. Пусть у нас есть
параллелограмм с углами в точках
(0, 0), (c, d), (a + c, b + d), (a, b) (углы даны в порядке обхода по
часовой стрелке). Тогда площадь этого параллелограмма можно вычислить
как модуль определителя матрицы
⎛⎜⎝
a
c
b
d
⎞⎟⎠.
Похожим образом можно выразить и объем параллелепипеда через
определитель матрицы размера 3×3.
10. Ранг матрицы
Напоминание теории. Рангом матрицы A называется
максимальное число линейно независимых строк (столбцов) этой матрицы.
В NumPy ранг матрицы вычисляется с помощью функции
numpy.linalg.matrix_rank(M, tol=None), где M — матрица,
tol — параметр, отвечающий за некоторую точность вычисления. В
простом случае можно его не задавать, и функция сама определит
подходящее значение этого параметра.
a = np.array([[1, 2, 3], [1, 1, 1], [2, 2, 2]]) r = np.linalg.matrix_rank(a)
print ("Матрица:n", a) print ("Ранг матрицы:", r)
Матрица: [[1 2 3] [1 1 1] [2 2 2]] Ранг матрицы: 2
С помощью вычисления ранга матрицы можно проверять линейную
независимость системы векторов.
Допустим, у нас есть несколько векторов. Составим из них матрицу, где
наши векторы будут являться строками. Понятно, что векторы линейно
независимы тогда и только тогда, когда ранг полученной матрицы совпадает
с числом векторов. Приведем пример:
a = np.array([1, 2, 3]) b = np.array([1, 1, 1]) c = np.array([2, 3, 5]) m = np.array([a, b, c])
print (np.linalg.matrix_rank(m) == m.shape[0])
True
11. Системы линейных уравнений
Напоминание теории. Системой линейных алгебраических уравнений
называется система вида Ax = b, где
A ∈ ℝn×m, x ∈ ℝm×1, b ∈ ℝn×1.
В случае квадратной невырожденной матрицы A решение системы
единственно.
В NumPy решение такой системы можно найти с помощью функции
numpy.linalg.solve(a, b), где первый аргумент — матрица
A, второй — столбец b.
a = np.array([[3, 1], [1, 2]]) b = np.array([9, 8]) x = np.linalg.solve(a, b)
print ("Матрица A:n", a) print ("Вектор b:n", b) print ("Решение системы:n", x)
Матрица A: [[3 1] [1 2]] Вектор b: [9 8] Решение системы: [2. 3.]
Убедимся, что вектор x действительно является решением системы:
print (a.dot(x))
[9. 8.]
Бывают случаи, когда решение системы не существует. Но хотелось бы все
равно “решить” такую систему. Логичным кажется искать такой вектор
x, который минимизирует выражение
‖Ax − b‖2 — так мы приблизим выражение
Ax к b.
В NumPy такое псевдорешение можно искать с помощью функции
numpy.linalg.lstsq(a, b, …), где первые два аргумента такие
же, как и для функции numpy.linalg.solve(). Помимо решения
функция возвращает еще три значения, которые нам сейчас не понадобятся.
a = np.array([[0, 1], [1, 1], [2, 1], [3, 1]]) b = np.array([-1, 0.2, 0.9, 2.1]) x, res, r, s = np.linalg.lstsq(a, b, rcond=None)
print ("Матрица A:n", a) print ("Вектор b:n", b) print ("Псевдорешение системы:n", x)
Матрица A: [[0 1] [1 1] [2 1] [3 1]] Вектор b: [-1. 0.2 0.9 2.1] Псевдорешение системы: [ 1. -0.95]
12. Обращение матриц
Напоминание теории. Для квадратных невырожденных матриц определено
понятие обратной матрицы.
Пусть A — квадратная невырожденная матрица. Матрица
A − 1 называется обратной матрицей к A, если
AA − 1 = A − 1A = I,
где I — единичная матрица.
В NumPy обратные матрицы вычисляются с помощью функции
numpy.linalg.inv(a), где a — исходная матрица.
a = np.array([[1, 2, 1], [1, 1, 4], [2, 3, 6]], dtype=np.float32) b = np.linalg.inv(a)
print ("Матрица A:n", a) print ("Обратная матрица к A:n", b) print ("Произведение A на обратную должна быть единичной:n", a.dot(b))
Матрица A: [[1. 2. 1.] [1. 1. 4.] [2. 3. 6.]] Обратная матрица к A: [[ 6. 9. -7.] [-2. -4. 3.] [-1. -1. 1.]] Произведение A на обратную должна быть единичной: [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]
13. Собственные числа и собственные вектора матрицы
Напоминание теории. Для квадратных матриц определены понятия
собственного вектора и собственного числа.
Пусть A — квадратная матрица и
A ∈ ℝn×n. Собственным вектором матрицы
A называется такой ненулевой вектор
x ∈ ℝn, что для некоторого
λ ∈ ℝ выполняется равенство
Ax = λx. При этом λ называется
собственным числом матрицы A. Собственные числа и
собственные векторы матрицы играют важную роль в теории линейной алгебры
и ее практических приложениях.
В NumPy собственные числа и собственные векторы матрицы вычисляются
с помощью функции numpy.linalg.eig(a), где a — исходная
матрица. В качестве результата эта функция выдает одномерный массив
w собственных чисел и двумерный массив v, в котором по
столбцам записаны собственные вектора, так что вектор v[:, i]
соотвествует собственному числу w[i].
a = np.array([[-1, -6], [2, 6]]) w, v = np.linalg.eig(a)
print ("Матрица A:n", a) print ("Собственные числа:n", w) print ("Собственные векторы:n", v)
Матрица A: [[-1 -6] [ 2 6]] Собственные числа: [2. 3.] Собственные векторы: [[-0.89442719 0.83205029] [ 0.4472136 -0.5547002 ]]
Обратите внимание: у вещественной матрицы собственные значения или
собственные векторы могут быть комплексными.
14. Расстояния между векторами
Вспомним некоторые нормы, которые можно ввести в пространстве
ℝn, и рассмотрим, с помощью каких библиотек и
функций их можно вычислять в NumPy.
p-норма
p-норма (норма Гёльдера) для вектора
x = (x1, …, xn) ∈ ℝn вычисляется по
формуле:
‖x‖p = (n∑i = 1|xi|p)1 ⁄ p, p ≥ 1.
В частных случаях при: * p = 1 получаем ℓ1 норму
* p = 2 получаем ℓ2 норму
Далее нам понабится модуль numpy.linalg, реализующий некоторые
приложения линейной алгебры. Для вычисления различных норм мы используем
функцию numpy.linalg.norm(x, ord=None, …), где x —
исходный вектор, ord — параметр, определяющий норму (мы
рассмотрим два варианта его значений — 1 и 2). Импортируем эту функцию:
from numpy.linalg import norm
ℓ1 норма
ℓ1 норма (также известная как манхэттенское
расстояние)
для вектора x = (x1, …, xn) ∈ ℝn
вычисляется по формуле:
‖x‖1 = n∑i = 1|xi|.
Ей в функции numpy.linalg.norm(x, ord=None, …) соответствует
параметр ord=1.
a = np.array([1, 2, -3]) print('Вектор a:', a)
Вектор a: [ 1 2 -3]
print('L1 норма вектора a:n', norm(a, ord=1))
L1 норма вектора a: 6.0
ℓ2 норма
ℓ2 норма (также известная как евклидова норма) для вектора
x = (x1, …, xn) ∈ ℝn вычисляется по
формуле:
‖x‖2 = √(n∑i = 1(xi)2).
Ей в функции numpy.linalg.norm(x, ord=None, …) соответствует
параметр ord=2.
print ('L2 норма вектора a:n', norm(a, ord=2))
L2 норма вектора a: 3.7416573867739413
Более подробно о том, какие еще нормы (в том числе матричные) можно
вычислить, см.
документацию.
15. Расстояния между векторами
Для двух векторов x = (x1, …, xn) ∈ ℝn и
y = (y1, …, yn) ∈ ℝn ℓ1 и
ℓ2 раccтояния вычисляются по следующим формулам
соответственно:
ρ1(x, y) = ‖x − y‖1 = n∑i = 1|xi − yi|
ρ2(x, y) = ‖x − y‖2 = √(n∑i = 1(xi − yi)2).
a = np.array([1, 2, -3]) b = np.array([-4, 3, 8]) print ('Вектор a:', a) print ('Вектор b:', b)
Вектор a: [ 1 2 -3] Вектор b: [-4 3 8]
print ('L1 расстояние между векторами a и b:n', norm(a - b, ord=1)) print ('L2 расстояние между векторами a и b:n', norm(a - b, ord=2))
L1 расстояние между векторами a и b: 17.0 L2 расстояние между векторами a и b: 12.12435565298214
16. Скалярное произведение и угол между векторами
a = np.array([0, 5, -1]) b = np.array([-4, 9, 3]) print ('Вектор a:', a) print ('Вектор b:', b)
Вектор a: [ 0 5 -1] Вектор b: [-4 9 3]
Скалярное произведение в пространстве ℝn для двух
векторов x = (x1, …, xn) и
y = (y1, …, yn) определяется как:
⟨x, y⟩ = n∑i = 1xiyi.
Длиной вектора x = (x1, …, xn) ∈ ℝn
называется квадратный корень из скалярного произведения, то есть длина
равна евклидовой норме вектора:
|x| = √(⟨x, x⟩) = √(n∑i = 1x2i) = ‖x‖2.
Теперь, когда мы знаем расстояние между двумя ненулевыми векторами и их
длины, мы можем вычислить угол между ними через скалярное произведение:
⟨x, y⟩ = |x||y|cos(α) ⟹ cos(α) = (⟨x, y⟩)/(|x||y|),
где α ∈ [0, π] — угол между векторами x и
y.
cos_angle = np.dot(a, b) / norm(a) / norm(b) print ('Косинус угла между a и b:', cos_angle) print ('Сам угол:', np.arccos(cos_angle))
Косинус угла между a и b: 0.8000362836474323 Сам угол: 0.6434406336093618
17. Комплексные числа в питоне
Напоминание теории. Комплексными числами называются числа вида
x + iy, где x и y — вещественные числа, а
i — мнимая единица (величина, для которой выполняется равенство
i2 = − 1). Множество всех комплексных чисел обозначается
буквой ℂ (подробнее про комплексные числа см.
википедию).
В питоне комплескные числа можно задать следующим образом (j
обозначает мнимую единицу):
a = 3 + 2j b = 1j
print ("Комплексное число a:n", a) print ("Комплексное число b:n", b)
Комплексное число a: (3+2j) Комплексное число b: 1j
С комплексными числами в питоне можно производить базовые арифметические
операции так же, как и с вещественными числами:
c = a * a d = a / (4 - 5j)
print ("Комплексное число c:n", c) print ("Комплексное число d:n", d)
Комплексное число c: (5+12j) Комплексное число d: (0.0487804878048781+0.5609756097560976j)
Задания: (Блок 2)
Задание 3:
Рассмотрим сложную математическую функцию на отрезке [1, 15]:
f(x) = sin(x / 5) * exp(x / 10) + 5 * exp(-x / 2)
Она может описывать, например, зависимость оценок, которые выставляют
определенному сорту вина эксперты, в зависимости от возраста этого вина.
Мы хотим приблизить сложную зависимость с помощью функции из
определенного семейства. В этом задании мы будем приближать указанную
функцию с помощью многочленов.
Как известно, многочлен степени n (то есть w0 +
w1x + w2x2 + … + wnxn)
однозначно определяется любыми n + 1 различными точками, через которые
он проходит. Это значит, что его коэффициенты w0, … wn
можно определить из следующей системы линейных уравнений:
где через x1, …, xn, xn + 1 обозначены точки, через которые
проходит многочлен, а через f(x1), …, f(xn), f(xn + 1) —
значения, которые он должен принимать в этих точках.
Воспользуемся описанным свойством, и будем находить приближение функции
многочленом, решая систему линейных уравнений.
- Сформируйте систему линейных уравнений (то есть задайте матрицу
коэффициентов A и свободный вектор b) для многочлена первой степени,
который должен совпадать с функцией f в точках 1 и 15. Решите данную
систему с помощью функции scipy.linalg.solve. Нарисуйте функцию f и
полученный многочлен. Хорошо ли он приближает исходную функцию? - Повторите те же шаги для многочлена второй степени, который совпадает
с функцией f в точках 1, 8 и 15. Улучшилось ли качество
аппроксимации? - Повторите те же шаги для многочлена третьей степени, который
совпадает с функцией f в точках 1, 4, 10 и 15. Хорошо ли он
аппроксимирует функцию? Коэффициенты данного многочлена (четыре числа
в следующем порядке: w_0, w_1, w_2, w_3) являются ответом на задачу.
Округлять коэффициенты не обязательно, но при желании можете
произвести округление до второго знака (т.е. до числа вида 0.42)
NumPy: матрицы и операции над ними
| Date: | 2022-02-08 09:00 |
|---|---|
| summary: | Библиотека NumPy |
| Status: | published |
Contents
NumPy: матрицы и операции над ними- 1. Создание матриц
- 2. Индексирование
- 3. Векторы, вектор-строки и вектор-столбцы
- 4. Datatypes
- 5. Математические операции
- 6. Умножение матриц и столбцов
- 7. Объединение массивов
- Задания: (Блок 1)
- Задание 1:
- Задание 2:
- Задания: (Блок 1)
- 8. Транспонирование матриц
- 9. Определитель матрицы
- 10. Ранг матрицы
- 11. Системы линейных уравнений
- 12. Обращение матриц
- 13. Собственные числа и собственные вектора матрицы
- 14. Расстояния между векторами
- p-норма
- ell_{1} норма
- ell_{2} норма
- 15. Расстояния между векторами
- 16. Скалярное произведение и угол между векторами
- 17. Комплексные числа в питоне
- Задания: (Блок 2)
- Задание 3:
- Задания: (Блок 2)
NumPy: матрицы и операции над ними
Ссылка на jupyter notebook
В этом ноутбуке из сторонних библиотек нам понадобится только NumPy.
Для удобства импортируем ее под более коротким именем:
1. Создание матриц
Приведем несколько способов создания матриц в NumPy.
Самый простой способ — с помощью функции
numpy.array(list, dtype=None, …).
В качестве первого аргумента ей надо передать итерируемый объект,
элементами которого являются другие итерируемые объекты одинаковой длины
и содержащие данные одинакового типа.
Второй аргумент является опциональным и определяет тип данных матрицы.
Его можно не задавать, тогда тип данных будет определен из типа
элементов первого аргумента. При задании этого параметра будет
произведена попытка приведения типов.
Например, матрицу из списка списков целых чисел можно создать следующим
образом:
a = np.array([1, 2, 3]) # Создаем одномерный массив print(type(a)) # Prints "<class 'numpy.ndarray'>" print(a.shape) # Prints "(3,)" - кортеж с размерностями print(a[0], a[1], a[2]) # Prints "1 2 3" a[0] = 5 # Изменяем значение элемента массива print(a) # Prints "[5, 2, 3]" b = np.array([[1,2,3],[4,5,6]]) # Создаем двухмерный массив print(b.shape) # Prints "(2, 3)" print(b[0, 0], b[0, 1], b[1, 0]) # Prints "1 2 4" print(np.arange(1, 5)) #Cоздает вектор с эелементами от 1 до 4
<class 'numpy.ndarray'> (3,) 1 2 3 [5 2 3] (2, 3) 1 2 4 [1 2 3 4]
matrix = np.array([[1, 2, 3], [2, 5, 6], [6, 7, 4]]) print ("Матрица:n", matrix)
Матрица: [[1 2 3] [2 5 6] [6 7 4]]
Второй способ создания — с помощью встроенных функций
numpy.eye(N, M=None, …), numpy.zeros(shape, …),
numpy.ones(shape, …).
Первая функция создает единичную матрицу размера N times M;
если M не задан, то M = N.
Вторая и третья функции создают матрицы, состоящие целиком из нулей или
единиц соответственно. В качестве первого аргумента необходимо задать
размерность массива — кортеж целых чисел. В двумерном случае это набор
из двух чисел: количество строк и столбцов матрицы.
Примеры:
b = np.eye(5) print ("Единичная матрица:n", b)
Единичная матрица: [[1. 0. 0. 0. 0.] [0. 1. 0. 0. 0.] [0. 0. 1. 0. 0.] [0. 0. 0. 1. 0.] [0. 0. 0. 0. 1.]]
c = np.ones((7, 5)) print ("Матрица, состоящая из одних единиц:n", c)
Матрица, состоящая из одних единиц: [[1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.] [1. 1. 1. 1. 1.]]
d = np.full((2,2), 7) # Создает матрицу (1, 2) заполненую заданным значением print(d) # Prints "[[ 7. 7.] # [ 7. 7.]]" e = np.random.random((2,2)) # Создает еденичную матрицу (2, 2) заполненую случаными числами (0, 1) print(e) # Might print "[[ 0.91940167 0.08143941] # [ 0.68744134 0.87236687]]"
[[7 7] [7 7]] [[0.25744383 0.48056466] [0.13767881 0.40578168]]
Обратите внимание: размерность массива задается не двумя аргументами
функции, а одним — кортежем!
Вот так — np.ones(7, 5) — создать массив не получится, так как
функции в качестве параметра shape передается 7, а не кортеж
(7, 5).
И, наконец, третий способ — с помощью функции
numpy.arange([start, ]stop, [step, ], …), которая создает
одномерный массив последовательных чисел из промежутка
[start, stop) с заданным шагом step, и метода
array.reshape(shape).
Параметр shape, как и в предыдущем примере, задает размерность
матрицы (кортеж чисел). Логика работы метода ясна из следующего примера:
v = np.arange(0, 24, 2) print ("Вектор-столбец:n", v)
Вектор-столбец: [ 0 2 4 6 8 10 12 14 16 18 20 22]
d = v.reshape((3, 4)) print ("Матрица:n", d)
Матрица: [[ 0 2 4 6] [ 8 10 12 14] [16 18 20 22]]
Более подробно о том, как создавать массивы в NumPy, см.
документацию.
2. Индексирование
Для получения элементов матрицы можно использовать несколько способов.
Рассмотрим самые простые из них.
Для удобства напомним, как выглядит матрица d:
Матрица: [[ 0 2 4 6] [ 8 10 12 14] [16 18 20 22]]
Элемент на пересечении строки i и столбца j можно
получить с помощью выражения array[i, j].
Обратите внимание: строки и столбцы нумеруются с нуля!
print ("Второй элемент третьей строки матрицы:", d[2, 1])
Второй элемент третьей строки матрицы: 18
Из матрицы можно получать целые строки или столбцы с помощью выражений
array[i, :] или array[:, j] соответственно:
print ("Вторая строка матрицы d:n", d[1, :]) print ("Четвертый столбец матрицы d:n", d[:, 3])
Вторая строка матрицы d: [ 8 10 12 14] Четвертый столбец матрицы d: [ 6 14 22]
Еще один способ получения элементов — с помощью выражения
array[list1, list2], где list1, list2 —
некоторые списки целых чисел. При такой адресации одновременно
просматриваются оба списка и возвращаются элементы матрицы с
соответствующими координатами. Следующий пример более понятно объясняет
механизм работы такого индексирования:
print ("Элементы матрицы d с координатами (1, 2) и (0, 3):n", d[[1, 0], [2, 3]])
Элементы матрицы d с координатами (1, 2) и (0, 3): [12 6]
# Slicing # Создадим матрицу (3, 4) # [[ 1 2 3 4] # [ 5 6 7 8] # [ 9 10 11 12]] a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) # Используя слайсинг, созадим матрицу b из элементов матрицы а # будем использовать 0 и 1 строку, а так же 1 и 2 столебц # [[2 3] # [6 7]] b = a[:2, 1:3] print(b) # ОБРАТИТЕ ВНИМАНИЕ НА ИЗМЕНЕНИЕ ИСХОДОЙ МАТРИЦЫ print(a[0, 1]) # Prints "2" b[0, 0] = 77 # b[0, 0] is the same piece of data as a[0, 1] print(a[0, 1]) # Prints "77"
[[2 3] [6 7]] 2 77
# Integer array indexing a = np.array([[1,2], [3, 4], [5, 6]]) print(a) print() # Пример Integer array indexing # В результате получится массив размерности (3,) # Обратите внимание, что до запятой идут индексы строк, после - столбцов print(a[[0, 1, 2], [0, 1, 0]]) # Prints "[1 4 5]" print() # По-другому пример можно записать так print(np.array([a[0, 0], a[1, 1], a[2, 0]])) # Prints "[1 4 5]"
[[1 2] [3 4] [5 6]] [1 4 5] [1 4 5]
Примеры использования слайсинга:
# Создадим новый маассив, из которого будем выбирать эллементы a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]]) print(a) # prints "array([[ 1, 2, 3], # [ 4, 5, 6], # [ 7, 8, 9], # [10, 11, 12]])" # Создадим массив индексов b = np.array([0, 2, 0, 1]) # Выберем из каждой строки элемент с индексом из b (индекс столбца берется из b) print(a[np.arange(4), b]) # Prints "[ 1 6 7 11]" print() # Добавим к этим элементам 10 a[np.arange(4), b] += 10 print(a) # prints "array([[11, 2, 3], # [ 4, 5, 16], # [17, 8, 9], # [10, 21, 12]])
[[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]] [ 1 6 7 11] [[11 2 3] [ 4 5 16] [17 8 9] [10 21 12]]
a = np.array([[1,2], [3, 4], [5, 6]]) bool_idx = (a > 2) # Найдем эллементы матрицы a, которые больше 2 # В результате получим матрицу b, такой же размерности, как и a print(bool_idx) # Prints "[[False False] print() # [ True True] # [ True True]]" # Воспользуемся полученным массивом для создания нового массива, ранга 1 print(a[bool_idx]) # Prints "[3 4 5 6]" # Аналогично print(a[a > 2]) # Prints "[3 4 5 6]"
[[False False] [ True True] [ True True]] [3 4 5 6] [3 4 5 6]
#Помните, что вы можете пользоваться сразу несколькими типами индексирования a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) row_r1 = a[1, :] row_r2 = a[1:2, :] print(row_r1, row_r1.shape) # Prints "[5 6 7 8] (4,)" print(row_r2, row_r2.shape) # Prints "[[5 6 7 8]] (1, 4)"
[5 6 7 8] (4,) [[5 6 7 8]] (1, 4)
Более подробно о различных способах индексирования в массивах см.
документацию.
3. Векторы, вектор-строки и вектор-столбцы
Следующие два способа задания массива кажутся одинаковыми:
a = np.array([1, 2, 3]) b = np.array([[1], [2], [3]])
Однако, на самом деле, это задание одномерного массива (то есть
вектора) и двумерного массива:
print ("Вектор:n", a) print ("Его размерность:n", a.shape) print ("Двумерный массив:n", b) print ("Его размерность:n", b.shape)
Вектор: [1 2 3] Его размерность: (3,) Двумерный массив: [[1] [2] [3]] Его размерность: (3, 1)
Обратите внимание: вектор (одномерный массив) и вектор-столбец
или вектор-строка (двумерные массивы) являются различными объектами в
NumPy, хотя математически задают один и тот же объект. В случае
одномерного массива кортеж shape состоит из одного числа и имеет
вид (n,), где n — длина вектора. В случае двумерных
векторов в shape присутствует еще одна размерность, равная
единице.
В большинстве случаев неважно, какое представление использовать, потому
что часто срабатывает приведение типов. Но некоторые операции не
работают для одномерных массивов. Например, транспонирование (о нем
пойдет речь ниже):
print ("Вектор не изменился:n", a) print ("Его размерность также не изменилась:n", a.shape) print ("Транспонированный двумерный массив:n", b) print ("Его размерность изменилась:n", b.shape)
Вектор не изменился: [1 2 3] Его размерность также не изменилась: (3,) Транспонированный двумерный массив: [[1 2 3]] Его размерность изменилась: (1, 3)
4. Datatypes
Все элементы в массиве numpy принадлежат одному типу. В этом плане
массивы ближе к C, чем к привычным вам листам питона. Numpy имеет
множество встренных типов, подходящих для решения большинства задач.
x = np.array([1, 2]) # Автоматический выбор типа print(x.dtype) # Prints "int64" x = np.array([1.0, 2.0]) # Автоматический выбор типа print(x.dtype) # Prints "float64" x = np.array([1, 2], dtype=np.int64) # Принудительное выставление типа print(x.dtype) # Prints "int64"
int32 float64 int64
5. Математические операции
К массивам (матрицам) можно применять известные вам математические
операции. Следут понимать, что при этом у элементов должны быть схожие
размерности. Поведение в случае не совпадения размерностей хорошо
описанно в документации numpy.
x = np.array([[1,2],[3,4]], dtype=np.float64) y = np.array([[5,6],[7,8]], dtype=np.float64) arr = np.array([1, 2])
# Сложение происходит поэлеметно # [[ 6.0 8.0] # [10.0 12.0]] print(x + y) print() print(np.add(x, y)) print('С числом') print(x + 1) print('C массивом другой размерности') print(x + arr)
[[ 6. 8.] [10. 12.]] [[ 6. 8.] [10. 12.]] С числом [[2. 3.] [4. 5.]] C массивом другой размерности [[2. 4.] [4. 6.]]
# Вычитание print(x - y) print(np.subtract(x, y))
[[-4. -4.] [-4. -4.]] [[-4. -4.] [-4. -4.]]
# Деление # [[ 0.2 0.33333333] # [ 0.42857143 0.5 ]] print(x / y) print(np.divide(x, y))
[[0.2 0.33333333] [0.42857143 0.5 ]] [[0.2 0.33333333] [0.42857143 0.5 ]]
# Другие функции # [[ 1. 1.41421356] # [ 1.73205081 2. ]] print(np.sqrt(x))
[[1. 1.41421356] [1.73205081 2. ]]
6. Умножение матриц и столбцов
Напоминание теории. Операция умножения определена для двух
матриц, таких что число столбцов первой равно числу строк второй.
Пусть матрицы A и B таковы, что
A in mathbb{R}^{n times k} и
B in mathbb{R}^{k times m}. Произведением матриц
A и B называется матрица C, такая что
c_{ij} = sum_{r=1}^{k} a_{ir}b_{rj}, где c_{ij} —
элемент матрицы C, стоящий на пересечении строки с номером
i и столбца с номером j.
В NumPy произведение матриц вычисляется с помощью функции
numpy.dot(a, b, …) или с помощью метода
array1.dot(array2), где array1 и array2 —
перемножаемые матрицы.
a = np.array([[1, 0], [0, 1]]) b = np.array([[4, 1], [2, 2]]) r1 = np.dot(a, b) r2 = a.dot(b)
print ("Матрица A:n", a) print ("Матрица B:n", b) print ("Результат умножения функцией:n", r1) print ("Результат умножения методом:n", r2)
Матрица A: [[1 0] [0 1]] Матрица B: [[4 1] [2 2]] Результат умножения функцией: [[4 1] [2 2]] Результат умножения методом: [[4 1] [2 2]]
Матрицы в NumPy можно умножать и на векторы:
c = np.array([1, 2]) r3 = b.dot(c)
print ("Матрица:n", b) print ("Вектор:n", c) print ("Результат умножения:n", r3)
Матрица: [[4 1] [2 2]] Вектор: [1 2] Результат умножения: [6 6]
Обратите внимание: операция * производит над матрицами
покоординатное умножение, а не матричное!
print ("Матрица A:n", a) print ("Матрица B:n", b) print ("Результат покоординатного умножения через операцию умножения:n", r)
Матрица A: [[1 0] [0 1]] Матрица B: [[4 1] [2 2]] Результат покоординатного умножения через операцию умножения: [[4 0] [0 2]]
Более подробно о матричном умножении в NumPy см.
документацию.
7. Объединение массивов
Массивы можно Объединенять. Есть горизонтальное и вертикальное
объединение.
a = np.floor(10*np.random.random((2,2))) b = np.floor(10*np.random.random((2,2))) print(a) print(b) print() print(np.vstack((a,b))) print() print(np.hstack((a,b)))
[[4. 0.] [1. 4.]] [[9. 7.] [2. 6.]] [[4. 0.] [1. 4.] [9. 7.] [2. 6.]] [[4. 0. 9. 7.] [1. 4. 2. 6.]]
Массивы можно переформировать при помощи метода, который задает новый
многомерный массив. Следуя следующему примеру, мы переформатируем
одномерный массив из десяти элементов во двумерный массив, состоящий из
пяти строк и двух столбцов:
a = np.array(range(10), float) print(a) print() # Превратим в матрицу a = a.reshape((5, 2)) print(a) print() # Вернем обратно print(a.flatten()) # Другой вариант print(a.reshape((-1))) # Превратим в марицу (9, 1) print(a.reshape((-1, 1))) # Превратим в марицу (1, 9) print(a.reshape((1, -1)))
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] [[0. 1.] [2. 3.] [4. 5.] [6. 7.] [8. 9.]] [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] [[0.] [1.] [2.] [3.] [4.] [5.] [6.] [7.] [8.] [9.]] [[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]]
Задания: (Блок 1)
Задание 1:
Решите без использования циклов средставми NumPy (каждый пункт решается
в 1-2 строчки)
- Создайте вектор с элементами от 12 до 42
- Создайте вектор из нулей длины 12, но его пятый елемент должен быть равен 1
- Создайте матрицу (3, 3), заполненую от 0 до 8
- Найдите все положительные числа в np.array([1,2,0,0,4,0])
- Умножьте матрицу размерности (5, 3) на (3, 2)
- Создайте матрицу (10, 10) так, чтобы на границе были 0, а внтури 1
- Создайте рандомный вектор и отсортируйте его
- Каков эквивалент функции enumerate для numpy массивов?
- *Создайте рандомный вектор и выполните нормализацию столбцов (из каждого столбца вычесть среднее этого столбца, из каждого столбца вычесть sd этого столбца)
- *Для заданного числа найдите ближайший к нему элемент в векторе
- *Найдите N наибольших значений в векторе
Задание 2:
Напишите полностью векторизованный вариант
Дан трёхмерный массив, содержащий изображение, размера (height, width,
numChannels), а также вектор длины numChannels. Сложить каналы
изображения с указанными весами, и вернуть результат в виде матрицы
размера (height, width). Считать реальное изображение можно при помощи
функции scipy.misc.imread (если изображение не в формате png,
установите пакет pillow: conda install pillow). Преобразуйте
цветное изображение в оттенки серого, использовав коэффициенты
np.array([0.299, 0.587, 0.114]).
8. Транспонирование матриц
Напоминание теории. Транспонированной матрицей A^{T}
называется матрица, полученная из исходной матрицы A заменой
строк на столбцы. Формально: элементы матрицы A^{T} определяются
как a^{T}_{ij} = a_{ji}, где a^{T}_{ij} — элемент
матрицы A^{T}, стоящий на пересечении строки с номером i
и столбца с номером j.
В NumPy транспонированная матрица вычисляется с помощью функции
numpy.transpose() или с помощью метода array.T, где
array — нужный двумерный массив.
a = np.array([[1, 2], [3, 4]]) b = np.transpose(a) c = a.T
print ("Матрица:n", a) print ("Транспонирование функцией:n", b) print ("Транспонирование методом:n", c)
Матрица: [[1 2] [3 4]] Транспонирование функцией: [[1 3] [2 4]] Транспонирование методом: [[1 3] [2 4]]
См. более подробно о
numpy.transpose()
и
array.T
в NumPy.
В следующих разделах активно используется модуль numpy.linalg,
реализующий некоторые приложения линейной алгебры. Более подробно о
функциях, описанных ниже, и различных других функциях этого модуля можно
посмотреть в его
документации.
9. Определитель матрицы
Напоминание теории. Для квадратных матриц существует понятие
определителя.
Пусть A — квадратная матрица. Определителем (или
детерминантом) матрицы A in mathbb{R}^{n times n} назовем
число
det A = sum_{alpha_{1}, alpha_{2}, dots, alpha_{n}} (-1)^{N(alpha_{1}, alpha_{2}, dots, alpha_{n})} cdot a_{alpha_{1} 1} cdot cdot cdot a_{alpha_{n} n},
где alpha_{1}, alpha_{2}, dots, alpha_{n} — перестановка
чисел от 1 до n,
N(alpha_{1}, alpha_{2}, dots, alpha_{n}) — число инверсий в
перестановке, суммирование ведется по всем возможным перестановкам длины
n.
Не стоит расстраиваться, если это определение понятно не до конца — в
дальнейшем в таком виде оно не понадобится.
Например, для матрицы размера 2 times 2 получается:
det left( begin{array}{cc} a_{11} & a_{12} \ a_{21} & a_{22} end{array} right) = a_{11} a_{22} - a_{12} a_{21}
Вычисление определителя матрицы по определению требует порядка
n! операций, поэтому разработаны методы, которые позволяют
вычислять его быстро и эффективно.
В NumPy определитель матрицы вычисляется с помощью функции
numpy.linalg.det(a), где a — исходная матрица.
a = np.array([[1, 2, 1], [1, 1, 4], [2, 3, 6]], dtype=np.float32) det = np.linalg.det(a)
print ("Матрица:n", a) print ("Определитель:n", det)
Матрица: [[1. 2. 1.] [1. 1. 4.] [2. 3. 6.]] Определитель: -1.0
Рассмотрим одно интересное свойство определителя. Пусть у нас есть
параллелограмм с углами в точках
(0, 0), (c,d), (a+c, b+d), (a, b) (углы даны в порядке обхода по
часовой стрелке). Тогда площадь этого параллелограмма можно вычислить
как модуль определителя матрицы
left( begin{array}{cc} a & c \ b & d end{array} right).
Похожим образом можно выразить и объем параллелепипеда через
определитель матрицы размера 3 times 3.
10. Ранг матрицы
Напоминание теории. Рангом матрицы A называется
максимальное число линейно независимых строк (столбцов) этой матрицы.
В NumPy ранг матрицы вычисляется с помощью функции
numpy.linalg.matrix_rank(M, tol=None), где M — матрица,
tol — параметр, отвечающий за некоторую точность вычисления. В
простом случае можно его не задавать, и функция сама определит
подходящее значение этого параметра.
a = np.array([[1, 2, 3], [1, 1, 1], [2, 2, 2]]) r = np.linalg.matrix_rank(a)
print ("Матрица:n", a) print ("Ранг матрицы:", r)
Матрица: [[1 2 3] [1 1 1] [2 2 2]] Ранг матрицы: 2
С помощью вычисления ранга матрицы можно проверять линейную
независимость системы векторов.
Допустим, у нас есть несколько векторов. Составим из них матрицу, где
наши векторы будут являться строками. Понятно, что векторы линейно
независимы тогда и только тогда, когда ранг полученной матрицы совпадает
с числом векторов. Приведем пример:
a = np.array([1, 2, 3]) b = np.array([1, 1, 1]) c = np.array([2, 3, 5]) m = np.array([a, b, c])
print (np.linalg.matrix_rank(m) == m.shape[0])
True
11. Системы линейных уравнений
Напоминание теории. Системой линейных алгебраических уравнений
называется система вида Ax = b, где
A in mathbb{R}^{n times m}, x in mathbb{R}^{m times 1}, b in mathbb{R}^{n times 1}.
В случае квадратной невырожденной матрицы A решение системы
единственно.
В NumPy решение такой системы можно найти с помощью функции
numpy.linalg.solve(a, b), где первый аргумент — матрица
A, второй — столбец b.
a = np.array([[3, 1], [1, 2]]) b = np.array([9, 8]) x = np.linalg.solve(a, b)
print ("Матрица A:n", a) print ("Вектор b:n", b) print ("Решение системы:n", x)
Матрица A: [[3 1] [1 2]] Вектор b: [9 8] Решение системы: [2. 3.]
Убедимся, что вектор x действительно является решением системы:
[9. 8.]
Бывают случаи, когда решение системы не существует. Но хотелось бы все
равно “решить” такую систему. Логичным кажется искать такой вектор
x, который минимизирует выражение
leftVert Ax – brightVert^{2} — так мы приблизим выражение
Ax к b.
В NumPy такое псевдорешение можно искать с помощью функции
numpy.linalg.lstsq(a, b, …), где первые два аргумента такие
же, как и для функции numpy.linalg.solve(). Помимо решения
функция возвращает еще три значения, которые нам сейчас не понадобятся.
a = np.array([[0, 1], [1, 1], [2, 1], [3, 1]]) b = np.array([-1, 0.2, 0.9, 2.1]) x, res, r, s = np.linalg.lstsq(a, b, rcond=None)
print ("Матрица A:n", a) print ("Вектор b:n", b) print ("Псевдорешение системы:n", x)
Матрица A: [[0 1] [1 1] [2 1] [3 1]] Вектор b: [-1. 0.2 0.9 2.1] Псевдорешение системы: [ 1. -0.95]
12. Обращение матриц
Напоминание теории. Для квадратных невырожденных матриц определено
понятие обратной матрицы.
Пусть A — квадратная невырожденная матрица. Матрица
A^{-1} называется обратной матрицей к A, если
AA^{-1} = A^{-1}A = I,
где I — единичная матрица.
В NumPy обратные матрицы вычисляются с помощью функции
numpy.linalg.inv(a), где a — исходная матрица.
a = np.array([[1, 2, 1], [1, 1, 4], [2, 3, 6]], dtype=np.float32) b = np.linalg.inv(a)
print ("Матрица A:n", a) print ("Обратная матрица к A:n", b) print ("Произведение A на обратную должна быть единичной:n", a.dot(b))
Матрица A: [[1. 2. 1.] [1. 1. 4.] [2. 3. 6.]] Обратная матрица к A: [[ 6. 9. -7.] [-2. -4. 3.] [-1. -1. 1.]] Произведение A на обратную должна быть единичной: [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]
13. Собственные числа и собственные вектора матрицы
Напоминание теории. Для квадратных матриц определены понятия
собственного вектора и собственного числа.
Пусть A — квадратная матрица и
A in mathbb{R}^{n times n}. Собственным вектором матрицы
A называется такой ненулевой вектор
x in mathbb{R}^{n}, что для некоторого
lambda in mathbb{R} выполняется равенство
Ax = lambda x. При этом lambda называется
собственным числом матрицы A. Собственные числа и
собственные векторы матрицы играют важную роль в теории линейной алгебры
и ее практических приложениях.
В NumPy собственные числа и собственные векторы матрицы вычисляются
с помощью функции numpy.linalg.eig(a), где a — исходная
матрица. В качестве результата эта функция выдает одномерный массив
w собственных чисел и двумерный массив v, в котором по
столбцам записаны собственные вектора, так что вектор v[:, i]
соотвествует собственному числу w[i].
a = np.array([[-1, -6], [2, 6]]) w, v = np.linalg.eig(a)
print ("Матрица A:n", a) print ("Собственные числа:n", w) print ("Собственные векторы:n", v)
Матрица A: [[-1 -6] [ 2 6]] Собственные числа: [2. 3.] Собственные векторы: [[-0.89442719 0.83205029] [ 0.4472136 -0.5547002 ]]
Обратите внимание: у вещественной матрицы собственные значения или
собственные векторы могут быть комплексными.
14. Расстояния между векторами
Вспомним некоторые нормы, которые можно ввести в пространстве
mathbb{R}^{n}, и рассмотрим, с помощью каких библиотек и
функций их можно вычислять в NumPy.
p-норма
p-норма (норма Гёльдера) для вектора
x = (x_{1}, dots, x_{n}) in mathbb{R}^{n} вычисляется по
формуле:
leftVert x rightVert_{p} = left( sum_{i=1}^n left| x_{i} right|^{p} right)^{1 / p},~p geq 1.
В частных случаях при: * p = 1 получаем ell_{1} норму
* p = 2 получаем ell_{2} норму
Далее нам понабится модуль numpy.linalg, реализующий некоторые
приложения линейной алгебры. Для вычисления различных норм мы используем
функцию numpy.linalg.norm(x, ord=None, …), где x —
исходный вектор, ord — параметр, определяющий норму (мы
рассмотрим два варианта его значений — 1 и 2). Импортируем эту функцию:
from numpy.linalg import norm
ell_{1} норма
ell_{1} норма (также известная как манхэттенское
расстояние)
для вектора x = (x_{1}, dots, x_{n}) in mathbb{R}^{n}
вычисляется по формуле:
leftVert x rightVert_{1} = sum_{i=1}^n left| x_{i} right|.
Ей в функции numpy.linalg.norm(x, ord=None, …) соответствует
параметр ord=1.
a = np.array([1, 2, -3]) print('Вектор a:', a)
Вектор a: [ 1 2 -3]
print('L1 норма вектора a:n', norm(a, ord=1))
L1 норма вектора a: 6.0
ell_{2} норма
ell_{2} норма (также известная как евклидова норма) для вектора
x = (x_{1}, dots, x_{n}) in mathbb{R}^{n} вычисляется по
формуле:
leftVert x rightVert_{2} = sqrt{sum_{i=1}^n left( x_{i} right)^2}.
Ей в функции numpy.linalg.norm(x, ord=None, …) соответствует
параметр ord=2.
print ('L2 норма вектора a:n', norm(a, ord=2))
L2 норма вектора a: 3.7416573867739413
Более подробно о том, какие еще нормы (в том числе матричные) можно
вычислить, см.
документацию.
15. Расстояния между векторами
Для двух векторов x = (x_{1}, dots, x_{n}) in mathbb{R}^{n} и
y = (y_{1}, dots, y_{n}) in mathbb{R}^{n} ell_{1} и
ell_{2} раccтояния вычисляются по следующим формулам
соответственно:
rho_{1}left( x, y right) = leftVert x - y rightVert_{1} = sum_{i=1}^n left| x_{i} - y_{i} right|
rho_{2}left( x, y right) = leftVert x - y rightVert_{2} =
sqrt{sum_{i=1}^n left( x_{i} - y_{i} right)^2}.
a = np.array([1, 2, -3]) b = np.array([-4, 3, 8]) print ('Вектор a:', a) print ('Вектор b:', b)
Вектор a: [ 1 2 -3] Вектор b: [-4 3 8]
print ('L1 расстояние между векторами a и b:n', norm(a - b, ord=1)) print ('L2 расстояние между векторами a и b:n', norm(a - b, ord=2))
L1 расстояние между векторами a и b: 17.0 L2 расстояние между векторами a и b: 12.12435565298214
16. Скалярное произведение и угол между векторами
a = np.array([0, 5, -1]) b = np.array([-4, 9, 3]) print ('Вектор a:', a) print ('Вектор b:', b)
Вектор a: [ 0 5 -1] Вектор b: [-4 9 3]
Скалярное произведение в пространстве mathbb{R}^{n} для двух
векторов x = (x_{1}, dots, x_{n}) и
y = (y_{1}, dots, y_{n}) определяется как:
langle x, y rangle = sum_{i=1}^n x_{i} y_{i}.
Длиной вектора x = (x_{1}, dots, x_{n}) in mathbb{R}^{n}
называется квадратный корень из скалярного произведения, то есть длина
равна евклидовой норме вектора:
left| x right| = sqrt{langle x, x rangle} = sqrt{sum_{i=1}^n x_{i}^2} = leftVert x rightVert_{2}.
Теперь, когда мы знаем расстояние между двумя ненулевыми векторами и их
длины, мы можем вычислить угол между ними через скалярное произведение:
langle x, y rangle = left| x right| | y | cos(alpha)
implies cos(alpha) = frac{langle x, y rangle}{left| x right| | y |},
где alpha in [0, pi] — угол между векторами x и
y.
cos_angle = np.dot(a, b) / norm(a) / norm(b) print ('Косинус угла между a и b:', cos_angle) print ('Сам угол:', np.arccos(cos_angle))
Косинус угла между a и b: 0.8000362836474323 Сам угол: 0.6434406336093618
17. Комплексные числа в питоне
Напоминание теории. Комплексными числами называются числа вида
x + iy, где x и y — вещественные числа, а
i — мнимая единица (величина, для которой выполняется равенство
i^{2} = -1). Множество всех комплексных чисел обозначается
буквой mathbb{C} (подробнее про комплексные числа см.
википедию).
В питоне комплескные числа можно задать следующим образом (j
обозначает мнимую единицу):
print ("Комплексное число a:n", a) print ("Комплексное число b:n", b)
Комплексное число a: (3+2j) Комплексное число b: 1j
С комплексными числами в питоне можно производить базовые арифметические
операции так же, как и с вещественными числами:
c = a * a d = a / (4 - 5j)
print ("Комплексное число c:n", c) print ("Комплексное число d:n", d)
Комплексное число c: (5+12j) Комплексное число d: (0.0487804878048781+0.5609756097560976j)
Задания: (Блок 2)
Задание 3:
Рассмотрим сложную математическую функцию на отрезке [1, 15]:
f(x) = sin(x / 5) * exp(x / 10) + 5 * exp(-x / 2)
Она может описывать, например, зависимость оценок, которые выставляют
определенному сорту вина эксперты, в зависимости от возраста этого вина.
Мы хотим приблизить сложную зависимость с помощью функции из
определенного семейства. В этом задании мы будем приближать указанную
функцию с помощью многочленов.
Как известно, многочлен степени n (то есть w_0 +
w_1 x + w_2 x^2 + ldots + w_n x^n)
однозначно определяется любыми n + 1 различными точками, через которые
он проходит. Это значит, что его коэффициенты w_0, … w_n
можно определить из следующей системы линейных уравнений:
где через x_1, …, x_n, x_{n+1} обозначены точки, через которые
проходит многочлен, а через f(x_1), …, f(x_n), f(x_{n+1}) —
значения, которые он должен принимать в этих точках.
Воспользуемся описанным свойством, и будем находить приближение функции
многочленом, решая систему линейных уравнений.
- Сформируйте систему линейных уравнений (то есть задайте матрицу
коэффициентов A и свободный вектор b) для многочлена первой степени,
который должен совпадать с функцией f в точках 1 и 15. Решите данную
систему с помощью функции scipy.linalg.solve. Нарисуйте функцию f и
полученный многочлен. Хорошо ли он приближает исходную функцию? - Повторите те же шаги для многочлена второй степени, который совпадает
с функцией f в точках 1, 8 и 15. Улучшилось ли качество
аппроксимации? - Повторите те же шаги для многочлена третьей степени, который
совпадает с функцией f в точках 1, 4, 10 и 15. Хорошо ли он
аппроксимирует функцию? Коэффициенты данного многочлена (четыре числа
в следующем порядке: w_0, w_1, w_2, w_3) являются ответом на задачу.
Округлять коэффициенты не обязательно, но при желании можете
произвести округление до второго знака (т.е. до числа вида 0.42)
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 Собственные векторы входной матрицы.
Замечание
Примеры
Иногда, визуально кажется, что вышеописанные равенства не выполняются:
Однако, значения первых столбцов равны, а значения второго и третьего столбцов настолько малы, что могут быть приравнены к 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 <0. M-1>) .
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.
Каков самый быстрый способ найти собственные значения/векторы в python?
В настоящее время im использует numpy, который выполняет задание. Но, поскольку я имею дело с матрицами с несколькими тысячами строк/столбцов, и позже эта цифра будет возрастать до десятков тысяч, мне было интересно, существует ли существующий пакет, который может выполнять такие вычисления быстрее?
ОТВЕТЫ
Ответ 1
**, если ваша матрица разрежена, а затем создайте экземпляр своей матрицы, используя конструктор из scipy.sparse, затем используйте аналогичные собственные методы/собственные значения в spicy.sparse.linalg. С точки зрения производительности это имеет два преимущества:
ваша матрица, построенная из конструктора spicy.sparse, будет меньше по размеру, насколько она разрежена.
методы собственного значения/собственного вектора для разреженных матриц (eigs, eigsh) принимают необязательный аргумент, k, который является числом собственного вектора/пар собственных значений, которые вы хотите вернуть. Почти всегда число, необходимое для учетa > 99% дисперсии, намного меньше количества столбцов, которые вы можете проверить ex post; другими словами, вы можете сказать, что метод не вычисляет и не возвращает все пары собственных/собственных значений – за небольшим (обычно) небольшим подмножеством, необходимым для учета дисперсии, маловероятно, что вам нужно все остальное.
используйте библиотеку линейных алгебр в SciPy, scipy.linalg, вместо этого одноименной библиотеки NumPy. Эти две библиотеки одно и то же имя и использовать те же имена методов. Но есть разница в производительности. Это различие вызвано тем, что numpy.linalg является менее надежной оберткой на аналогичных процедурах LAPACK, которые пожертвовать некоторой производительностью для мобильности и удобства (т.е. чтобы соответствовать цели дизайна NumPy, что вся библиотека NumPy должен быть построен без компилятора Fortran). linalg в SciPy on другая сторона представляет собой гораздо более полную оболочку на LAPACK и которая использует f2py.
выберите функцию, подходящую для вашего использования; другими словами, не использовать функцию делает больше, чем вам нужно. В scipy.linalg существует несколько функций для вычисления собственных значений; различия невелики, хотя тщательный выбор функции для вычисления собственных значений вы должны увидеть повышение производительности. Для пример:
- scipy.linalg.eig возвращает как собственные значения, так и собственные векторы
- scipy.linalg.eigvals возвращает только собственные значения. Поэтому, если вам нужны только собственные значения матрицы, тогда не используйте linalg.eig, вместо этого используйте linalg.eigvals.
- если у вас есть квадратные симметричные матрицы с вещественным значением (равные его транспонированию), то используйте scipy.linalg.eigsh
оптимизируйте свою Scipy-сборку. Создайте среду сборки SciPy. выполняется в основном в SciPy setup.py script. Возможно, наиболее важным вариантом является определение любого оптимизированного Библиотеки LAPACK, такие как ATLAS или инфраструктура Accelerate/vecLib (OS X только?), чтобы SciPy мог их обнаружить и построить против них. В зависимости от установки, которую вы сейчас используете, оптимизация вашего SciPy сборка, повторная установка может дать вам существенную производительность увеличение. Дополнительные примечания от основной команды SciPy: здесь.
Будут ли эти функции работать для больших матриц?
Я так думаю. Это методы разложения матрицы промышленной прочности и которые являются лишь тонкой оболочкой над аналогичной процедурой Fortran LAPACK.
Я использовал большинство методов в библиотеке linalg для разложения матриц, в которых количество столбцов обычно составляет от 5 до 50, а количество строк обычно превышает 500 000. Ни SVD, ни методы собственных значений, похоже, не имеют проблем с обработкой матриц такого размера.
Используя библиотеку SciPy linalg, вы можете рассчитать собственные векторы и собственные значения с помощью одного вызова с использованием любого из нескольких методов из этой библиотеки eig, eigvalsh и в восемь.
Ответ 2
Если ваши матрицы разрежены, вы можете попробовать использовать функцию scipy sparse ownvalue, которая должна быть быстрее:
Вы также можете проверить специализированные пакеты, такие как SLEPc, которые имеют привязки python и могут выполнять вычисления параллельно с помощью mpi:
[spoiler title=”источники:”]
http://numpy.org/doc/stable/reference/generated/numpy.linalg.eig.html
http://ask-dev.ru/info/158941/whats-the-fastest-way-to-find-eigenvaluesvectors-in-python
[/spoiler]
