Skip to content

01. Окружение, numpy 2.x и загрузка данных ​

В этом уроке мы поднимем Python-окружение, установим зависимости, разберёмся почему оригинальные файлы задания падают на свежем numpy и что мы в них починили, а затем загрузим данные (реальные или стаб) и проверим, что всё читается.

Шаг 1. Виртуальное окружение (venv) ​

Отдельное окружение на проект — чтобы версии библиотек не мешали друг другу и системный Python не пачкался. В assignments/assignment1:

bash
# Создаём и активируем venv (Windows: activate.bat, Linux/macOS: source)
python -m venv .venv
# Windows (Git Bash / cmd):
.venv/Scripts/activate
# Linux / macOS:
# source .venv/bin/activate

# Проверяем, что активировались
which python        # должен показать путь в .venv
python --version    # нужен 3.10+, в курсе используем 3.13

Шаг 2. Установка зависимостей ​

bash
pip install --upgrade pip
pip install -r requirements.txt

requirements.txt содержит numpy, matplotlib, scipy. На 2026 год pip поставит numpy 2.x — и именно тут начинается интересная часть урока.

Шаг 3. Почему задание падает на numpy ≥ 2.0 (и что мы поправили) ​

В numpy 2.0 удалены «исторические» алиасы, которые ранее указывали на встроенные типы Python. По ним код на свежем numpy падает с AttributeError. В исходниках задания таких мест четыре — в нашей копии assignment_source/ они уже исправлены. Разберём каждое.

3.1. np.int и np.float удалены ​

В старых версиях np.int был алиасом встроенного int, а np.float — встроенного float. В numpy 2.x их нет:

python
import numpy as np
np.int     # AttributeError: module 'numpy' has no attribute 'int'
np.float   # AttributeError: module 'numpy' has no attribute 'float'

knn.py — в predict_labels_binary и predict_labels_multiclass:

python
# Было (падает на numpy 2.x):
pred = np.zeros(num_test, np.int)
# Стало:
pred = np.zeros(num_test, int)

linear_classifer.py — в predict:

python
# Было:
y_pred = np.zeros(X.shape[0], dtype=np.int)
# Стало:
y_pred = np.zeros(X.shape[0], dtype=int)

Почему int, а не np.int64? int даёт платформенный 64-битный целочисленный тип (то, что раньше делал np.int). Для хранения меток классов этого достаточно.

3.2. Проверка типа в gradient_check.py ​

Было:

python
assert x.dtype == np.float   # np.float больше не существует

Стало:

python
assert np.issubdtype(x.dtype, np.floating)

np.issubdtype — правильный способ спросить «это какой-то вещественный тип?» (float32, float64, …), не привязываясь к конкретной ширине.

3.3. Ноутбук Linear_classifier.ipynb: float() от одноэлементного массива ​

В ячейке с проверкой градиента определена функция:

python
def square(x):
    return float(x*x), 2*x

Когда x — массив из одного элемента (как np.array([3.0])), выражение x*x — это всё ещё массив, а не скаляр. В numpy 2.x float() не конвертирует одноэлементный массив (раньше работал с предупреждением):

python
import numpy as np
x = np.array([3.0])
float(x * x)   # TypeError: only 0-dimensional arrays can be converted to Python scalars

Правильно — сначала свести к скаляру суммой:

python
def square(x):
    return float(np.sum(x * x)), 2 * x

В нашей копии ноутбука эта правка уже внесена.

3.4. np.bool — оставили как есть ​

В knn.py встречается np.bool (проверка бинарного режима и тип pred):

python
if self.train_y.dtype == np.bool:
    ...
pred = np.zeros(num_test, np.bool)

В отличие от np.int/np.float, np.bool в numpy 2.x работает (это корректный bool-тип), предупреждений не выдаёт. Поэтому трогать его не нужно — и не стоит «на всякий случай» менять на bool: пусть остаётся каноничным для задания.

Шаг 4. Формат .mat и функция load_svhn ​

Данные лежат в MATLAB-файлах .mat. Читаем их через scipy.io.loadmat. Разберём готовый dataset.py, он короткий:

