Давайте быстро приступим. Numpy - математическая библиотека для Python. Это позволяет нам выполнять вычисления эффективно и результативно. Он лучше обычного питона из-за его потрясающих возможностей.
В этой статье я просто познакомлю вас с основами того, что в основном требуется для машинного обучения и науки о данных. Я не собираюсь описывать все, что возможно с помощью библиотеки numpy. Это первая часть серии обучающих программ.
Первое, что я хочу вам представить, это то, как вы его импортируете.
import numpy as np
Хорошо, теперь мы сообщаем python, что «np» - это официальная ссылка на numpy, которая идет дальше.
Давайте создадим массив Python и массив np.
# python array a = [1,2,3,4,5,6,7,8,9] # numpy array A = np.array([1,2,3,4,5,6,7,8,9])
Если бы я их распечатал, я бы не увидел большой разницы.
print(a) print(A) ====================================================================[1, 2, 3, 4, 5, 6, 7, 8, 9] [1 2 3 4 5 6 7 8 9]
Хорошо, но почему я должен использовать массив np вместо обычного массива?
Ответ заключается в том, что массивы np лучше с точки зрения более быстрых вычислений и простоты манипуляций.
Подробнее об этом здесь, если вам интересно:
Давайте продолжим и рассмотрим более интересные вещи. Погодите, мы еще не видели ничего крутого! Хорошо, вот что:
np.arange ()
np.arange(0,10,2) ====================================================================array([0, 2, 4, 6, 8])
Что делает arange ([start], stop, [step]), так это то, что он упорядочивает числа от начала до остановки с шагом step. Вот что это значит для np.arange (0,10,2):
вернуть список np, начиная с 0 до 10, но не включать 10 и увеличивать числа каждый раз на 2.
Итак, вот как мы получаем:
array([0, 2, 4, 6, 8])
здесь важно помнить, что номер остановки не будет включен в список.
другой пример:
np.arange(2,29,5) ==================================================================== array([ 2, 7, 12, 17, 22, 27])
Прежде чем продолжить, я должен предупредить вас, что этот «массив» взаимозаменяемо называется «матрицей» или «вектором». Так что не паникуйте, когда я скажу, например, «Форма матрицы 2 х 3». Все это означает, что массив выглядит примерно так:
array([ 2, 7, 12,],
[17, 22, 27])
Теперь поговорим о форме массива np по умолчанию.
Форма - это атрибут массива np. Когда массив по умолчанию, например, A вызывается с shape, он выглядит вот так.
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.shape ==================================================================== (9,)
Это матрица (массив) ранга 1, в которой всего 9 элементов в строке.
В идеале это должна быть матрица 1 X 9, не так ли?
Я согласен с вами, поэтому в игру вступает reshape (). Это метод, который изменяет размеры вашей исходной матрицы на желаемое.
Давайте посмотрим на изменение формы в действии. Вы можете передать кортеж любого размера, который хотите, при условии, что измененная матрица и исходная матрица имеют одинаковое количество элементов.
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.reshape(1,9) ==================================================================== array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])
Обратите внимание, что reshape возвращает матрицу с несколькими размерами. На это указывают две квадратные скобки в начале. [[1, 2, 3, 4, 5, 6, 7, 8, 9]] - потенциально многомерная матрица в отличие от [1, 2, 3, 4, 5, 6, 7, 8, 9] .
Другой пример:
B = [1, 2, 3, 4, 5, 6, 7, 8, 9]
B.reshape(3,3)
====================================================================
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
Если я посмотрю на фигуру B, она будет (3,3):
B.shape ==================================================================== (3,3)
Идеально. Перейдем к np.zeros ().
На этот раз ваша работа - рассказать мне, что происходит при просмотре этого кода:
np.zeros((4,3)) ==================================================================== ???????????
Хорошо, если вы думали, что собираетесь напечатать матрицу 4 X 3, заполненную нулями. Вот результат:
np.zeros((4,3))
====================================================================
array([[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]])
np.zeros ((n, m)) возвращает матрицу n x m, содержащую нули. Это так просто.
Давайте снова угадаем: что делает np.eye ()?
Подсказка: eye () означает личность.
np.eye(5)
====================================================================
array([[ 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.]])
np.eye () возвращает единичную матрицу с указанными размерами.
Что, если нам нужно перемножить 2 матрицы?
Нет проблем, у нас есть np.dot ().
np.dot () выполняет умножение матриц при условии, что обе матрицы «умножаемы». Это просто означает, что количество столбцов первой матрицы должно соответствовать количеству строк во второй матрице.
Пример: A = (2,3) & B = (3,2). Здесь количество столбцов в A = 3. Количество строк в B = 3. Поскольку они совпадают, возможно умножение.
Проиллюстрируем умножение с помощью np-кода:
# generate an identity matrix of (3 x 3)
I = np.eye(3)
I
====================================================================
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
# generate another (3 x 3) matrix to be multiplied.
D = np.arange(1,10).reshape(3,3)
D
====================================================================
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
Теперь мы подготовили обе матрицы для умножения. Давайте посмотрим на них в действии.
# perform actual dot product.
M = np.dot(D,I)
M
====================================================================
array([[ 1., 2., 3.],
[ 4., 5., 6.],
[ 7., 8., 9.]])
Большой! Теперь вы знаете, как легко и возможно умножать матрицы! Также обратите внимание, что теперь весь массив имеет тип с плавающей запятой.
А как насчет добавления элементов матрицы?
# add all the elements of matrix. sum_val = np.sum(M) sum_val ==================================================================== 45.0
np.sum () складывает все элементы матрицы.
Однако есть 2 варианта.
1. Просуммируйте по строкам.
# sum along the rows np.sum(M,axis=1) ==================================================================== array([ 6., 15., 24.])
6 - это сумма 1-й строки (1, 2, 3).
15 - это сумма 2-й строки (4, 5, 6).
24 - это сумма 3-й строки (7, 8, 9).
2. Просуммируйте по столбцам.
# sum along the cols np.sum(M,axis=0) ==================================================================== array([ 12., 15., 18.])
12 - это сумма 1-го столбца (1, 4, 7).
15 - это сумма 2-го столбца (2, 5, 8).
18 - это сумма 3-го столбца (3, 6, 9).
Вот следующий урок - часть 2. На этом все.
Вот видеоурок, объясняющий все, что я сделал, если вы хотите использовать видео.
Если вам интересно изучать панд, я написал обучающую статью здесь. Он называется Введение в Pandas: -1: Руководство для начинающих по машинному обучению и науке о данных.
