NumPy: Эффективные вычисления с массивами - Машинное обучение и ИИ: От Новичка до Собственных Проектов - Qpel.AI
QPEL.ai

NumPy: Эффективные вычисления с массивами

Курс: Машинное обучение и ИИ: От Новичка до Собственных Проектов

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

Что такое NumPy и почему он важен?

В машинном обучении и анализе данных нам постоянно приходится работать с большими объемами числовых данных: это могут быть изображения, тексты, показания датчиков или финансовые ряды. Стандартные списки Python, хоть и универсальны, не всегда эффективны для таких задач, особенно когда речь идет о миллионах или миллиардах элементов.

Здесь на сцену выходит NumPy. Он предоставляет мощный объект ndarray (N-dimensional array) — многомерный массив, который позволяет хранить однотипные данные и выполнять над ними операции гораздо быстрее, чем с обычными списками Python.

💡 Почему NumPy быстрее? NumPy написан на C и Fortran, что обеспечивает высокую производительность. Он оптимизирован для работы с большими массивами данных, используя векторные операции, которые выполняются на низком уровне без необходимости явных циклов Python. Это критически важно для скорости обучения сложных моделей машинного обучения.

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

Создание массивов NumPy

Давайте начнем с создания наших первых массивов.

Из списков Python

Самый простой способ — преобразовать существующий список или вложенный список в массив NumPy.

import numpy as np

# Одномерный массив (вектор)
arr1d = np.array([1, 2, 3, 4, 5])
print("Одномерный массив:", arr1d)
print("Тип массива:", type(arr1d))
print("Форма массива (размерность):", arr1d.shape) # (5,) - 5 элементов

# Двумерный массив (матрица)
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
print("\nДвумерный массив:\n", arr2d)
print("Форма массива:", arr2d.shape) # (2, 3) - 2 строки, 3 столбца
print("Количество измерений:", arr2d.ndim) # 2

Создание массивов со специальными значениями

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

# Массив из нулей
zeros_arr = np.zeros((3, 4)) # Матрица 3x4, заполненная нулями
print("\nМассив из нулей:\n", zeros_arr)

# Массив из единиц
ones_arr = np.ones((2, 2)) # Матрица 2x2, заполненная единицами
print("\nМассив из единиц:\n", ones_arr)

# Массив с заданным значением
full_arr = np.full((2, 3), 7) # Матрица 2x3, заполненная числом 7
print("\nМассив с заданным значением:\n", full_arr)

# Массив с последовательностью чисел
range_arr = np.arange(0, 10, 2) # От 0 до 10 (не включая), с шагом 2
print("\nМассив с последовательностью (arange):", range_arr)

# Массив с равномерно распределенными числами
linspace_arr = np.linspace(0, 1, 5) # 5 чисел от 0 до 1 (включительно)
print("\nМассив с равномерно распределенными числами (linspace):", linspace_arr)

Случайные числа

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

# Массив случайных чисел от 0 до 1 (равномерное распределение)
random_float_arr = np.random.rand(2, 3)
print("\nСлучайные числа (float):\n", random_float_arr)

# Массив случайных целых чисел
random_int_arr = np.random.randint(0, 10, size=(2, 4)) # Целые от 0 до 9, размер 2x4
print("\nСлучайные числа (int):\n", random_int_arr)

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

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

Арифметические операции

Сложение, вычитание, умножение, деление и другие операции применяются поэлементно.

arr_a = np.array([[1, 2], [3, 4]])
arr_b = np.array([[5, 6], [7, 8]])

print("Массив A:\n", arr_a)
print("Массив B:\n", arr_b)

print("\nСложение (поэлементное):\n", arr_a + arr_b)
print("Умножение (поэлементное):\n", arr_a * arr_b)
print("Умножение на скаляр:\n", arr_a * 2)

# Матричное умножение (очень важно для ML!)
matrix_mult = arr_a @ arr_b # Или np.dot(arr_a, arr_b)
print("\nМатричное умножение (A @ B):\n", matrix_mult)

Индексация и срезы

Доступ к элементам массива осуществляется аналогично спискам Python, но с расширенными возможностями для многомерных массивов.

arr = np.array([[10, 20, 30],
                [40, 50, 60],
                [70, 80, 90]])
print("Исходный массив:\n", arr)

# Доступ к элементу (строка, столбец)
print("\nЭлемент (0, 1):", arr[0, 1]) # 20

# Срез строки
print("Первая строка:", arr[0, :]) # [10 20 30]

# Срез столбца
print("Второй столбец:", arr[:, 1]) # [20 50 80]

# Подмассив
print("Подмассив (первые 2 строки, последние 2 столбца):\n", arr[:2, 1:])

# Булева индексация (очень мощный инструмент!)
# Выбираем все элементы, которые больше 50
print("\nЭлементы > 50:", arr[arr > 50]) # [60 70 80 90]

Изменение формы (Reshape)

Часто требуется изменить форму массива, не меняя его данных. Например, преобразовать одномерный массив в двумерный или наоборот.

arr_flat = np.arange(1, 10)
print("Исходный одномерный массив:", arr_flat)

# Преобразовать в матрицу 3x3
arr_reshaped = arr_flat.reshape((3, 3))
print("\nМассив после reshape (3x3):\n", arr_reshaped)