python
def load_data_mat(filename, max_samples, seed=42):
    raw = io.loadmat(filename)
    X = raw['X']  # массив формы [32, 32, 3, n_samples]
    y = raw['y']  # массив формы [n_samples, 1]
    X = np.moveaxis(X, [3], [0])   # переносим ось образцов в начало → (n_samples, 32, 32, 3)
    y = y.flatten()                # (n_samples, 1) → (n_samples,)
    y[y == 10] = 0                 # метка «0» в SVHN хранится как 10, приводим к 0
    np.random.seed(seed)
    samples = np.random.choice(np.arange(X.shape[0]), max_samples, replace=False)
    return X[samples].astype(np.float32), y[samples]

Ключевые моменты, которые понадобятся дальше:

  • np.moveaxis(X, [3], [0]) — перестановка осей: образцы (axis 3) становятся первой осью. В итоге X имеет форму (n_samples, 32, 32, 3) — «образец-first».
  • Метки SVHN: 0..9 хранятся как 1..10, поэтому y[y == 10] = 0. Важно: это не y - 1 (сдвиг всех), а точечная замена только десятки. После этой строки метки — нормальные 0..9.
  • max_samples без замены (replace=False) — берём ровно столько различных образцов. Поэтому max_train/max_test не могут превышать реальный размер.
  • Возвращаемый X приведён к float32 — экономим память (4 байта на пиксель-канал).

load_svhn(folder, max_train, max_test) вызывает load_data_mat дважды (для train_32x32.mat и test_32x32.mat) и возвращает (train_X, train_y, test_X, test_y).

Шаг 5. Загрузка данных: реальные или стаб ​

Вариант А. Реальный SVHN ​

bash
# В папке assignments/assignment1 (или там, где лежит ваш dataset.py)
bash download_data.sh
# или вручную:
mkdir -p data
wget -c http://ufldl.stanford.edu/housenumbers/train_32x32.mat \
       http://ufldl.stanford.edu/housenumbers/test_32x32.mat -P data/

Флаг -c у wget — резюме: если скачивание прервалось, продолжит с того же места.

Вариант Б. Синтетический стаб (офлайн, быстро) ​

Если нет желания качать 240 МБ (или нет доступа к хосту), сгенерируем «домашние» цифры. Скрипт из этого модуля:

bash
python scripts/make_svhn_stub.py --folder data_stub --n-train 10000 --n-test 1000

Он создаёт data_stub/train_32x32.mat и data_stub/test_32x32.mat в том же формате (X: 32×32×3×N uint8, y: (N,1) int64, метки 1..10), поэтому load_svhn работает без единой правки. Параметры: --folder, --n-train, --n-test, --seed.

Один стаб — на обе части. Стаб на 10 000/1 000 образцов работает и для KNN, и для линейного классификатора: KNN-ноутбук грузит load_svhn("data_stub", 1000, 100) (случайные 1000/100 из стаба, seed фиксирован в load_data_mat), а линейный — load_svhn("data_stub", 10000, 1000) (весь стаб). На реальных данных задание сразу использует max_train=10000, max_test=1000.

Шаг 6. Проверяем загрузку и смотрим цифры ​

Скрипт-проверка (выполните в папке с dataset.py):

python
from dataset import load_svhn
import numpy as np

# Укажите свою папку с данными:
FOLDER = "data"          # реальные
# FOLDER = "data_stub"   # или стаб

train_X, train_y, test_X, test_y = load_svhn(FOLDER, 1000, 100)

print("train_X:", train_X.shape, train_X.dtype)  # (1000, 32, 32, 3) float32
print("train_y:", train_y.shape, train_y.dtype)  # (1000,) int64
print("test_X:", test_X.shape)                    # (100, 32, 32, 3)
print("label range:", train_y.min(), train_y.max())  # 0 9
print("unique labels:", np.unique(train_y))

Ожидаемый вывод (на стабе):

text
train_X: (1000, 32, 32, 3) float32
train_y: (1000,) int64
test_X: (100, 32, 32, 3)
label range: 0 9
unique labels: [0 1 2 3 4 5 6 7 8 9]

Шаг 7. Визуализируем пару изображений ​

Визуализируем headless (без окна) через бэкенд Agg, сохранив в PNG. Канонический размер: figsize=(0.4, 0.4) при dpi=80 даёт ровно 32×32 пикселя.

