План курса: NumPy для AI-инженера

Этот модуль является фундаментальной математической основой курса. Главная задача — научить инженера мыслить векторно, отказаться от циклов Python и перевести вычисления на C-скорость процессора. Каждая тема дает изолированный практический инструмент, который сразу можно применять в бэкенд-пайплайнах или Deep Learning.

Каждое упражнение снабжено скрытым блоком ответов ::: details Посмотреть решение для интеграции в VitePress.

• Упражнения базовые: не менее 5 штук на проработку изученного материала в данном блоке. Все переменные, индексы и комментарии в кодовой части пишутся исключительно на английском языке с использованием полного имени библиотеки numpy.
• Упражнения смешанные: не менее 5 штук на проработку изученного материала в данном блоке и включающие пройденный материал предыдущих разделов для поддержания сквозного тонуса знаний.

1. Введение в NumPy: роль в ИИ, векторизация и установка

Почему библиотека называется NumPy

Происхождение названия от словосочетания Numerical Python («Численный Python»). Историческая роль библиотеки в преодолении медлительности чистого Python и превращении его в главный мировой стандарт для сферы Data Science и инженерии искусственного интеллекта.

Концепция векторизации и C-оптимизации

Механизм работы векторизованных вычислений без циклов for на аппаратной C-скорости. Физическое устройство непрерывного блока памяти (Contiguous memory) массива ndarray в ОЗУ против стандартных списков Python (list). Обход блокировки GIL (Global Interpreter Lock). Установка через pip/conda и правила полного импорта import numpy в промышленной разработке.

Упражнения базовые (7 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (0 шт)

2. Физические свойства массивов ndarray и метаданные памяти

Анатомия метаданных массива

Изучение встроенных атрибутов объекта numpy.ndarray для контроля аппаратных ресурсов: .ndim (количество осей/размерность), .shape (кортеж геометрии массива) и .size (общее количество элементов в буфере).

Физический вес структур в RAM

Анализ реального потребления оперативной памяти элементами массива с помощью свойства .nbytes. Сравнение легковесности C-буферов NumPy со стандартными объектами Python для предотвращения переполнения памяти на серверах.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

3. Фабричные методы генерации структурированных векторов

Способы ручного конструирования данных

Использование базовой функции numpy.array() для конвертации стандартных коллекций Python в массивы ndarray.

Скоростные генераторы однородных сеток

Методы быстрого выделения памяти под веса и маски: numpy.zeros() (заполнение нулями), numpy.ones() (заполнение единицами) и их аналоги с суффиксом _like для автоматического копирования геометрии существующих тензоров. Функции построения упорядоченных шаговых сеток: numpy.arange() (арифметические диапазоны) и numpy.linspace() (линейное разбиение интервала).

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт)

4. Архитектура типов данных: Квантование и приведение типов (Dtypes)

Иерархия числовых форматов NumPy

Детальный разбор типов элементов: целочисленные знаковые и беззнаковые форматы (int8, int32, int64, uint8), вещественные числа с плавающей точкой (float16, float32, float64) и булевы флаги (bool).

Концепция квантования моделей (Quantization)

Физический смысл и применение низкобитных форматов (int8, float16) для сжатия весов нейросетей и экономии VRAM видеокарт в разы. Правила явного безопасного изменения типов с помощью C-метода .astype(). Поведение памяти при отбрасывании дробной части при касте во фрагменты целых чисел.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт)

5. Чтение, индексация и базовые срезы одномерных векторов

Доступ к элементам по одномерным координатам

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

Базовый одномерный слайсинг (1D Slicing)

Синтаксис нарезки интервалов vector[start:stop:step] по правилам Python (правая граница stop не включается в результат). Извлечение шаговых подмассивов, инвертирование и разворот векторов на C-скорости.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт)

6. Манипуляции с составом 1D-векторов: изменение структуры, сортировка и расщепление

Вставка, добавление и удаление элементов

Изучение функций numpy.append(), numpy.insert() и numpy.delete(). Механизм их работы на уровне оперативной памяти: почему эти операции не изменяют исходный буфер, а всегда выделяют в ОЗУ новый блок и возвращают физически новый массив.

Алгоритмы сортировки и расщепления

Сортировка данных по возрастанию и по убыванию (комбинация с расширенным срезом [::-1]). Разница между функцией модуля numpy.sort(arr) (создает отсортированную копию) и методом самого объекта arr.sort() (выполняет in-place сортировку на месте). Разделение одномерных последовательностей на равные части с помощью функций numpy.split() и numpy.hsplit().

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт)

