{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Мини-проект: ближайшие соседи\n", "\n", "Метод k ближайших соседей на NumPy — порекомендовать напиток по оценкам похожих гостей и предсказать продажи по похожим дням; почему перед расстояниями признаки нужно нормализовать.\n", "\n", "Курс NumPy · урок `np-project-knn` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/numpy/project-knn).\n", "\n", "Выполняйте ячейки по порядку (Shift+Enter), начиная с первой — она готовит урок. После каждого упражнения идёт\n", "ячейка проверки: она печатает ✓ / ✗ и итог." ], "id": "intro" }, { "cell_type": "code", "metadata": { "cellView": "form", "jupyter": { "source_hidden": true } }, "source": [ "# @title Подготовка урока — выполните эту ячейку первой\n", "# Проверяет версии пакетов, записывает файлы данных в папку data/ и определяет _check — проверку упражнений.\n", "import base64, os, zlib\n", "\n", "for _name, _min in {\"numpy\":\"2.0\"}.items():\n", " try:\n", " _have = __import__(_name).__version__\n", " except ImportError:\n", " print(f\"Нет пакета {_name}: выполните %pip install {_name} и перезапустите ядро\")\n", " continue\n", " if tuple(int(x) for x in _have.split(\".\")[:2]) < tuple(int(x) for x in _min.split(\".\")):\n", " print(f\"Урок написан для {_name} {_min} и новее, у вас {_have}: выполните %pip install -U {_name} и перезапустите ядро\")\n", "\n", "# ─── Проверка упражнений: тот же раннер, что у задач на сайте ───\n", "# ─── Запуск тестов ───────────────────────────────────────────────────────────\n", "\n", "_TIMEOUT = 2.0 # секунд на тест; отдельный тест может задать свой: test_x.timeout = 10\n", "\n", "\n", "def _call_with_timeout(target, seconds: float) -> bool:\n", " \"\"\"Запускает target() в отдельном потоке. Возвращает False, если за seconds он не завершился.\"\"\"\n", " import sys\n", " import threading\n", "\n", " if sys.platform == \"emscripten\": # Python в браузере: потоков нет, таймаут обеспечивает страница\n", " target()\n", " return True\n", " # Большой стек нужен, чтобы глубокая рекурсия давала RecursionError, а не аварийное завершение Python.\n", " for megabytes in (256, 64, 0):\n", " try:\n", " threading.stack_size(megabytes * 1024 * 1024)\n", " worker = threading.Thread(target=target, daemon=True)\n", " worker.start()\n", " except (ValueError, RuntimeError, MemoryError):\n", " continue\n", " worker.join(seconds)\n", " return not worker.is_alive()\n", " target() # потоки недоступны — запускаем без таймаута\n", " return True\n", "\n", "\n", "def _test_info(fn) -> dict:\n", " \"\"\"Описание теста, его лимит времени и сообщение на случай зависания.\"\"\"\n", " limit = getattr(fn, \"timeout\", _TIMEOUT)\n", " hint = getattr(fn, \"timeout_hint\", \"\")\n", " message = (\n", " f\"тест не завершился за {limit:g} с — возможно, бесконечный цикл или рекурсия: \"\n", " \"проверьте, что границы/аргументы изменяются на каждом шаге\" + (f\". {hint}\" if hint else \"\")\n", " )\n", " return {\"title\": (fn.__doc__ or fn.__name__).strip(), \"timeout\": limit, \"timeout_message\": message}\n", "\n", "\n", "def _error_result(title: str, error: BaseException, user_file: str | None) -> dict:\n", " \"\"\"Результат упавшего теста: статус, сообщение, тип исключения и строка в коде решения.\"\"\"\n", " line = None\n", " if user_file: # самый глубокий кадр в коде решения; ошибка внутри самих тестов — без номера строки\n", " tb = error.__traceback__\n", " while tb is not None:\n", " if tb.tb_frame.f_code.co_filename == user_file:\n", " line = tb.tb_lineno\n", " tb = tb.tb_next\n", " status, message = \"error\", f\"{type(error).__name__}: {error}\"\n", " if isinstance(error, NotImplementedError):\n", " status, message, line = \"not_written\", \"функция ещё не написана\", None\n", " elif isinstance(error, AssertionError):\n", " status, message = \"failed\", str(error) or \"проверка не прошла\"\n", " elif isinstance(error, RecursionError):\n", " message = \"RecursionError: слишком глубокая рекурсия — проверьте базовый случай и то, что задача уменьшается\"\n", " elif isinstance(error, MemoryError) or (isinstance(error, OverflowError) and \"index-sized\" in str(error)):\n", " message = f\"{type(error).__name__}: не хватило памяти — возможно, создаётся слишком большая структура данных\"\n", " return {\"title\": title, \"status\": status, \"message\": message, \"error_type\": type(error).__name__, \"line\": line}\n", "\n", "\n", "def _run_tests(verbose: bool = True, on_start=None, on_result=None, user_file: str | None = None) -> list[dict]:\n", " \"\"\"Запускает тесты задачи (_TESTS — функции из tests.py) по порядку, каждый — с таймаутом.\n", "\n", " Возвращает список результатов: {\"title\", \"status\", \"message\", \"error_type\", \"line\"}, где status —\n", " passed · failed · error · not_written · timeout · not_run. Если тест завис, при verbose=True печатает\n", " итог и завершает процесс: зависший поток остановить нельзя. on_start(i) и on_result(i, результат)\n", " вызываются по мере выполнения; user_file — имя файла с кодом решения для номеров строк в ошибках.\n", " \"\"\"\n", " import os\n", " import sys\n", "\n", " if verbose:\n", " try: # ✓ и кириллица в консоли Windows со старой кодировкой\n", " sys.stdout.reconfigure(encoding=\"utf-8\")\n", " except Exception: # noqa: BLE001 — reconfigure может не быть (перенаправленный вывод, браузер)\n", " pass\n", "\n", " tests = list(_TESTS)\n", " results: list[dict] = []\n", " not_written = hung = False\n", " for index, fn in enumerate(tests):\n", " info = _test_info(fn)\n", " outcome: dict = {}\n", "\n", " def target(fn=fn, outcome=outcome):\n", " try:\n", " fn()\n", " except BaseException as e:\n", " outcome[\"error\"] = e\n", "\n", " if on_start:\n", " on_start(index)\n", " if not _call_with_timeout(target, info[\"timeout\"]):\n", " results.append({\"title\": info[\"title\"], \"status\": \"timeout\", \"message\": info[\"timeout_message\"], \"error_type\": None, \"line\": None})\n", " for other in tests[index + 1:]:\n", " results.append({\"title\": _test_info(other)[\"title\"], \"status\": \"not_run\", \"message\": \"не запускался: предыдущий тест завис\", \"error_type\": None, \"line\": None})\n", " hung = True\n", " break\n", " error = outcome.get(\"error\")\n", " if error is None:\n", " result = {\"title\": info[\"title\"], \"status\": \"passed\", \"message\": \"\", \"error_type\": None, \"line\": None}\n", " else:\n", " result = _error_result(info[\"title\"], error, user_file)\n", " not_written = not_written or result[\"status\"] == \"not_written\"\n", " results.append(result)\n", " if on_result:\n", " on_result(index, result)\n", "\n", " if not_written: # пока функция не написана, «даром» пройденные тесты не засчитываются\n", " for r in results:\n", " if r[\"status\"] == \"passed\":\n", " r.update(status=\"not_written\", message=\"не засчитан, пока функция не написана\")\n", " for r in results:\n", " if len(r[\"message\"]) > 300:\n", " r[\"message\"] = r[\"message\"][:300] + \"…\"\n", "\n", " if verbose:\n", " if not_written:\n", " print(\"Функция ещё не написана — замените raise NotImplementedError своим кодом.\\n\")\n", " for r in results:\n", " mark = {\"passed\": \"✓\", \"not_run\": \"–\"}.get(r[\"status\"], \"✗\")\n", " print(f\"{mark} {r['title']}\")\n", " if r[\"message\"]:\n", " print(f\" {r['message']}\")\n", " passed = sum(r[\"status\"] == \"passed\" for r in results)\n", " print(\"─\" * 40)\n", " print(f\"Прошло {passed} из {len(results)}\" + (\" — всё верно!\" if passed == len(results) else \"\"))\n", " if hung:\n", " print(\"Выполнение остановлено: один из тестов завис.\")\n", " sys.stdout.flush()\n", " os._exit(1)\n", " return results\n", "\n", "\n", "def _check(*tests, names=()):\n", " \"\"\"Запускает проверки упражнения и печатает ✓ / ✗ и итог — как на сайте.\"\"\"\n", " for name in names:\n", " if \".\" in name: # «Класс.метод» из заготовки: класс должен быть объявлен\n", " if not isinstance(globals().get(name.split(\".\")[0]), type):\n", " print(f\"✗ класс {name.split('.')[0]} не объявлен — выполните ячейку упражнения\")\n", " return\n", " continue\n", " if name not in globals():\n", " print(f\"✗ переменная {name} не создана — выполните ячейку упражнения\")\n", " return\n", " if globals()[name] is Ellipsis:\n", " print(f\"✗ {name} пока равна ... — замените многоточие своим кодом\")\n", " return\n", " globals()[\"_TESTS\"] = list(tests)\n", " _run_tests()" ], "execution_count": null, "outputs": [], "id": "setup" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Как сервисы угадывают, что вам понравится? Один из самых простых и понятных способов — **k ближайших соседей**\n", "(k-nearest neighbors, kNN): найти `k` самых похожих на вас людей и посмотреть, что нравится им. «Похожие» — это\n", "близкие по расстоянию, если каждого человека записать строкой чисел. Метод хорошо разобран, например, в книге\n", "«Грокаем алгоритмы» (глава 10). Здесь соберём его сами из того, что уже знаем: разности с транслированием,\n", "`np.linalg.norm`, `np.argsort`.\n", "\n", "## Шаг 1. Похожие гости\n", "\n", "Восемь постоянных гостей кофейни оценили шесть напитков по шкале от 1 до 5. Столбцы: эспрессо, капучино, латте,\n", "раф, чай, какао. Новая гостья Оля оценила первые пять, а какао не пробовала. Понравится ли оно ей?" ], "id": "text-10" }, { "cell_type": "code", "metadata": {}, "source": [ "# Оценки гостей\n", "import numpy as np\n", "\n", "drinks = np.array([\"эспрессо\", \"капучино\", \"латте\", \"раф\", \"чай\", \"какао\"])\n", "ratings = np.array([\n", " [5, 4, 2, 1, 2, 1],\n", " [2, 3, 5, 5, 3, 5],\n", " [4, 5, 3, 2, 1, 2],\n", " [1, 2, 4, 5, 4, 4],\n", " [5, 5, 3, 2, 2, 1],\n", " [3, 3, 3, 3, 5, 3],\n", " [2, 2, 5, 4, 3, 5],\n", " [4, 3, 2, 2, 4, 2],\n", "])\n", "olya = np.array([2, 3, 5, 4, 3]) # без какао\n", "print(ratings.shape, olya.shape)\n", "print(drinks[:5])" ], "execution_count": null, "outputs": [], "id": "data" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Расстояние до каждого гостя\n", "\n", "Сохраните в `dists` расстояние от оценок Оли `olya` до оценок каждого гостя — только по первым пяти напиткам,\n", "которые Оля пробовала.\n", "\n", "
Подсказка 1\n", "\n", "Первые пять столбцов — `ratings[:, :5]`, таблица `(8, 5)`; `olya` — `(5,)`, разность транслируется.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "`np.linalg.norm(ratings[:, :5] - olya, axis=1)`.\n", "\n", "
" ], "id": "similar-task" }, { "cell_type": "code", "metadata": {}, "source": [ "dists = ..." ], "execution_count": null, "outputs": [], "id": "similar" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def test_dists():\n", " \"dists — расстояния до восьми гостей\"\n", " assert isinstance(dists, np.ndarray), \"dists — одно число: norm без оси считает всю таблицу разом\"\n", " assert dists.shape == (8,), f\"у dists форма {dists.shape}, а гостей 8\"\n", " assert np.allclose(dists, [5.385165, 1.0, 4.472136, 2.236068, 4.690416, 3.162278, 1.0, 4.242641], atol=1e-5), (\n", " f\"dists = {np.round(dists, 3)}: сравнивайте только первые пять столбцов\"\n", " )\n", "\n", "_check(test_dists, names=[\"dists\"])" ], "execution_count": null, "outputs": [], "id": "similar-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "dists = np.linalg.norm(ratings[:, :5] - olya, axis=1)\n", "```\n", "\n", "
" ], "id": "similar-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 2. Три ближайших\n", "\n", "`np.argsort` возвращает номера в порядке возрастания — первые `k` из них и есть ближайшие соседи." ], "id": "text-31" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Соседи Оли\n", "\n", "Сохраните в `neighbors` номера трёх гостей, ближайших к Оле.\n", "\n", "
Подсказка 1\n", "\n", "`np.argsort(dists)` — от ближнего к дальнему; первые три — срез `[:3]`.\n", "\n", "
" ], "id": "neighbors-task" }, { "cell_type": "code", "metadata": {}, "source": [ "neighbors = ..." ], "execution_count": null, "outputs": [], "id": "neighbors" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_neighbors():\n", " \"neighbors — три ближайших гостя\"\n", " assert isinstance(neighbors, np.ndarray), f\"neighbors — это {type(neighbors).__name__}, а нужен массив номеров\"\n", " assert len(neighbors) == 3, f\"в neighbors {len(neighbors)} номеров, а соседей нужно три\"\n", " assert sorted(neighbors.tolist()) != [0, 2, 4], \"это три самых далёких гостя: argsort упорядочивает по возрастанию, ближние — в начале\"\n", " assert sorted(neighbors.tolist()) == [1, 3, 6], f\"neighbors = {neighbors.tolist()} — это не три ближайших к Оле гостя\"\n", "\n", "_check(test_neighbors, names=[\"neighbors\"])" ], "execution_count": null, "outputs": [], "id": "neighbors-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "neighbors = np.argsort(dists)[:3]\n", "```\n", "\n", "
" ], "id": "neighbors-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 3. Предсказание\n", "\n", "Прогноз для Оли — средняя оценка какао у её соседей. Массив номеров выбирает строки таблицы так же, как\n", "элементы одномерного массива в уроке о сортировке: `ratings[neighbors]` — таблица из трёх строк." ], "id": "text-41" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Понравится ли какао\n", "\n", "Сохраните в `cocoa_pred` среднюю оценку какао (столбец 5) у трёх соседей Оли.\n", "\n", "
Подсказка 1\n", "\n", "Строки соседей — `ratings[neighbors]`; столбец какао — `[:, 5]`.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "`ratings[neighbors][:, 5].mean()`.\n", "\n", "
" ], "id": "predict-task" }, { "cell_type": "code", "metadata": {}, "source": [ "cocoa_pred = ..." ], "execution_count": null, "outputs": [], "id": "predict" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_pred():\n", " \"cocoa_pred — прогноз оценки какао\"\n", " assert np.shape(cocoa_pred) == (), \"cocoa_pred — массив, а нужно одно число: средняя оценка какао у соседей\"\n", " assert abs(cocoa_pred - 2.875) > 1e-6, \"это средняя какао у всех гостей; нужна — у трёх соседей\"\n", " assert abs(cocoa_pred - 14 / 3) < 1e-9, f\"cocoa_pred = {cocoa_pred} — это не средняя оценка какао у трёх соседей\"\n", "\n", "_check(test_pred, names=[\"cocoa_pred\"])" ], "execution_count": null, "outputs": [], "id": "predict-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "cocoa_pred = ratings[neighbors][:, 5].mean()\n", "```\n", "\n", "
" ], "id": "predict-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "*После решения упражнения выше:*\n", "\n", "Прогноз 4.7 из 5 — какао Оле стоит предложить. Для сравнения, средняя оценка какао у всех гостей — около 2.9:\n", "соседи знают об Оле больше, чем «средний гость»." ], "id": "component-54" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ниже первая строка — средние оценки трёх соседей Оли по всем шести напиткам, вторая — средние всех гостей:" ], "id": "text-58" }, { "cell_type": "code", "metadata": {}, "source": [ "# Вкусы соседей по всем напиткам\n", "print(np.round(ratings[neighbors].mean(axis=0), 1))\n", "print(np.round(ratings.mean(axis=0), 1))" ], "execution_count": null, "outputs": [], "id": "recommend" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 4. Прогноз продаж\n", "\n", "Тот же метод предсказывает числа. Кофейня записывала для каждого дня три **признака** — температуру, выходной ли\n", "это (1 или 0) и была ли акция (1 или 0) — и сколько чашек продали. Завтра будний день, +17 °C, без акции.\n", "Сколько варить?" ], "id": "text-62" }, { "cell_type": "code", "metadata": {}, "source": [ "# Двенадцать прошлых дней\n", "days = np.array([\n", " # температура, выходной, акция\n", " [5, 0, 0],\n", " [12, 0, 1],\n", " [18, 1, 0],\n", " [22, 1, 1],\n", " [8, 1, 0],\n", " [25, 0, 0],\n", " [15, 0, 1],\n", " [19, 0, 0],\n", " [3, 1, 1],\n", " [16, 1, 0],\n", " [28, 1, 0],\n", " [10, 0, 0],\n", "])\n", "cups = np.array([140, 190, 260, 330, 250, 150, 200, 155, 280, 265, 240, 145])\n", "tomorrow = np.array([17, 0, 0])\n", "print(days.shape, cups.shape)" ], "execution_count": null, "outputs": [], "id": "days" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 4. Соседи по сырым признакам\n", "\n", "Сохраните в `naive_dists` расстояние от завтрашнего дня `tomorrow` до каждого прошлого дня по признакам `days`,\n", "в `naive_nb` — номера четырёх ближайших дней, а в `naive_pred` — среднее число чашек `cups` в эти дни.\n", "\n", "
Подсказка 1\n", "\n", "Как в шагах 1–3: `np.linalg.norm(days - tomorrow, axis=1)`, `np.argsort(…)[:4]`.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "`cups[naive_nb].mean()`.\n", "\n", "
" ], "id": "naive-task" }, { "cell_type": "code", "metadata": {}, "source": [ "naive_dists = ...\n", "naive_nb = ...\n", "naive_pred = ..." ], "execution_count": null, "outputs": [], "id": "naive" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 4 — выполните после своего решения\n", "def test_dists():\n", " \"naive_dists — расстояния до двенадцати дней\"\n", " assert isinstance(naive_dists, np.ndarray) and naive_dists.shape == (12,), \"naive_dists — 12 расстояний\"\n", "\n", "\n", "def test_nb():\n", " \"naive_nb — четыре ближайших дня\"\n", " assert len(naive_nb) == 4, f\"в naive_nb {len(naive_nb)} номеров, а нужно четыре\"\n", " assert sorted(naive_nb.tolist()) == [2, 6, 7, 9], f\"naive_nb = {naive_nb.tolist()} — это не четыре ближайших дня по сырым признакам\"\n", "\n", "\n", "def test_pred():\n", " \"naive_pred — прогноз по сырым признакам\"\n", " assert np.shape(naive_pred) == (), \"naive_pred — одно число: средняя cups у соседей\"\n", " assert naive_pred == 220, f\"naive_pred = {naive_pred} — это не средняя cups четырёх соседей\"\n", "\n", "_check(test_dists, test_nb, test_pred, names=[\"naive_dists\",\"naive_nb\",\"naive_pred\"])" ], "execution_count": null, "outputs": [], "id": "naive-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "naive_dists = np.linalg.norm(days - tomorrow, axis=1)\n", "naive_nb = np.argsort(naive_dists)[:4]\n", "naive_pred = cups[naive_nb].mean()\n", "```\n", "\n", "
" ], "id": "naive-solution" }, { "cell_type": "code", "metadata": {}, "source": [ "# Кто оказался соседом\n", "print(days[naive_nb])\n", "print(cups[naive_nb])" ], "execution_count": null, "outputs": [], "id": "naive-days" }, { "cell_type": "markdown", "metadata": {}, "source": [ "*После решения упражнения выше:*\n", "\n", "Среди «похожих» дней оказались выходные с продажами 260 и 265 чашек — хотя завтра будний день. Почему? Температура\n", "меняется от 3 до 28 — разница в 5 градусов даёт в расстоянии 5, а разница «выходной или будний» — всего 1.\n", "Признак с большими числами **заглушает** остальные." ], "id": "component-81" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Шаг 5. Нормализация\n", "\n", "Решение — привести каждый признак к одной шкале 0–1, как в уроке о нормализации: `(x - min) / (max - min)` по\n", "каждому столбцу. Минимум и максимум берутся по прошлым дням, и завтрашний день приводится **теми же** числами." ], "id": "text-86" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 5. Соседи после нормализации\n", "\n", "Приведите признаки к 0–1: `lo` и `hi` — минимум и максимум каждого столбца `days`, `days_n` — нормализованная\n", "таблица, `tomorrow_n` — нормализованный завтрашний день. Затем сохраните в `scaled_nb` номера четырёх ближайших\n", "дней по нормализованным признакам, а в `scaled_pred` — среднее число чашек в эти дни.\n", "\n", "
Подсказка 1\n", "\n", "`lo = days.min(axis=0)`, `hi = days.max(axis=0)`; `days_n = (days - lo) / (hi - lo)` — транслирование по строкам.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "`tomorrow_n = (tomorrow - lo) / (hi - lo)`; дальше — как в шаге 4.\n", "\n", "
" ], "id": "scaled-task" }, { "cell_type": "code", "metadata": {}, "source": [ "lo = ...\n", "hi = ...\n", "days_n = ...\n", "tomorrow_n = ...\n", "scaled_nb = ...\n", "scaled_pred = ..." ], "execution_count": null, "outputs": [], "id": "scaled" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 5 — выполните после своего решения\n", "def test_scale():\n", " \"days_n и tomorrow_n — признаки на шкале 0–1\"\n", " assert np.shape(lo) == (3,) and np.shape(hi) == (3,), \"lo и hi — по числу на признак\"\n", " assert isinstance(days_n, np.ndarray) and days_n.shape == (12, 3), \"days_n — таблица той же формы, что days\"\n", " assert days_n.min() == 0 and days_n.max() == 1, \"days_n должна быть от 0 до 1 в каждом столбце\"\n", " assert np.shape(tomorrow_n) == (3,), \"tomorrow_n — три нормализованных признака завтрашнего дня\"\n", " assert not np.isnan(tomorrow_n).any(), \"в tomorrow_n есть nan: завтрашний день приводят теми же lo и hi, что и прошлые дни\"\n", " assert np.allclose(tomorrow_n, [0.56, 0, 0]), f\"tomorrow_n = {tomorrow_n}: приводите теми же lo и hi, что и days\"\n", "\n", "\n", "def test_nb():\n", " \"scaled_nb — четыре ближайших дня после нормализации\"\n", " assert len(scaled_nb) == 4, f\"в scaled_nb {len(scaled_nb)} номеров, а нужно четыре\"\n", " assert sorted(scaled_nb.tolist()) == [0, 5, 7, 11], f\"scaled_nb = {scaled_nb.tolist()} — это не четыре ближайших дня после нормализации\"\n", "\n", "\n", "def test_pred():\n", " \"scaled_pred — прогноз после нормализации\"\n", " assert np.shape(scaled_pred) == (), \"scaled_pred — одно число\"\n", " assert scaled_pred == 147.5, f\"scaled_pred = {scaled_pred} — это не средняя cups четырёх соседей\"\n", "\n", "_check(test_scale, test_nb, test_pred, names=[\"lo\",\"hi\",\"days_n\",\"tomorrow_n\",\"scaled_nb\",\"scaled_pred\"])" ], "execution_count": null, "outputs": [], "id": "scaled-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "lo = days.min(axis=0)\n", "hi = days.max(axis=0)\n", "days_n = (days - lo) / (hi - lo)\n", "tomorrow_n = (tomorrow - lo) / (hi - lo)\n", "scaled_nb = np.argsort(np.linalg.norm(days_n - tomorrow_n, axis=1))[:4]\n", "scaled_pred = cups[scaled_nb].mean()\n", "```\n", "\n", "
" ], "id": "scaled-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: нормализовать новый объект своими числами.**\n", ">\n", "> Завтрашний день — одна строка: его собственные минимум и максимум бессмысленны. Новые данные всегда приводят\n", "> к шкале теми же `lo` и `hi`, что и старые, — иначе они окажутся в другой системе координат." ], "id": "component-101" }, { "cell_type": "code", "metadata": {}, "source": [ "# Два прогноза\n", "print(\"соседи без нормализации:\", days[naive_nb][:, 1].sum(), \"выходных из 4 →\", naive_pred, \"чашек\")\n", "print(\"соседи после нормализации:\", days[scaled_nb][:, 1].sum(), \"выходных из 4 →\", scaled_pred, \"чашек\")" ], "execution_count": null, "outputs": [], "id": "summary" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Выводы" ], "id": "text-107" }, { "cell_type": "markdown", "metadata": {}, "source": [ "*После решения всех упражнений урока:*\n", "\n", "После нормализации соседями стали будние дни без акции — те, что действительно похожи на завтрашний, — и прогноз\n", "упал с 220 до 148 чашек: сырые признаки завысили бы заказ почти в полтора раза. Метод ближайших соседей — это\n", "всего три операции NumPy: разность с транслированием, норма по строкам и `argsort`. А главный урок проекта —\n", "перед тем как измерять расстояния, признаки приводят к одной шкале." ], "id": "component-110" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Подробнее в справочнике:** [numpy/linalg](https://ds-edu-trainer.vercel.app/reference/numpy/linalg) · [numpy/sorting](https://ds-edu-trainer.vercel.app/reference/numpy/sorting) · [numpy/broadcasting](https://ds-edu-trainer.vercel.app/reference/numpy/broadcasting)" ], "id": "more" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }