import numpy as np
import matplotlib.pyplot as plt

from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MinMaxScaler

plt.rcParams["figure.figsize"] = (8, 5)
plt.rcParams["font.size"] = 12

print("Библиотеки загружены")

X = np.array([
    [900, 2],
    [850, 3],
    [780, 2],
    [820, 4],
    [740, 3],
    [880, 5],
    [350, 9],
    [420, 8],
    [300, 10],
    [450, 9],
    [500, 7],
    [380, 6],
], dtype=float)

y = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1])
query = np.array([700, 9], dtype=float)

class_names = {0: "Воин", 1: "Маг"}
class_colors = {0: "tomato", 1: "royalblue"}

print("Размер X:", X.shape)
print("Новый персонаж:", query)

def plot_dataset(ax, X_plot, y_plot, query_plot=None, title="Персонажи"):
    for class_id in np.unique(y_plot):
        mask = y_plot == class_id
        ax.scatter(
            X_plot[mask, 0],
            X_plot[mask, 1],
            color=class_colors[class_id],
            edgecolor="black",
            s=90,
            label=class_names[class_id],
        )

    if query_plot is not None:
        ax.scatter(
            query_plot[0],
            query_plot[1],
            marker="*",
            color="gold",
            edgecolor="black",
            linewidth=1.2,
            s=320,
            label="Новый персонаж",
            zorder=5,
        )

    ax.set_xlabel("Здоровье")
    ax.set_ylabel("Магическая сила")
    ax.set_title(title)
    ax.grid(alpha=0.25)
    ax.legend()


fig, ax = plt.subplots()
plot_dataset(ax, X, y, query, "Кто этот новый персонаж?")
plt.show()

def l1_distance(a, b):
    return np.sum(np.abs(a - b))


def l2_distance(a, b):
    return np.sqrt(np.sum((a - b) ** 2))


def linf_distance(a, b):
    return np.max(np.abs(a - b))


a = np.array([1, 2])
b = np.array([4, 6])

print("L1:  ", l1_distance(a, b))
print("L2:  ", l2_distance(a, b))
print("Linf:", linf_distance(a, b))

assert np.isclose(l1_distance(a, b), 7)
assert np.isclose(l2_distance(a, b), 5)
assert np.isclose(linf_distance(a, b), 4)

distance_functions = {
    "L1": l1_distance,
    "L2": l2_distance,
    "Linf": linf_distance,
}

for metric_name, metric_function in distance_functions.items():
    distances = np.array([metric_function(point, query) for point in X])
    nearest_index = np.argmin(distances)

    print(
        f"{metric_name}: ближайший объект {X[nearest_index]}, "
        f"класс — {class_names[y[nearest_index]]}, "
        f"расстояние — {distances[nearest_index]:.2f}"
    )

knn_raw = KNeighborsClassifier(
    n_neighbors=3,
    metric="euclidean",
)

knn_raw.fit(X, y)
prediction_raw = knn_raw.predict(query.reshape(1, -1))[0]
distances_raw, indices_raw = knn_raw.kneighbors(query.reshape(1, -1))

indices_raw = indices_raw[0]
distances_raw = distances_raw[0]

print("Предсказание:", class_names[prediction_raw])
print("Индексы соседей:", indices_raw)
print("Классы соседей:", [class_names[label] for label in y[indices_raw]])
print("Расстояния:", np.round(distances_raw, 2))

def plot_neighbors(
    ax,
    X_plot,
    y_plot,
    query_plot,
    neighbor_indices,
    prediction,
    title,
):
    plot_dataset(ax, X_plot, y_plot, query_plot, title)

    ax.scatter(
        X_plot[neighbor_indices, 0],
        X_plot[neighbor_indices, 1],
        s=250,
        facecolors="none",
        edgecolors="black",
        linewidths=2.2,
        zorder=4,
    )

    for index in neighbor_indices:
        ax.plot(
            [query_plot[0], X_plot[index, 0]],
            [query_plot[1], X_plot[index, 1]],
            color="dimgray",
            linestyle="--",
            alpha=0.75,
            zorder=1,
        )

    ax.set_title(f"{title}\nПредсказание: {class_names[prediction]}")


fig, ax = plt.subplots()
plot_neighbors(
    ax, X, y, query, indices_raw, prediction_raw,
    "Без нормализации, k=3, L2",
)
plt.show()

scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
query_scaled = scaler.transform(query.reshape(1, -1))

print("Минимумы обучающих данных:", scaler.data_min_)
print("Максимумы обучающих данных:", scaler.data_max_)
print("Новая точка до нормализации:   ", query)
print("Новая точка после нормализации:", np.round(query_scaled[0], 3))

knn_scaled = KNeighborsClassifier(
    n_neighbors=3,
    metric="euclidean",
)

knn_scaled.fit(X_scaled, y)
prediction_scaled = knn_scaled.predict(query_scaled)[0]
distances_scaled, indices_scaled = knn_scaled.kneighbors(query_scaled)

indices_scaled = indices_scaled[0]
distances_scaled = distances_scaled[0]

print("Предсказание без нормализации:", class_names[prediction_raw])
print("Предсказание с нормализацией: ", class_names[prediction_scaled])
print("Новые соседи:", indices_scaled)
print("Классы соседей:", [class_names[label] for label in y[indices_scaled]])
print("Расстояния в новом масштабе:", np.round(distances_scaled, 3))