7. Управление памятью: Механизм Views vs Copies (Представления против Копий)

Анатомия ссылочной модели NumPy

Фундаментальная тема курса: почему стандартный слайсинг в NumPy не копирует данные физически, а возвращает высокоскоростные представления (Views). Риски возникновения побочных эффектов (side-effects) при случайной мутации памяти оригинала через срез.

Глубокое изолирование буферов

Программное определение природы массива: использование скрытого свойства .base для поиска первоисточника данных. Применение метода принудительного глубокого копирования объектов .copy() для полной изоляции независимых выборок в ОЗУ.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт)

8. Векторизованная арифметика: операции со скалярами и поэлементная математика

Базовая векторная арифметика и типы операндов

Математические операции в режимах «вектор со скаляром» (числом) и «вектор с вектором» (поэлементно). Принципы работы стандартных арифметических операторов (+, -, *, /, **) на уровне компилируемого C-кода. Требование идентичности форм (shape) операндов при поэлементных вычислениях векторов.

Автоматическое расширение типов при операциях (Upcasting)

Автоматическое расширение типов данных при взаимодействии целочисленных векторов и вещественных скаляров (например, int32 + float64) для предотвращения потери точности. Использование встроенных математических констант высокой точности numpy.e (число Эйлера) и numpy.pi (число Пи).

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт)

9. Управление памятью в вычислениях: In-place мутации и векторные агрегаторы

Модификация на месте (In-place) vs Выделение новой памяти

Принципиальное отличие операторов присваивания +=, -=, *=, /= от классических выражений вида a = a + 1. Механизм сохранения адреса объекта в памяти. Побочные эффекты in-place операций при работе со связанными ссылками массивов. Оптимизация RAM-памяти при градиентном обновлении весов моделей.

Базовые векторные агрегаторы и кумулятивные функции

Как сжать одномерный вектор в одно скалярное число без медленных циклов. Математический смысл функций и методов .sum() (сумма), .mean() (среднее арифметическое), .min() / .max() (экстремумы). Концепция сканирующих ufuncs и вычисление накопленной суммы через numpy.cumsum().

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт)

10. Сложные ufuncs, математическая база ИИ и обработка исключений (NaN/Inf)

Математическая база для функций активации и потерь в AI

Применение сложных универсальных функций numpy.cos(), numpy.sin(), numpy.v() и встроенных ufuncs numpy.exp() и numpy.log() с целыми массивами на C-скорости процессора (SIMD, кэш-оптимизация). Логарифмы и экспоненты как основа для построения функций активации (Sigmoid, Softmax) и расчета функций потерь (Cross-Entropy Loss) без циклов.

Стандарт арифметики IEEE 754 и маркеры аномалий

Почему деление на ноль и логарифм нуля в NumPy не вызывают падения программы (исключений Python), генерируя предупреждения RuntimeWarning. Понятие бесконечности numpy.inf и отрицательной бесконечности -numpy.inf. Математический смысл неопределенности 0/0 и маркера numpy.nan. Использование специализированной ufunc-функции numpy.isnan для быстрого обнаружения и локализации «сломанных» точек в нейросетевых датасетах.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт)

11. Фильтрация 1D массивов, булевы маски и функция ReLU

Булева индексация и маскирование на C-уровне

Векторизованная фильтрация элементов массивов на основе логических сравнений (>, <, ==, !=). Механизм генерации булевых масок типа numpy.bool и правила извлечения подмассивов данных по маске array[mask].

Побитовое комбинирование условий и функции быстрой проверки

Логическое комбинирование условий через побитовые операторы & (AND), | (OR), ~ (NOT) с обязательным использованием круглых скобок для изоляции условий. Использование векторизованного оператора numpy.where(condition, x, y) как быстрой замены if-else. Симуляция функции активации ReLU (layer[layer < 0] = 0). Применение редукторов numpy.any() и numpy.all() для экспресс-проверки состояний массивов.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

12. Двумерные матрицы (2D): Создание и базовые атрибуты

Конструирование 2D матриц признаков

Конвертация вложенных двумерных списков Python в матрицы. Геометрия и строгое введение направлений — вертикальной оси строк (axis=0) и горизонтальной оси столбцов (axis=1), как фундамента вычислений в ИИ.

Физическое устройство матриц: Strides и C_CONTIGUOUS