# Можно использовать -1, чтобы NumPy сам вычислил размерность
arr_reshaped_auto = arr_flat.reshape((3, -1)) # 3 строки, количество столбцов вычисляется автоматически
print("\nМассив после reshape (3, -1):\n", arr_reshaped_auto)

# Преобразовать обратно в одномерный
arr_back_to_flat = arr_reshaped.flatten()
print("\nМассив обратно в одномерный (flatten):", arr_back_to_flat)

Объединение и разделение массивов

arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])

# Объединение по вертикали (добавление строк)
arr_vstacked = np.vstack((arr1, arr2))
print("\nОбъединение по вертикали (vstack):\n", arr_vstacked)

# Объединение по горизонтали (добавление столбцов)
arr_hstacked = np.hstack((arr1, arr2))
print("\nОбъединение по горизонтали (hstack):\n", arr_hstacked)

# Разделение массива
arr_to_split = np.arange(12).reshape((3, 4))
print("\nМассив для разделения:\n", arr_to_split)

# Разделение на 2 части по горизонтали
split_h = np.hsplit(arr_to_split, 2)
print("\nРазделение по горизонтали (hsplit):\n", split_h[0])
print(split_h[1])

Векторизация и производительность

Одним из ключевых преимуществ NumPy является векторизация — возможность выполнять операции над целыми массивами данных без явных циклов. Это не только делает код более компактным и читаемым, но и значительно ускоряет вычисления.

Давайте сравним производительность NumPy с обычными списками Python на простом примере.

import time

size = 1_000_000 # Миллион элементов

# Создаем два больших списка Python
list1 = list(range(size))
list2 = list(range(size))

# Создаем два больших массива NumPy
np_arr1 = np.arange(size)
np_arr2 = np.arange(size)

# Сравнение производительности для сложения
start_time = time.time()
result_list = [list1[i] + list2[i] for i in range(size)]
end_time = time.time()
print(f"\nВремя выполнения сложения списков Python: {end_time - start_time:.4f} секунд")

start_time = time.time()
result_np = np_arr1 + np_arr2
end_time = time.time()
print(f"Время выполнения сложения массивов NumPy: {end_time - start_time:.4f} секунд")

# Вы увидите, что NumPy справляется с задачей в десятки, а то и сотни раз быстрее!

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

Задания для Самостоятельной Работы

Пришло время закрепить полученные знания на практике!

Упражнения

  1. Создание и свойства массива:
    • Создайте одномерный массив NumPy из 10 случайных целых чисел в диапазоне от 1 до 100.
    • Выведите его форму (shape), количество измерений (ndim) и тип данных (dtype).
  2. Операции с массивами:
    • Создайте два массива NumPy размером 2x3, заполненные произвольными числами.
    • Выполните поэлементное сложение, вычитание и умножение этих массивов.
    • Попробуйте выполнить матричное умножение (если возможно с данными формами, иначе измените форму одного из массивов).
  3. Индексация и срезы:
    • Создайте массив 4x4, заполненный числами от 1 до 16 (используйте np.arange и reshape).
    • Извлеките из него:
      • Вторую строку.
      • Третий столбец.
      • Подмассив, состоящий из первых двух строк и последних двух столбцов.
      • Все элементы, которые делятся на 3 без остатка.
  4. Изменение формы:
    • Возьмите одномерный массив из 12 элементов.
    • Преобразуйте его в массив 3x4, затем в 4x3.
    • Преобразуйте его в массив 2x2x3 (трехмерный).

Вопросы для Самопроверки

  1. В чем основное отличие ndarray от стандартного списка Python?
  2. Почему NumPy так важен для машинного обучения и анализа данных?
  3. Что такое "векторизация" в контексте NumPy и почему она так важна для производительности?
  4. Как создать массив NumPy, заполненный только нулями?
  5. Как получить доступ к элементу в третьей строке и втором столбце двумерного массива NumPy?

Ключевые Выводы и Следующие Шаги

Что мы узнали:

  • NumPy — это фундаментальная библиотека для научных вычислений в Python, предоставляющая высокопроизводительные многомерные массивы (ndarray).
  • Мы научились создавать массивы различными способами: из списков, с помощью специальных функций (zeros, ones, arange, linspace) и генераторов случайных чисел.
  • Освоили основные операции над массивами: арифметические, индексацию, срезы, изменение формы (reshape, flatten), а также объединение и разделение.
  • Поняли концепцию векторизации и ее критическое значение для производительности в задачах машинного обучения.

NumPy — это не просто библиотека, это основа, на которой строятся многие другие инструменты для работы с данными и машинного обучения, такие как Pandas, Scikit-learn, TensorFlow и PyTorch. Понимание NumPy позволит вам эффективно работать с данными на низком уровне и оптимизировать свои ML-проекты.

В следующем разделе мы продолжим наше погружение в мир работы с данными и познакомимся с библиотекой Pandas. Она использует NumPy как свою основу и предоставляет еще более мощные и удобные структуры данных для работы с табличными данными, что является следующим логическим шагом в подготовке данных для ваших будущих ИИ-проектов. Готовы к новым открытиям? 😉