fig, axes = plt.subplots(1, 2, figsize=(15, 5), sharex=True, sharey=True)

plot_neighbors(
    axes[0], X, y, query, indices_raw, prediction_raw,
    "Без нормализации",
)

# Рисуем точки в исходных координатах, но показываем соседей,
# выбранных моделью в нормализованном пространстве.
plot_neighbors(
    axes[1], X, y, query, indices_scaled, prediction_scaled,
    "После min-max нормализации",
)

plt.tight_layout()
plt.show()

metric_names = {
    "L1": "manhattan",
    "L2": "euclidean",
    "Linf": "chebyshev",
}

print(f"{'Нормализация':<17} {'k':<3} {'Метрика':<8} Ответ")
print("-" * 44)

for use_scaling in [False, True]:
    for k in [1, 3, 5, 7]:
        for metric_label, sklearn_metric in metric_names.items():
            if use_scaling:
                model = make_pipeline(
                    MinMaxScaler(),
                    KNeighborsClassifier(n_neighbors=k, metric=sklearn_metric),
                )
            else:
                model = KNeighborsClassifier(
                    n_neighbors=k,
                    metric=sklearn_metric,
                )

            model.fit(X, y)
            prediction = model.predict(query.reshape(1, -1))[0]
            scaling_label = "да" if use_scaling else "нет"

            print(
                f"{scaling_label:<17} {k:<3} {metric_label:<8} "
                f"{class_names[prediction]}"
            )

def plot_decision_regions(
    ax,
    X_train,
    y_train,
    k=3,
    metric="euclidean",
    use_scaling=True,
):
    if use_scaling:
        model = make_pipeline(
            MinMaxScaler(),
            KNeighborsClassifier(n_neighbors=k, metric=metric),
        )
    else:
        model = KNeighborsClassifier(n_neighbors=k, metric=metric)

    model.fit(X_train, y_train)

    x_min, x_max = X_train[:, 0].min() - 80, X_train[:, 0].max() + 80
    y_min, y_max = X_train[:, 1].min() - 1, X_train[:, 1].max() + 1

    xx, yy = np.meshgrid(
        np.linspace(x_min, x_max, 240),
        np.linspace(y_min, y_max, 180),
    )
    grid = np.column_stack([xx.ravel(), yy.ravel()])
    grid_prediction = model.predict(grid).reshape(xx.shape)

    ax.contourf(
        xx,
        yy,
        grid_prediction,
        levels=[-0.5, 0.5, 1.5],
        colors=["mistyrose", "lightblue"],
        alpha=0.8,
    )

    for class_id in np.unique(y_train):
        mask = y_train == class_id
        ax.scatter(
            X_train[mask, 0],
            X_train[mask, 1],
            color=class_colors[class_id],
            edgecolor="black",
            s=70,
            label=class_names[class_id],
        )

    scaling_title = "с нормализацией" if use_scaling else "без нормализации"
    ax.set_title(f"k={k}, {metric}, {scaling_title}")
    ax.set_xlabel("Здоровье")
    ax.set_ylabel("Магическая сила")
    ax.grid(alpha=0.15)

    return model

fig, axes = plt.subplots(2, 2, figsize=(14, 10), sharex=True, sharey=True)

plot_decision_regions(axes[0, 0], X, y, k=1, use_scaling=False)
plot_decision_regions(axes[0, 1], X, y, k=1, use_scaling=True)
plot_decision_regions(axes[1, 0], X, y, k=7, use_scaling=False)
plot_decision_regions(axes[1, 1], X, y, k=7, use_scaling=True)

handles, labels = axes[0, 0].get_legend_handles_labels()
fig.legend(handles, labels, loc="upper center", ncol=2)
fig.suptitle("Как k и нормализация меняют области решений", fontsize=16, y=1.02)
plt.tight_layout()
plt.show()

K = 3
METRIC = "euclidean"
USE_SCALING = True

fig, ax = plt.subplots(figsize=(9, 6))
experiment_model = plot_decision_regions(
    ax,
    X,
    y,
    k=K,
    metric=METRIC,
    use_scaling=USE_SCALING,
)

experiment_prediction = experiment_model.predict(query.reshape(1, -1))[0]
ax.scatter(
    query[0], query[1],
    marker="*", color="gold", edgecolor="black", s=320,
)
ax.set_title(
    ax.get_title() + f"\nНовый персонаж: {class_names[experiment_prediction]}"
)
ax.legend()
plt.show()

В `scikit-learn`	Формула
`manhattan`	$L_1$
`euclidean`	$L_2$
`chebyshev`	$L_\infty$

Семинар: расстояния, нормализация и KNN¶

План занятия¶

1. Данные¶

Обсудите в парах¶

2. Три функции расстояния¶

Мини-эксперимент¶

3. Готовый KNN¶

Обсудите результат¶

4. Min-max нормализация¶

Зафиксируйте вывод¶

5. Эксперименты с $k$ и метрикой¶

Исследовательское задание¶

6. Области решений¶

Что видно на рисунке?¶

7. Самостоятельный эксперимент¶

8. Итоги¶

Мостик к домашней работе¶