Проверка ключевых параметров матрицы: .ndim (всегда строго 2), .shape кортежа (rows, columns) и общего объема .size. Физическая укладка двумерных структур в линейную память (Row-major order / C_CONTIGUOUS). Изучение шагов памяти в байтах с помощью атрибута .strides по двум осям. Ручное конструирование матриц весов с приведением к типу полуточности numpy.float16.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

13. Индексация 2D matrix и разделение табличных датасетов

Двумерная индексация и слайсинг подматриц

Правила индексации строк и столбцов внутри одних квадратных скобок matrix[row_index, col_index] на C-скорости. Логика извлечения подматриц, выделения изолированных векторов строк matrix[0, :] и векторов столбцов matrix[:, 2] по осям.

Разделение данных и мини-батчинг в ML

Разделение табличного датасета на матрицу признаков (features) и вектор целевой переменной (target) через срезы вида X = matrix[:, :-1], y = matrix[:, -1]. Слайсинг мини-батчей данных по строкам (axis=0) для итеративного обучения моделей (Mini-batch Gradient Descent). Использование numpy.delete(axis=0) для удаления дефектных строк-логов из матриц.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

14. Матричное умножение (2D) и симуляция полносвязных слоев

Линейная алгебра против Поэлементной математики

Принципиальная разница между поэлементным умножением матриц через оператор * и настоящим матричным умножением из линейной алгебры (оператор @ или функция numpy.dot()). Жесткое правило согласованности внутренних размерностей столбцов первой и строк второй матриц.

Операция транспонирования и симуляция Forward Pass

Зеркальный поворот матричного пространства через быстрый атрибут .T без копирования данных. Реализация базового полносвязного слоя нейросети (Linear/Dense) по формуле линейческой комбинации: Y = X @ W + b, где вектор смещения bias автоматически транслируется на каждую строку батча активаций. Прямая параллель с поведением torch.matmul в Deep Learning.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

15. Матричные агрегации, оси вычислений и нормализация признаков

Агрегирующие функции и оси вычислений в 2D

Управление направлением «сжатия» матриц с помощью параметра axis. Расчет базовых статистик .sum(), .mean(), .max(), .std() глобально по всему массиву, вертикально по столбцам (axis=0 — сбор фичей) и горизонтально по строкам (axis=1 — сбор по объектам).

Определение классов и масштабирование фичей (Scaling)

Использование функций поиска индексов экстремумов numpy.argmax(axis=1) и numpy.argmin() как основы для определения предсказанного класса на выходе классификаторов ИИ. Применение осей вычислений для нормализации признаков: алгоритм MinMax Scaling (сжатие диапазона в 0–1) и алгоритм Standard Scaling (Z-score нормализация вокруг нуля с единичной дисперсией). Расчет среднеквадратичной ошибки (MSE Loss) по матрице предсказаний.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

16. Анатомия многомерных тензоров (3D+) в компьютерном зрении и NLP

Структуры многомерных данных в Deep Learning

Разбор реальных структур данных размерностью N >= 3 (тензоров) в AI-задачах. Кодирование цветных изображений [Height, Width, Channels], батчей картинок в сверточных сетях (CNN) [Batch, Height, Width, Channels] и текстовых последовательностей в Трансформерах [Batch, Seq_Len, Hidden_Dim]. Психологический переход к работе с n-мерными пространствами через strides.

Слайсинг многомерных пространств

Правила извлечения конкретных подмассивов из многомерных тензоров: изоляция отдельного объекта из батча, выделение конкретного цветового канала для всех картинок пакета сразу (tensor[:, :, :, 0]) и кроппинг (вырезание краев/кадрирование изображений) по пространственным осям высоты и ширины.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

17. Генерация случайных тензоров и инициализация весов нейросетей

Современный генератор случайных чисел (Generator API)

Использование современного объектно-ориентированного и потокобезопасного интерфейса генерации через вызов numpy.random.default_rng(seed). Причины, по которым старый подход глобального состояния numpy.random.seed() объявлен устаревшим (Legacy). Жесткая фиксация воспроизводимости результатов экспериментов обучения ИИ через seed.

Инициализация весов и аугментация батчей

Инициализация весов нейросетей с использованием нормального Гауссовского (rng.normal()) и равномерного (rng.uniform()) распределений под заданную геометрию тензора size. Инструменты перемешивания и случайного выбора для создания мини-батчей: перемешивание строк матриц на месте через rng.shuffle() и случайное уникальное сэмплирование без повторений через rng.choice(replace=False).

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