python
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 5, figsize=(8, 1.6))
for i, ax in enumerate(axes):
    ax.imshow(train_X[i])          # (32, 32, 3) — RGB
    ax.set_title(str(train_y[i]))
    ax.axis("off")
plt.tight_layout()
plt.savefig("sample_digits.png", dpi=100)
print("saved sample_digits.png")
xml
<svg viewBox="0 0 520 150" font-family="sans-serif" font-size="14">
  <!-- Row of 5 tiny digit tiles with label chips -->
  <g>
    <rect x="10"  y="30" width="80" height="80" rx="6" fill="var(--surface)" stroke="var(--border)"/>
    <rect x="110" y="30" width="80" height="80" rx="6" fill="var(--surface)" stroke="var(--border)"/>
    <rect x="210" y="30" width="80" height="80" rx="6" fill="var(--surface)" stroke="var(--border)"/>
    <rect x="310" y="30" width="80" height="80" rx="6" fill="var(--surface)" stroke="var(--border)"/>
    <rect x="410" y="30" width="80" height="80" rx="6" fill="var(--surface)" stroke="var(--border)"/>
  </g>
  <g text-anchor="middle" fill="currentColor" font-size="40" font-weight="700">
    <text x="50"  y="88">3</text>
    <text x="150" y="88">7</text>
    <text x="250" y="88">0</text>
    <text x="350" y="88">5</text>
    <text x="450" y="88">9</text>
  </g>
  <g text-anchor="middle" font-size="12" fill="var(--muted)">
    <text x="50"  y="135">train_y[i]</text>
    <text x="150" y="135">label 0..9</text>
    <text x="250" y="135">32x32x3</text>
    <text x="350" y="135">float32</text>
    <text x="450" y="135">RGB</text>
  </g>
</svg>

Практика: подзадания урока ​

1. Выполните Шаг 6 на обеих источниках данных (реальные и стаб) при max_train=1000, max_test=100. Сравните .shape и unique меток. Совпадает ли train_y.dtype между ними? (Подсказка: в load_data_mat метки не приводятся к конкретному типу.)

2. Загрузите с max_train=5000. Затем — с max_train=5001. Убедитесь, что в обоих случаях len(train_y) == max_train (только если в датасете столько образцов; на стабе 1000 — вторая загрузка упадёт). Какой ValueError/ошибка появляется, если запросить больше, чем есть?

3. Напишите одну строку кода, которая вычисляет среднее изображение по всей обучающей выборке: mean_img = ... (форма (32, 32, 3)). Сохраните его в mean_digit.png через plt.imsave.

Показать решения

1. Формы идентичны: (1000, 32, 32, 3) и (100, 32, 32, 3). unique — [0..9]. Тип меток int64 в обоих случаях, т.к. y из .mat — int64, а load_data_mat его не меняет (только X приводится к float32).

2. При max_train больше доступного np.random.choice(..., replace=False) бросает ValueError: Cannot take a larger sample than population when 'replace=False'.

3. mean_img = train_X.mean(axis=0) — усреднение по оси образцов. plt.imsave("mean_digit.png", mean_img).

Проверка «окружение готово» ​

Перед переходом к KNN убедитесь, что:

  • python --version показывает 3.10+, venv активен;
  • import numpy, scipy, matplotlib не ругается;
  • ваш knn.py/gradient_check.py/linear_classifer.py не содержатnp.int/np.float (проверка: grep -rn "np\.int\b\|np\.float\b" *.py возвращает пусто);
  • load_svhn возвращает ожидаемые формы, unique меток — 0..9.

Следующий урок — 02. Идея KNN: что вообще делает «k ближайших соседей» и почему это можно считать моделью.

Итоги урока ​

  • Вывели venv, поставили numpy 2.x через requirements.txt;
  • Разобрали 4 места, где оригинал ломается на numpy 2.x (np.int, np.float, float() от массива, assert x.dtype == np.float) и их исправления;
  • Поняли, почему np.bool трогать не нужно;
  • Разобрали load_data_mat: moveaxis, метки 1..10 → 0..9, max_samples без замены;
  • Научились загружать реальный SVHN (wget -c) и генерировать стаб (make_svhn_stub.py), а также показывать изображения headless.