Математика везде в нашей жизни, но в программировании, а особенно ML ее два раза больше. Обычно Питон берут в пример самого "научного" языка программирования из-за математических фреймворков. Как не Питон может помочь оперировать математическими абстракциями, некоторые из сферы ресерча пользуются исключительно питоном для всяких научных изысканий — сегодня мы поговорим про библиотеку NumPy и работу с массивами. 

Самая новичковая "библиотека" с примочками в виде SciPy и Matplotlib предназначена для работы с многомерными массивами. NumPy – основа для многих других библиотек для машинного обучения, таких как SciPy, Pandas, Scikit-learn и TensorFlow. 

Pandas, например, строится поверх NumPy и позволяет работать со структурами данных высокого уровня по типу DataFrame и Series. При помощи NumPy можно проводить преобразование категориальных данных в числовой формат, например, с использованием кодирования one-hot.

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

Массивы = работа с классическими матрицами и векторами, иначе многомерными массивами/ndarray. В распоряжении самые простые функции для элементов внутри sin/cos/or/and, линейные операции для самих матриц от нахождения определителя до их перемножения, поддержка векторизации — все это и есть наш кратчайший путь к математическим абстракциям, ML. 

Предварительно поставить утилиту можно через pip install numpy, импортировать через import numpy as np

Пробежимся по самым простым "операциям" в библиотеке. Главный объект — массивы. NumPy предоставляет несколько способов создания массивов. 

Наиболее распространенные из них про создание:

Cоздание массивов из списков. 

Создание массивов заданного размера или формы с начальными значениями 

Массивы нулей или массивы с рандомными элементами. 

Генерируем стандартные списки массивы 

Из списка:

arr = np.array([1, 2, 3, 4, 5], float)

На входе нам предоставлено два аргумента: список, конвертируемый в массив и тип данных. 

Из заданного размера и начальных значений

zeros_arr = np.zeros((3, 3))  # Массив нулей размером 3x3
ones_arr = np.ones((2, 2)) # Массив единиц размером 2x2

Да, внутри Numpy можно быстро задать массив любой размерности с одинаковыми элементами. 

Массив с рандомизированными значениями.

rand_arr = np.random.rand(3, 3)  # Массив 3x3 со случайными значениями

У массивов есть несколько особенностей:

- Размер массива фиксируется и поменяться после создания не может. С одной стороны, мы теряем в гибкости и некотором функционале – с другой, так библиотека выполняет операции с массивами быстрее. 

- Все элементы должны иметь одинаковый тип данных. 

Но задавать можно не только целочисленные значения – можно выбирать тип данных. 

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

matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) 
#двумерный массив 3x3. 

tensor = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]) 
#наш маленький трехмерный тензор 3х3х3. 

Как прооперировать наши миниматрицы?

Индексация и нарезка — это способы доступа к элементам и подмассивам в массивах NumPy. 

Напоминаем, что индексация начинается с 0. 

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

Нарезка позволяет выбирать подмассивы по заданным диапазонам индексов с использованием синтаксиса [start:stop:step], 

где start – начальный индекс (включается), 

stop – конечный индекс (не включается), 

step – шаг. 

Выглядит это примерно так:

arr1d = np.array([1, 2, 3, 4, 5])

# Нарезка для выбора подмассива
print(arr1d[1:4])    # Получаем [2 3 4] (элементы с индексами от 1 до 3)
print(arr1d[:3])     # Получаем [1 2 3] (элементы до индекса 3)
print(arr1d[::2])    # Получаем [1 3 5] (каждый второй элемент)

# Тоже самое можно проделать с двумерными матрицами
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Нарезка для выбора подматрицы
print(arr2d[0:2, 1:])   
# Вывод: [[2 3] [5 6]] (подматрица с 1 по последний столбец в строках с 0 по 1)
print(arr2d[:2, :2])    
# Вывод: [[1 2] [4 5]] (подматрица в строках с 0 по 1 и столбцах с 0 по 1)

Как управлять элементами матрицы (творить с ними все, что захочется)

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

Например, в Numpy есть статистические функции

np.mean() - среднее значение элементов массива.

np.median() - медиана элементов массива.

np.std(): стандартное отклонение элементов массива.

np.var(): дисперсия элементов массива.

np.percentile() - квантили массива.

Или бродкастинг, про который некоторые не знают. 

Например, функция np.broadcast() позволяет выполнять поэлементные операции между массивами различных форм и размерностей. Этот объект не массив, но информирует о том, как выполнять операции с массивами разной формы без явного копирования данных или изменения их формы.

arr1 = np.array([1, 2, 3])         # Форма (3,)
arr2 = np.array([[4], [5], [6]])   # Форма (3, 1)

broadcasted = np.broadcast(arr1, arr2)

print(broadcasted.shape)

Мы позаимствовали с Pinterest даже небольшую схемку с отображениями “представлений массивов”.

А еще в NumPy можно работать с многочленами. Если уж любить линейную математику, то до конца. Создать многочлен можно через функцию np.polyid(). И некоторые "специальные" виды уравнений:

np.polynomial.legendre.Legendre() – многочлены Лежандра.

np.polynomial.chebyshev.Chebyshev() – многочлены Чебышева.

np.polynomial.laguerre.Laguerre() – многочлены Лагерра.

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

# Создаем полином Чебышева первого рода
chebyshev_poly = np.polynomial.chebyshev.Chebyshev([1, 0, -1])  # Многочлен: x^2 - 1

# Вычисление значения многочлена в заданной точке
x = 0.5
value = chebyshev_poly(x)

# Интегрирование многочлена
integral = chebyshev_poly.integrate()

Работаем с матрицами/массивами по взрослому

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

Умножение матриц (np.dot()), транспонирование матриц (np.transpose()), нахождение обратной матрицы (np.linalg.inv()), решение систем линейных уравнений (np.linalg.solve()) и нахождение собственных значений и собственных векторов (np.linalg.eig()). 

На примере решения системы линейных уравнений:

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

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

Функция np.linalg.solve() решает систему линейных уравнений, которая моделирует это уравнение. Мы представляем эту систему в виде матрицы, где строки представляют собой примеры данных, а столбцы — признаки. Мы находим оптимальные значения весов и смещения путем решения этой системы уравнений. Эти оптимальные параметры позволяют нам построить и оценить линейную модель для наших данных в задачах машинного обучения.

В коде выглядит это как-то так: 

# Создаем матрицы признаков X и вектора целевых переменных y (пример)
X = np.array([[1, 2], [3, 4], [5, 6]])
y = np.array([3, 7, 11])

# Решаем линейное уравнение
w, b = np.linalg.solve(X.T @ X, X.T @ y)

print(" Тут у нас оптимальные значения весов:")
print(w)
print(" А тут оптимальное значение смещения:")
print(b)

Неочевидные функции:

Да, действительно в NumPy достаточно функций и перечислить все — растянуть материал на пару десятков килознаков. Но есть несколько неочевидных решений, которые упростят работу в моменте. 

np.where() позволяет выполнять условное индексирование. Она возвращает индексы элементов, удовлетворяющих заданному условию. Можно также использовать ее для замены значений в массиве по определенному условию.

arr = np.array([1, 2, 3, 4, 5])
indices = np.where(arr > 2)
print(indices)  # Вывод: (array([2, 3, 4]),)

np.unique() –  функция возвращает уникальные значения в массиве в отсортированном порядке. Это может быть полезно для удаления дубликатов или анализа уникальных значений.

arr = np.array([1, 2, 3, 1, 2, 4, 5])
unique_values = np.unique(arr)
print(unique_values)  # Вывод: [1 2 3 4 5]

np.clip() – функция обрезает значения массива, чтобы они попадали в определенный диапазон. Это может быть полезно для ограничения значений массива сверху и снизу.

arr = np.array([1, 2, 3, 4, 5])
clipped_arr = np.clip(arr, 2, 4)
print(clipped_arr)  # Вывод: [2 2 3 4 4]

np.ravel() "выпрямляет" массив, превращая многомерный массив в одномерный. Это может быть удобно для быстрого преобразования массива в одномерный вид.

arr = np.array([[1, 2, 3], [4, 5, 6]])
raveled_arr = np.ravel(arr)
print(raveled_arr)  # Вывод: [1 2 3 4 5 6]

Простой пример или проба NumPy на линейной регрессии без сторонних библиотек и фреймворков

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

X_train = np.array([[1], [2], [3], [4], [5]])  # Входные признаки (одномерный массив)
y_train = np.array([2, 4, 5, 4, 5])            # Целевая переменная

# Добавляем столбец с единицами для учета свободного члена в модели
X_train_with_bias = np.c_[np.ones((X_train.shape[0], 1)), X_train]

# Обучение модели линейной регрессии
theta = np.linalg.inv
(X_train_with_bias.T.dot(X_train_with_bias)).dot(X_train_with_bias.T).dot(y_train)

# Вывод коэффициентов модели
print("Коэффициенты модели:", theta)

# Предсказание на новых данных
X_test = np.array([[6], [7]])                 # Новые входные признаки
X_test_with_bias = np.c_[np.ones((X_test.shape[0], 1)), X_test]
y_pred = X_test_with_bias.dot(theta)

# Вывод предсказанных значений
print("Предсказанные значения:", y_pred)

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

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

И не нужно нам писать: используйте обычные списки. Мы просто посмеемся. Хотя пример карикатурный, но весь смысл NumPy – базовая библиотека для линейных операций, коих в ML много и дальше больше. 

В этой статье мы быстренько пробежались по функционалу библиотеки и даже показали на примере, как построить простую линейную регрессию. Самое большое наставление, которое можно дать любому начинающему ML/Data-специалисту - математика наше все. Благодаря рукотворно написанным ресерчам мы и получили прекрасные GPT, иначе трансформаторы и благодаря линейной алгебре мы можем прописывать "градиентный" бустинг. 

Писать на низком уровне абстракций, мы не про ассемблер и С, попробовать обозначать математику через такие библиотеки как NumPy - путь к лучшему пониманию машинного обучения в целом.