18. Изменение формы и сплющивание многомерных тензоров

Механика изменения геометрии через .reshape()

Изменение формы тензоров без физического копирования данных в памяти (возвращается View). Контракт сохранения неизменным общего объема элементов .size. Автоматический расчет размерности неизвестной оси с помощью параметра-джокера -1. Превращение матриц-строк в векторы-столбцы.

Сплющивание (Flattening) для классификаторов

Подготовка многомерных карт признаков сверточных слоев для передачи в полносвязные классификаторы ИИ. Принципиальная разница в памяти между методом .flatten() (глубокое копирование) и методом .ravel() (высокоскоростное представление View). Прямые параллели с концепциями и поведением методов torch.view() и torch.reshape() во фреймворке PyTorch.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

19. Манипуляции с осями тензоров и правила Broadcasting (трансляции)

Управление фиктивными (единичными) размерностями

Зачем нужны единичные оси (ndim) в архитектурах слоев глубокого обучения. Инструменты добавления фиктивных осей на C-уровне: маркер numpy.newaxis внутри скобок индексации и функция numpy.expand_dims(axis). Обратная операция полного удаления и схлопывания пустых осей через функцию-редуктор numpy.squeeze().

Механизм Broadcasting (Трансляция массивов)

Фундаментальный механизм виртуального растягивания меньших массивов до размеров больших без дублирования данных в памяти. Строгие математические правила совместимости форм операндов при сравнении справа налево (с конца). Практическое применение трансляции в AI: векторизованное прибавление bias-вектора смещения к матрице батча и центрирование признаков. Построение внешних сеток умножения (Outer product).

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

20. Объединение тензоров и сборка финальных датасетов

Механика конкатенации по осям

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

Операции стекинга и наслоения буферов

Быстрые обертки конкатенации: numpy.vstack() (вертикальное наслоение строк) и numpy.hstack() (горизонтальное наращивание столбцов). Концепция функции numpy.stack(), которая объединяет массивы, создавая совершенно новую ось, которой до этого не существовало (например, упаковка независимых 2D-матриц картинок в единый 3D-батч). Параллели со структурами torch.cat() и torch.stack() в PyTorch. Выделение непрерывного C-буфера при объединении.

Упражнения базовые (5 шт) (только с опорой на объясненную в данном уроке теорию)

Упражнения смешанные (5 шт) (включают материал прошлых уроков)

Сравнение создание массива на python и numpy времени выполнения.

Производительность.

%%time

sum_value = np.sum(np.arange(10**7))
print(sum_value)

49999995000000
CPU times: user 43.5 ms, sys: 44 ms, total: 87.5 ms
Wall time: 115 ms

%%time
arr = 5 * np.arange(10**7)

CPU times: user 31.9 ms, sys: 3.27 ms, total: 35.2 ms
Wall time: 103 ms

Установка numpy и импорт

Создание одномерных массивов, параметры

однородность типов, для выполнения операций с массивами.

преобрразование питон списков к array. Преобразование смешанного списка к массиву.

Методы массива array

Метод поиска методов документации

?np.ma.mean

np.con*?

Методы характеристики массива

перебор массива

Задача: создание массива и получение его характеристик: сам массив, тип элементов массива, тип массива, размерность всех элементов массива, вес массива по памяти

Методы создания массивов:

1. Создание нулевого и единичного массивов
2. np.arrange()
3. np.linspace()
4. np.logspace()

Операции над одномерными массивами

Типы числовых данных в numpy

Приведение численных типов каст к большему

np.cos()
np.log()

nan - как замены ошибки

Логические операции над элементами массива

Кванторы всеобществ и существования

np.any()
np.all()

Inplace операции (операции меняющие текущий объект, а не создают новый объект)

+=, -=

Деление ndarray на ноль. (не выбрасывает исключений)

Константы np.e, np.pi

np.cumsum()

Сортировка

Объединение массивов, расщепление массивов

np.hsplit()

Функции append, delete, insirt

Индексирование массивов и срезы

при срезе не создается новый массив, а передается по ссылке на исходный массив

массив индексов - создания массива путем передачи индексов от массива

Задание 3:

• Создать массив чисел от $-4\pi$ до $4\pi$, количество точек 100
• Посчитать сумму поэлементных квадратов синуса и косинуса для данного массива
• С помощью np.all проверить, что все элементы равны единице.

Код решения:

# решение

x = np.linspace(-4*np.pi, 4*np.pi, 100)

print(np.all((np.sin(x)**2 + np.cos(x)**2) == 1))
print(np.sin(x)**2 + np.cos(x)**2)
print(np.all((np.sin(x)**2 + np.cos(x)**2).round() == 1))

особенность работы раунд до целого числа

Двумерные массивы

a = np.array([[1, 2], [3, 4]])
print(a)

[[1 2]
 [3 4]]

---

a.ndim, a.shape, len(a), a.size

(2, (2, 2), 2, 4)

---

Обращение по индексу.

a[1][1], a[1, 1]

(4, 4)

---

Атрибуту shape можно присвоить новое значение — кортеж размеров по всем координатам. Получится новый заголовок массива; его данные не изменятся.

b = np.arange(0, 20)
b.shape = (2, 10)
print(b)

Методы создания двухменых матриц:

np.zeros() np.eye() np.diag()

Задание 4: Создать квадратную матрицу размера 8, на главной диаг. арифметическая прогрессия с шагом 3 (начиная с 3), а на побочной -1, остальные элементы 0.

# решение
a = -1*np.eye(8)[::-1] + np.diag(np.arange(3, 27, 3))
print(a)

[[ 3.  0.  0.  0.  0.  0.  0. -1.]
 [ 0.  6.  0.  0.  0.  0. -1.  0.]
 [ 0.  0.  9.  0.  0. -1.  0.  0.]
 [ 0.  0.  0. 12. -1.  0.  0.  0.]
 [ 0.  0.  0. -1. 15.  0.  0.  0.]
 [ 0.  0. -1.  0.  0. 18.  0.  0.]
 [ 0. -1.  0.  0.  0.  0. 21.  0.]
 [-1.  0.  0.  0.  0.  0.  0. 24.]]

Умножение матриц

a = 5 * np.ones((5, 5))
b = np.eye(5) + 1
print(a, '\n')
print(b)

[[5. 5. 5. 5. 5.]
 [5. 5. 5. 5. 5.]
 [5. 5. 5. 5. 5.]
 [5. 5. 5. 5. 5.]
 [5. 5. 5. 5. 5.]]

[[2. 1. 1. 1. 1.]
 [1. 2. 1. 1. 1.]
 [1. 1. 2. 1. 1.]
 [1. 1. 1. 2. 1.]
 [1. 1. 1. 1. 2.]]

print(a * b, '\n')  # поэлементное умножение
print(a @ b, '\n')  # матричное умножение
print(a.dot(b))

[[10.  5.  5.  5.  5.]
 [ 5. 10.  5.  5.  5.]
 [ 5.  5. 10.  5.  5.]
 [ 5.  5.  5. 10.  5.]
 [ 5.  5.  5.  5. 10.]]

[[30. 30. 30. 30. 30.]
 [30. 30. 30. 30. 30.]
 [30. 30. 30. 30. 30.]
 [30. 30. 30. 30. 30.]
 [30. 30. 30. 30. 30.]]

[[30. 30. 30. 30. 30.]
 [30. 30. 30. 30. 30.]
 [30. 30. 30. 30. 30.]
 [30. 30. 30. 30. 30.]
 [30. 30. 30. 30. 30.]]

Двумерные массивы, зависящие только от одного индекса: (x_{ij} = u_j, y_{ij} = v_i)

u = np.linspace(1, 2, 2)
v = np.linspace(4, 8, 3)
print(u)
print(v)

[1. 2.]
[4. 6. 8.]

---

x, y = np.meshgrid(u, v)
print(x, '\n')
print(y)

[[1. 2.]
 [1. 2.]
 [1. 2.]]

[[4. 4.]
 [6. 6.]
 [8. 8.]]

print(x.reshape(6))  # то же самое, что и shape

[1. 2. 1. 2. 1. 2.]

Задание 5:

• Отобразить вектор размера 100, в котором вычеркивается x, если x --- составное (т. е. не является простым)

is_prime = np.ones(100, dtype=bool)

---

is_prime[:2] = False

---

N_max = int(np.sqrt(len(is_prime)))
for i in range(2, N_max):
    is_prime[2*i::i] = False  # начинаем с 2i с шагом i

print(is_prime)

[False False  True  True False  True False  True False False False  True
 False  True False False False  True False  True False False False  True
 False False False False False  True False  True False False False False
 False  True False False False  True False  True False False False  True
 False False False False False  True False False False False False  True
 False  True False False False False False  True False False False  True
 False  True False False False False False  True False False False False
 False  True False False False False False  True False False False False
 False  True False False]

проверка просых чисел

print(is_prime[17])
print(is_prime[25])

True
False

Маски.

a = np.arange(20)
print(a % 3 == 0)
print(a[a % 3 == 0])

[ True False False  True False False  True False False  True False False
  True False False  True False False  True False]
[ 0  3  6  9 12 15 18]

---

След (trace) - сумма диагональных элементов.

b = np.diag(a[a >= 10])
print(b)
print(np.trace(b))

[[10  0  0  0  0  0  0  0  0  0]
 [ 0 11  0  0  0  0  0  0  0  0]
 [ 0  0 12  0  0  0  0  0  0  0]
 [ 0  0  0 13  0  0  0  0  0  0]
 [ 0  0  0  0 14  0  0  0  0  0]
 [ 0  0  0  0  0 15  0  0  0  0]
 [ 0  0  0  0  0  0 16  0  0  0]
 [ 0  0  0  0  0  0  0 17  0  0]
 [ 0  0  0  0  0  0  0  0 18  0]
 [ 0  0  0  0  0  0  0  0  0 19]]
145

4. Тензоры (многомерные массивы)

X = np.arange(64).reshape(8, 2, 4)
print(X)

[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]

 [[16 17 18 19]
  [20 21 22 23]]

 [[24 25 26 27]
  [28 29 30 31]]

 [[32 33 34 35]
  [36 37 38 39]]

 [[40 41 42 43]
  [44 45 46 47]]

 [[48 49 50 51]
  [52 53 54 55]]

 [[56 57 58 59]
  [60 61 62 63]]]

X.shape, len(X), X.size, X.ndim

((8, 2, 4), 8, 64, 3)

np.sum(X)

2016

Посмотрим на суммы по разным осям.

print(np.sum(X, axis=0), '\n')
print(np.sum(X, axis=1), '\n')
print(np.sum(X, axis=2), '\n')

# суммируем сразу по двум осям, то есть для фиксированной i
# суммируем только элементы с индексами (i, *, *)
print(np.sum(X, axis=(1, 2)))

[[224 232 240 248]
 [256 264 272 280]]

[[ 4  6  8 10]
 [20 22 24 26]
 [36 38 40 42]
 [52 54 56 58]
 [68 70 72 74]
 [84 86 88 90]
 [100 102 104 106]
 [116 118 120 122]]

[[  6  22]
 [ 38  54]
 [ 70  86]
 [102 118]
 [134 150]
 [166 182]
 [198 214]
 [230 246]]

[ 28  92 156 220 284 348 412 476]

5. Линейная алгебра

a = np.array([[2, 1], [2, 3]])
print(a)

[[2 1]
 [2 3]]

---

Определитель.

np.linalg.det(a)

4.0

---

Нахождения обратной.

b = np.linalg.inv(a)
print(b)

[[ 0.75 -0.25]
 [-0.5   0.5 ]]

print(a.dot(b))
print(b.dot(a))

[[1. 0.]
 [0. 1.]]
[[1. 0.]
 [0. 1.]]

---

c = np.array([[2, 1], [6, 3]])
print(c)
print(np.linalg.det(c))

[[2 1]
 [6 3]]
-3.330669073875464e-16

---

np.linalg.inv(c)

array([[-9.00719925e+15,  3.00239975e+15],
       [ 1.80143985e+16, -6.00479950e+15]])

Решение СЛАУ (Решение неоднороных линейных равнений)

[\text{A} \cdot x = v]

v = np.array([5, -10])
print(np.linalg.solve(a, v))
print(b.dot(v))

[ 6.25 -7.5 ]
[ 6.25 -7.5 ]

---

Найдем собственные вектора матрицы A.

[\text{A} \cdot x = \lambda \cdot x]

l, u = np.linalg.eig(a)
print(l)
print(u)

[1. 4.]
[[-0.70710678 -0.4472136 ]
 [ 0.70710678 -0.89442719]]

Собственные значения матриц A и A.T совпадают.

l, u = np.linalg.eig(a.T)
print(l)
print(u)

[1. 4.]
[[-0.89442719 -0.70710678]
 [ 0.4472136  -0.70710678]]

---

l, u = np.linalg.eig(np.eye(3))
print(l)
print(u)

[1. 1. 1.]
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]