Python для Data Science и Машинного обучения

Введение в экосистему Python: настройка окружения и базовые структуры данных

Добро пожаловать в курс «Python для Data Science и Машинного обучения». Это первая статья, которая станет фундаментом для вашего пути в мир анализа данных. Мы не просто изучим синтаксис языка, но и настроим профессиональное рабочее пространство, которое используют специалисты по Data Science во всем мире.

Почему Python стал стандартом в Data Science?

Python — это интерпретируемый язык высокого уровня, который завоевал популярность благодаря своему простому и читаемому синтаксису. Однако в контексте Data Science его сила заключается не только в простоте, но и в экосистеме.

Представьте, что вы строите дом. Python — это ваш набор инструментов (молоток, дрель, пила). Но чтобы построить небоскреб (сложную модель машинного обучения), вам нужны готовые блоки, краны и бетономешалки. В мире Python этими «блоками» являются библиотеки:

• NumPy и Pandas — для работы с данными.
• Matplotlib и Seaborn — для визуализации.
• Scikit-learn, TensorFlow, PyTorch — для машинного обучения.

Настройка окружения: Anaconda и Jupyter

Для начала работы нам нужно место, где мы будем писать код. В отличие от веб-разработки, где часто пишут скрипты в текстовых файлах, в Data Science стандартом является Jupyter Notebook.

Что такое Jupyter Notebook?

Это интерактивная среда, которая позволяет объединять код, текст (как этот), формулы и графики в одном документе. Это идеально подходит для исследований: вы пишете кусочек кода, сразу видите результат (график или таблицу) и описываете свои выводы.

Установка через Anaconda

Самый простой способ получить Python, Jupyter и все необходимые библиотеки сразу — установить дистрибутив Anaconda.

1. Скачайте Anaconda Distribution с официального сайта.
2. Установите её, следуя инструкциям.
3. Запустите Anaconda Navigator и выберите Jupyter Notebook.

Альтернативой для тех, кто не хочет ничего устанавливать, является Google Colab — это облачный Jupyter Notebook от Google, который работает прямо в браузере.

Переменные и базовые типы данных

В Data Science мы постоянно работаем с данными разных типов: числами, категориями, текстом. Давайте разберем, как Python хранит эту информацию.

Присваивание переменных

В Python не нужно объявлять тип переменной заранее (это называется динамической типизацией). Вы просто присваиваете значение имени.

x = 10
name = "Alice"
pi = 3.1415

Основные скалярные типы

1. Integer (int): Целые числа. Используются для счетчиков, индексов.
2. Float (float): Числа с плавающей точкой. Используются для большинства вычислений в Data Science (веса моделей, вероятности).
3. String (str): Строки. Используются для обработки текста (NLP).
4. Boolean (bool): Логический тип (True или False). Нужен для фильтрации данных.

Структуры данных: контейнеры для информации

Работа с одной переменной редко имеет смысл в анализе данных. Обычно мы работаем с коллекциями: списками клиентов, временными рядами цен, наборами признаков. Для этого в Python существуют четыре встроенные структуры данных.

1. Списки (Lists)

Список — это упорядоченная изменяемая коллекция объектов. Это самая часто используемая структура. Списки создаются с помощью квадратных скобок [].

prices = [100, 150, 90, 200]
mixed_list = [1, "data", 3.5, True]

Особенности списков:

• Упорядоченность: Элементы хранятся в том порядке, в котором вы их добавили.
• Индексация: Доступ к элементам осуществляется по индексу, начиная с нуля.

print(prices[0])  # Выведет 100
print(prices[-1]) # Выведет 200 (последний элемент)

• Изменяемость (Mutability): Вы можете изменить элемент списка после его создания.

prices[1] = 160 # Теперь список выглядит как [100, 160, 90, 200]

В Data Science списки часто используются для хранения последовательностей значений перед преобразованием их в более сложные структуры (например, массивы NumPy).

Предположим, у нас есть список значений $x$, и мы хотим найти их среднее арифметическое. Математически это записывается так:

$$\bar{x} = \frac{1}{n} \sum_{i=1}^{n} x_i$$

Где $\bar{x}$ — это среднее значение, $n$ — количество элементов в списке, $\sum$ — знак суммы (мы складываем все элементы), а $x_i$ — каждый отдельный элемент списка.

В коде это выглядит так:

data = [10, 20, 30, 40, 50]
mean = sum(data) / len(data)
print(mean) # 30.0

2. Кортежи (Tuples)

Кортеж очень похож на список, но он неизменяем (immutable). Он создается с помощью круглых скобок ().

dimensions = (1920, 1080)

Если вы попытаетесь сделать dimensions[0] = 1280, Python выдаст ошибку. Зачем это нужно? В Data Science кортежи часто используются для возврата нескольких значений из функции или для хранения конфигураций, которые не должны случайно измениться в процессе работы программы.

3. Словари (Dictionaries)

Словарь — это неупорядоченная коллекция пар «ключ-значение». Это аналог реального словаря, где вы ищете слово (ключ) и получаете его определение (значение). Словари создаются с помощью фигурных скобок {}.

user = {
    "name": "John",
    "age": 30,
    "role": "Data Scientist"
}

Доступ к данным осуществляется по ключу, а не по индексу:

print(user["role"]) # Выведет 'Data Scientist'

В машинном обучении словари часто используются для хранения параметров моделей (гиперпараметров), например: {'learning_rate': 0.01, 'epochs': 100}.

4. Множества (Sets)

Множество — это неупорядоченная коллекция уникальных элементов. Также создается фигурными скобками {}, но без пар ключ-значение, или функцией set().

ids = {101, 102, 101, 103}
print(ids) # Выведет {101, 102, 103}

Обратите внимание, что дубликат 101 исчез. Множества идеально подходят для удаления дубликатов из данных или проверки принадлежности элемента к группе.

Математически операции над множествами в Python соответствуют теории множеств. Например, объединение двух множеств $A$ и $B$:

$$C = A \cup B$$

Где $C$ — результирующее множество, содержащее все уникальные элементы из $A$ и $B$, а $\cup$ — знак объединения.

В Python:

A = {1, 2, 3}
B = {3, 4, 5}
C = A.union(B) # {1, 2, 3, 4, 5}

Управляющие конструкции

Структуры данных бесполезны без возможности их перебирать и проверять условия.

Цикл for

В Python цикл for работает как итератор. Он проходит по каждому элементу коллекции.

scores = [0.85, 0.92, 0.78]
for score in scores:
    print(score * 100)

Условный оператор if

Позволяет выполнять код только при выполнении определенного условия.

accuracy = 0.92
if accuracy > 0.90:
    print("Модель отличная!")
else:
    print("Нужно доработать.")

Заключение

Сегодня мы подготовили почву для серьезной работы. Мы настроили окружение с помощью Anaconda и Jupyter Notebook, а также разобрали базовые кирпичики языка Python: переменные, списки, кортежи, словари и множества. Понимание различий между ними (например, когда использовать кортеж вместо списка) критически важно для написания эффективного кода.

В следующей статье мы перейдем от встроенных структур Python к специализированным инструментам для анализа данных и познакомимся с библиотекой NumPy.

Манипуляция данными и предварительная обработка с использованием библиотек NumPy и Pandas

В предыдущей статье мы познакомились с базовым синтаксисом Python и стандартными структурами данных: списками и словарями. Это отличные инструменты для общей логики программирования. Однако, когда речь заходит о Data Science, где нам приходится обрабатывать миллионы строк данных и выполнять сложные математические операции, стандартных средств Python становится недостаточно.

Представьте, что вам нужно умножить каждый элемент списка из миллиона чисел на 2. В чистом Python вам пришлось бы писать цикл, который обрабатывает каждое число по очереди. Это медленно. В мире больших данных нам нужна скорость и эффективность.

В этой статье мы изучим два столпа, на которых держится весь анализ данных в Python: библиотеки NumPy и Pandas.

NumPy: Фундамент вычислительной математики

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

Почему NumPy быстрее списков?

Списки в Python — это массивы ссылок на объекты. Каждый элемент списка может быть чем угодно: числом, строкой или другим списком. Из-за этой гибкости компьютер тратит много ресурсов на проверку типа данных каждого элемента при операциях.

Массивы NumPy (ndarray) — это типизированные массивы. Это значит, что все элементы в них имеют один и тот же тип (обычно числа). Благодаря этому данные в памяти располагаются плотно, друг за другом, что позволяет процессору обрабатывать их невероятно быстро, используя векторные инструкции.

Создание массивов и векторизация

Для начала работы нужно импортировать библиотеку. Стандартное сокращение — np.

import numpy as np

# Создание массива из списка
arr = np.array([1, 2, 3, 4, 5])

# Арифметические операции (векторизация)
print(arr * 2)
# Результат: [ 2  4  6  8 10]

Обратите внимание: мы умножили массив на 2, и операция применилась ко всем элементам сразу без всяких циклов for. Это называется векторизацией.

Основные операции линейной алгебры

В машинном обучении данные часто представляются в виде матриц. Одной из самых частых операций является перемножение матриц (Dot Product).

Математически произведение двух матриц $A$ (размером $m \times n$) и $B$ (размером $n \times k$) записывается так:

$$C_{ij} = \sum_{k=1}^{n} A_{ik} B_{kj}$$

Где:

• $C_{ij}$ — элемент результирующей матрицы $C$, стоящий на пересечении $i$-й строки и $j$-го столбца.
• $\sum$ — знак суммирования.
• $A_{ik}$ — элемент $i$-й строки матрицы $A$.
• $B_{kj}$ — элемент $j$-го столбца матрицы $B$.

Простыми словами: мы берем строку из первой матрицы, столбец из второй, попарно перемножаем их элементы и складываем результаты.

В NumPy это делается одной командой:

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

# Матричное умножение
C = np.dot(A, B)
print(C)

Pandas: Excel на стероидах

Если NumPy — это мощный двигатель для чисел, то Pandas — это удобная приборная панель. Эта библиотека создана для работы с табличными данными (как в Excel или SQL), но с мощью программирования.

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

Основные структуры данных

1. Series — одномерный массив с метками (похож на одну колонку в Excel).
2. DataFrame — двумерная таблица, где каждый столбец может иметь свой тип данных (числа, строки, даты).

Загрузка и осмотр данных

Чаще всего данные хранятся в файлах CSV (Comma-Separated Values). Загрузим их:

import pandas as pd

# Загрузка данных
df = pd.read_csv('data.csv')

# Просмотр первых 5 строк
print(df.head())

# Общая информация о типах данных и пропусках
print(df.info())

Индексация и выбор данных

В Pandas есть два основных способа выбрать данные:

• .iloc — выбор по позиции (как в списках, по номеру индекса).
• .loc — выбор по метке (по названию индекса или колонки).

# Выбрать первую строку (позиция 0)
print(df.iloc[0])

# Выбрать данные из колонки 'Age' для строк, где индекс равен 'User_1'
# (при условии, что мы установили индексы)
# print(df.loc['User_1', 'Age'])

Фильтрация данных

Одна из самых мощных возможностей Pandas — фильтрация по условию (Boolean Indexing).

Допустим, мы хотим найти всех клиентов старше 30 лет:

# Создаем маску (список True/False)
mask = df['Age'] > 30

# Применяем маску к DataFrame
adults = df[mask]

Предварительная обработка данных (Preprocessing)

В реальном мире данные никогда не бывают чистыми. В них есть пропуски, ошибки, дубликаты. Прежде чем строить модели машинного обучения, данные нужно «помыть».

1. Работа с пропущенными значениями

Пропуски в Pandas обозначаются как NaN (Not a Number). Модели машинного обучения обычно не умеют работать с пропусками, поэтому их нужно либо удалить, либо заполнить.

• Поиск пропусков:

print(df.isna().sum()) # Показывает количество пропусков в каждой колонке

• Удаление: Если пропусков мало, строки с ними можно удалить.

df_clean = df.dropna()

• Заполнение (Импутация): Часто лучше заполнить пропуски средним значением или нулем, чтобы не терять данные.

Математически заполнение средним выглядит так. Пусть $x$ — вектор значений признака, где некоторые значения отсутствуют. Мы вычисляем среднее $\mu$ по имеющимся значениям:

$$\mu = \frac{1}{n} \sum_{i=1}^{n} x_i$$

Где:

• $\mu$ — среднее арифметическое.
• $n$ — количество непропущенных значений.
• $x_i$ — значения признака.

В коде:

mean_age = df['Age'].mean()
df['Age'] = df['Age'].fillna(mean_age)

2. Удаление дубликатов

Повторяющиеся строки могут исказить статистику.

df = df.drop_duplicates()

3. Базовая статистика

Чтобы понять природу данных, полезно посмотреть на их статистическое описание.

print(df.describe())

Метод .describe() покажет количество записей, среднее, стандартное отклонение, минимум, максимум и квартили для всех числовых колонок.

Заключение

Мы разобрали основы работы с NumPy и Pandas. Теперь вы умеете:

1. Создавать быстрые массивы и выполнять математические операции.
2. Загружать табличные данные и фильтровать их.
3. Очищать данные от пропусков и дубликатов.

Эти навыки — это 80% работы Data Scientist'а. В следующей статье мы научимся превращать эти сухие цифры в понятные графики с помощью библиотек визуализации Matplotlib и Seaborn.

Разведочный анализ данных (EDA) и визуализация с помощью Matplotlib и Seaborn

В предыдущих статьях мы настроили рабочее окружение и научились манипулировать табличными данными с помощью Pandas. Теперь у нас есть очищенный DataFrame, но сухие цифры в таблице редко дают полное понимание картины. Человеческий мозг плохо воспринимает тысячи строк текста, но мгновенно находит паттерны на изображениях.

В этой статье мы займемся Разведочным анализом данных (Exploratory Data Analysis, или EDA). Это процесс, в ходе которого мы «знакомимся» с данными, ищем закономерности, аномалии и проверяем гипотезы с помощью визуализации.

Нашими инструментами станут две самые популярные библиотеки Python: Matplotlib и Seaborn.

Зачем нужна визуализация?

Представьте, что у вас есть таблица с данными о продажах. Вы посчитали среднее значение и стандартное отклонение. Кажется, что вы знаете о данных всё. Но существует знаменитый пример — Квартет Анскомба. Это четыре набора данных, у которых одинаковые средние значения, дисперсии и корреляции, но если построить их графики, они выглядят совершенно по-разному.

Визуализация — это единственный способ увидеть структуру данных, которую скрывает сухая статистика.

Matplotlib: Фундамент графики в Python

Matplotlib — это базовая библиотека для построения графиков в Python. Она очень мощная и позволяет настроить каждый пиксель изображения, но её синтаксис может показаться многословным.

Анатомия графика

Чтобы эффективно работать с Matplotlib, нужно понимать иерархию объектов:

1. Figure (Фигура): Это «холст» или окно, в котором рисуется всё содержимое.
2. Axes (Оси): Это сам график (система координат) внутри фигуры. На одной фигуре может быть несколько осей (например, два графика рядом).
3. Axis (Ось): Это конкретная ось X или Y с делениями и подписями.

Простой пример

import matplotlib.pyplot as plt
import numpy as np

# Генерируем данные
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Создаем график
plt.figure(figsize=(10, 6)) # Размер 10 на 6 дюймов
plt.plot(x, y, label='Синус', color='blue')
plt.title('График функции синуса')
plt.xlabel('Время')
plt.ylabel('Амплитуда')
plt.legend()
plt.grid(True)
plt.show()

Команда plt.plot() строит линейный график. Мы последовательно добавляем заголовок, подписи осей и сетку.

Seaborn: Красота и статистика

Если Matplotlib — это набор инструментов (молоток, кисть, краски), то Seaborn — это готовый художник, который знает, как рисовать красиво и статистически грамотно. Seaborn работает поверх Matplotlib, упрощая код и улучшая дизайн.

Для работы нам понадобятся обе библиотеки:

import seaborn as sns
import matplotlib.pyplot as plt

Одномерный анализ (Univariate Analysis)

Первый шаг EDA — изучить каждую переменную отдельно. Нас интересует распределение данных.

Гистограмма (Histogram)

Гистограмма показывает, как часто встречаются значения в определенном диапазоне. Это лучший способ понять форму распределения (нормальное, скошенное, бимодальное).

# Загрузим встроенный датасет о чаевых
tips = sns.load_dataset('tips')

# Построение гистограммы распределения общего чека
sns.histplot(data=tips, x='total_bill', kde=True)
plt.title('Распределение суммы чека')
plt.show()

Параметр kde=True добавляет плавную линию (Kernel Density Estimate), которая сглаживает гистограмму.

Ящик с усами (Boxplot)

Boxplot (или диаграмма размаха) — незаменимый инструмент для поиска выбросов (аномальных значений). Чтобы понять его, нам нужно немного математики описательной статистики.

Boxplot строится на основе квартилей — значений, которые делят упорядоченные данные на 4 равные части.

• $Q_1$ (25-й перцентиль): 25% данных находятся ниже этого значения.
• $Q_2$ (Медиана): 50% данных находятся ниже этого значения.
• $Q_3$ (75-й перцентиль): 75% данных находятся ниже этого значения.

Ключевое понятие здесь — Межквартильный размах (Interquartile Range, IQR). Он показывает разброс центральной половины данных.

$$IQR = Q_3 - Q_1$$

Где:

• $IQR$ — межквартильный размах.
• $Q_3$ — третий квартиль (75%).
• $Q_1$ — первый квартиль (25%).

«Усы» ящика обычно простираются на расстояние $1.5 \times IQR$. Всё, что находится за пределами усов, считается выбросом.

Формула для определения границ выбросов:

$$\text{Lower Bound} = Q_1 - 1.5 \times IQR$$

$$\text{Upper Bound} = Q_3 + 1.5 \times IQR$$

Где:

• $\text{Lower Bound}$ — нижняя граница, ниже которой значения считаются аномально низкими.
• $\text{Upper Bound}$ — верхняя граница, выше которой значения считаются аномально высокими.

В коде это выглядит очень просто:

sns.boxplot(x=tips['total_bill'])
plt.title('Boxplot суммы чека')
plt.show()

Двумерный анализ (Bivariate Analysis)

Теперь посмотрим, как две переменные зависят друг от друга.

Диаграмма рассеяния (Scatter Plot)

Показывает взаимосвязь между двумя числовыми переменными. Каждая точка — это одно наблюдение.

# Зависимость чаевых от суммы чека
sns.scatterplot(data=tips, x='total_bill', y='tip', hue='sex')
plt.title('Связь между чеком и чаевыми')
plt.show()

Параметр hue='sex' раскрашивает точки в разные цвета в зависимости от пола клиента. Это позволяет добавить третье измерение (категориальное) на плоский график.

Тепловая карта корреляции (Heatmap)

Корреляция — это мера линейной связи между двумя переменными. Самый популярный коэффициент — коэффициент корреляции Пирсона ($r$). Он меняется от -1 до 1.

Математическая формула коэффициента Пирсона:

$$r = \frac{\sum_{i=1}^{n} (x_i - \bar{x})(y_i - \bar{y})}{\sqrt{\sum_{i=1}^{n} (x_i - \bar{x})^2} \sqrt{\sum_{i=1}^{n} (y_i - \bar{y})^2}}$$

Где:

• $r$ — коэффициент корреляции.
• $n$ — количество наблюдений.
• $x_i, y_i$ — значения переменных $x$ и $y$ для $i$-го наблюдения.
• $\bar{x}, \bar{y}$ — средние значения переменных $x$ и $y$.
• $\sum$ — знак суммы.

Если $r = 1$, это полная положительная связь (рост одной переменной ведет к росту другой). Если $r = -1$ — полная отрицательная связь. Если $r = 0$ — линейной связи нет.

Чтобы визуализировать корреляцию сразу всех переменных, используют тепловую карту:

# Вычисляем матрицу корреляции (только для числовых колонок)
corr_matrix = tips.corr(numeric_only=True)

# Строим тепловую карту
sns.heatmap(corr_matrix, annot=True, cmap='coolwarm')
plt.title('Матрица корреляции')
plt.show()

Pairplot: Взгляд с высоты птичьего полета

Если вы хотите увидеть всё и сразу, используйте pairplot. Он строит диаграммы рассеяния для каждой пары переменных и гистограммы распределения на диагонали.

sns.pairplot(tips, hue='day')
plt.show()

Это невероятно мощный инструмент для быстрого старта анализа нового датасета.

Заключение

Разведочный анализ данных (EDA) — это искусство задавать вопросы данным с помощью графиков. Мы изучили:

1. Matplotlib для создания основы графиков.
2. Seaborn для красивой и быстрой статистической визуализации.
3. Гистограммы и Boxplot для анализа распределений и поиска выбросов.
4. Scatterplot и Heatmap для поиска взаимосвязей и корреляций.

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

Основы машинного обучения: обучение с учителем и библиотека Scikit-Learn

Мы прошли долгий путь: настроили окружение, научились манипулировать данными с Pandas и визуализировать их с помощью Seaborn. Теперь, когда данные очищены и изучены, мы подошли к самому захватывающему этапу — Машинному обучению (Machine Learning).

В этой статье мы разберем фундаментальные концепции обучения с учителем и познакомимся с библиотекой Scikit-Learn, которая является золотым стандартом классического машинного обучения в Python.

Что такое Машинное обучение?

В традиционном программировании вы пишете правила. Например, «если сумма чека больше 5000 рублей, сделай скидку 10%». Вы явно задаете логику.

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

Машинное обучение — это область искусственного интеллекта, которая дает компьютерам способность учиться без явного программирования. — Артур Сэмюэл

Обучение с учителем (Supervised Learning)

Это самый распространенный тип машинного обучения. Представьте, что вы учите ребенка различать фрукты. Вы показываете яблоко и говорите: «Это яблоко». Показываете банан: «Это банан». После множества примеров ребенок начинает сам определять фрукты.

В терминах Data Science:

• Признаки (Features, $X$): Характеристики объекта (вес фрукта, цвет, текстура).
• Целевая переменная (Target, $y$): Правильный ответ (название фрукта).

Задача модели — найти математическую зависимость $f$, такую что:

$$y = f(X)$$

Где:

• $y$ — предсказанное значение (целевая переменная).
• $f$ — функция (модель), которую мы ищем.
• $X$ — входные данные (признаки).

Два типа задач обучения с учителем

В зависимости от того, что именно мы предсказываем, задачи делятся на два типа:

1. Регрессия (Regression): Целевая переменная — это число (непрерывная величина).
   • Примеры: Предсказание цены квартиры, температуры воздуха, выручки магазина.
2. Классификация (Classification): Целевая переменная — это категория (класс, метка).
   • Примеры: Спам или не спам, болен пациент или здоров, кошка или собака на фото.

Библиотека Scikit-Learn

Scikit-Learn (или sklearn) — это самая популярная библиотека для ML в Python. Её любят за единообразный интерфейс. Неважно, используете ли вы простую линейную регрессию или сложный случайный лес — команды будут одни и те же.

Алгоритм работы с Scikit-Learn

1. Импорт: Загружаем нужный класс модели.
2. Инициализация: Создаем экземпляр модели (можно задать настройки — гиперпараметры).
3. Обучение (fit): Скармливаем модели данные ($X$) и ответы ($y$). Здесь происходит магия математики.
4. Предсказание (predict): Просим обученную модель предсказать ответы для новых данных.

Задача Регрессии: Линейная регрессия

Давайте разберем простейший алгоритм — Линейную регрессию. Представьте, что мы хотим предсказать зарплату сотрудника ($y$) на основе его опыта работы в годах ($x$).

Линейная регрессия пытается провести прямую линию через данные, которая описывается уравнением:

$$y = w_0 + w_1 x$$

Где:

• $y$ — предсказываемая зарплата.
• $w_0$ — свободный член (bias), точка пересечения с осью Y (базовая зарплата при нулевом опыте).
• $w_1$ — весовой коэффициент (насколько сильно опыт влияет на зарплату).
• $x$ — опыт работы (признак).

Задача обучения — найти такие $w_0$ и $w_1$, чтобы ошибка предсказания была минимальной.

Пример кода

import numpy as np
from sklearn.linear_model import LinearRegression

# Данные: Опыт работы (X) и Зарплата (y)
# X должен быть двумерным массивом (таблицей), поэтому используем reshape
X = np.array([1, 2, 3, 4, 5]).reshape(-1, 1)
y = np.array([30000, 40000, 55000, 60000, 75000])

# 1. Инициализация
model = LinearRegression()

# 2. Обучение
model.fit(X, y)

# 3. Предсказание для сотрудника с опытом 6 лет
prediction = model.predict([[6]])
print(f"Прогноз зарплаты: {prediction[0]}")

Разделение данных: Train и Test

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

Если студент выучит ответы к экзамену наизусть, он сдаст его на отлично, но не поймет предмет. Это называется переобучением (Overfitting). Чтобы проверить реальные знания, нужны новые вопросы.

Поэтому мы делим данные на две части:

1. Обучающая выборка (Training set): Обычно 70-80% данных. На них модель учится.
2. Тестовая выборка (Test set): Оставшиеся 20-30%. На них мы проверяем качество.

В Scikit-Learn для этого есть функция train_test_split.

Задача Классификации: k-Ближайших Соседей (k-NN)

Рассмотрим задачу классификации на примере алгоритма k-Nearest Neighbors (k-NN). Это простой и интуитивный алгоритм.

Идея: «Скажи мне, кто твой друг, и я скажу, кто ты». Чтобы классифицировать новый объект, алгоритм смотрит на $k$ ближайших к нему объектов из обучающей выборки и выбирает тот класс, который встречается чаще всего.

Пример с ирисами Фишера

Используем встроенный датасет Iris, где по размерам лепестков нужно определить вид цветка.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Загрузка данных
iris = load_iris()
X = iris.data  # Признаки
y = iris.target # Классы (0, 1, 2)

# Разделение на train и test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Инициализация модели (смотрим на 3 соседей)
knn = KNeighborsClassifier(n_neighbors=3)

# Обучение
knn.fit(X_train, y_train)

# Предсказание
y_pred = knn.predict(X_test)

# Оценка точности
accuracy = accuracy_score(y_test, y_pred)
print(f"Точность модели: {accuracy:.2f}")

Оценка качества модели

Как понять, что модель работает хорошо? Нам нужны метрики.

Для классификации часто используют Accuracy (Точность) — долю правильных ответов:

$$\text{Accuracy} = \frac{N_{correct}}{N_{total}}$$

Где:

• $\text{Accuracy}$ — точность модели.
• $N_{correct}$ — количество правильно классифицированных объектов.
• $N_{total}$ — общее количество объектов.

Для регрессии Accuracy не подходит (мы редко угадываем число с точностью до копейки). Там используют MSE (Mean Squared Error) — среднюю квадратичную ошибку:

$$MSE = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2$$

Где:

• $MSE$ — средняя квадратичная ошибка.
• $n$ — количество объектов.
• $\sum$ — знак суммы (суммируем ошибку по всем объектам).
• $y_i$ — реальное значение.
• $\hat{y}_i$ — предсказанное моделью значение.

Чем меньше MSE, тем лучше модель.

Заключение

Сегодня мы сделали огромный шаг вперед. Мы разобрали суть обучения с учителем, узнали разницу между регрессией и классификацией, и построили свои первые модели с помощью Scikit-Learn.

Мы также усвоили критически важное правило: всегда делить данные на обучающую и тестовую выборки, чтобы честно оценивать качество работы алгоритмов.

В следующей статье мы углубимся в метрики качества, потому что простого accuracy часто бывает недостаточно, особенно когда данные несбалансированы.

Оценка качества моделей, подбор гиперпараметров и введение в кластеризацию

В предыдущей статье мы сделали важный шаг: обучили наши первые модели с учителем — линейную регрессию и метод ближайших соседей. Мы даже проверили их точность с помощью метрики accuracy (доля правильных ответов). Казалось бы, дело сделано?

На самом деле, обучение модели (model.fit) — это лишь начало. В реальных проектах Data Science возникают два критических вопроса:

1. Действительно ли модель хороша? (Спойлер: accuracy часто врет).
2. Как сделать модель лучше? (Настройка «ручек» управления).

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

Почему Accuracy недостаточно?

Представьте, что вы строите модель для обнаружения редкого заболевания, которое встречается у 1% населения. Если ваша модель будет просто всем подряд говорить «Здоров», её точность (accuracy) составит 99%. Звучит великолепно, но такая модель абсолютно бесполезна, так как она пропустит всех больных.

Для более глубокой оценки классификации используется Матрица ошибок (Confusion Matrix).

Матрица ошибок

Это таблица, которая показывает, где именно ошибается модель. Она делит все предсказания на 4 категории:

• True Positive (TP): Истинно положительные. Модель сказала «Да», и это правда.
• True Negative (TN): Истинно отрицательные. Модель сказала «Нет», и это правда.
• False Positive (FP): Ложноположительные (Ошибка I рода). Модель сказала «Да», но ошиблась (ложная тревога).
• False Negative (FN): Ложноотрицательные (Ошибка II рода). Модель сказала «Нет», но ошиблась (пропуск цели).

На основе этих значений строятся более надежные метрики.

Precision (Точность) и Recall (Полнота)

Precision отвечает на вопрос: «Если модель назвала объект целевым, какова вероятность, что она права?». Это важно, когда высока цена ложной тревоги (например, спам-фильтр: мы не хотим, чтобы важное письмо улетело в спам).

$$Precision = \frac{TP}{TP + FP}$$

Где:

• $Precision$ — точность.
• $TP$ — количество истинно положительных срабатываний.
• $FP$ — количество ложных срабатываний.

Recall отвечает на вопрос: «Какую долю целевых объектов модель смогла найти?». Это критически важно в медицине: лучше перестраховаться, чем пропустить болезнь.

$$Recall = \frac{TP}{TP + FN}$$

Где:

• $Recall$ — полнота.
• $TP$ — количество истинно положительных срабатываний.
• $FN$ — количество пропущенных целей.

F1-Score

Часто нам нужен баланс между Precision и Recall. Для этого используют их гармоническое среднее — F1-меру.

$$F1 = 2 \times \frac{Precision \times Recall}{Precision + Recall}$$

Где:

• $F1$ — итоговая метрика качества.
• $Precision$ — точность.
• $Recall$ — полнота.

Если одна из метрик (Precision или Recall) близка к нулю, F1-Score тоже упадет до нуля.

Кросс-валидация: защита от случайности

В прошлый раз мы делили данные на train и test один раз. Но что, если нам «повезло» с разделением, и в тест попали самые легкие примеры? Оценка будет завышена.

Чтобы получить честную оценку, используют кросс-валидацию (Cross-Validation).

Метод K-Fold работает так:

1. Весь набор данных делится на $K$ равных частей (фолдов).
2. Модель обучается $K$ раз.
3. Каждый раз одна часть используется как тест, а остальные $K-1$ — как обучение.
4. Итоговая оценка — это среднее значение метрик по всем $K$ прогонам.

В Scikit-Learn это делается одной функцией:

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
# cv=5 означает деление на 5 частей
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')

print(f"Средняя точность: {scores.mean():.2f}")

Подбор гиперпараметров (Hyperparameter Tuning)

У каждой модели есть два типа параметров:

1. Параметры модели: Выучиваются сами в процессе fit (например, веса $w$ в линейной регрессии).
2. Гиперпараметры: Задаются человеком до обучения (например, количество соседей $k$ в k-NN).

Как найти идеальные гиперпараметры? Не перебирать же их вручную?

Grid Search (Поиск по сетке)

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

from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier

# Задаем сетку параметров
param_grid = {'n_neighbors': [3, 5, 7, 9]}

knn = KNeighborsClassifier()

# Запускаем поиск
grid_search = GridSearchCV(knn, param_grid, cv=5)
grid_search.fit(X_train, y_train)

print(f"Лучшие параметры: {grid_search.best_params_}")

Введение в кластеризацию (Clustering)

До сих пор мы занимались обучением с учителем: у нас были правильные ответы $y$. Но что делать, если ответов нет? Представьте, что у вас есть база данных клиентов магазина, и вы хотите разбить их на сегменты (например, «экономные», «богатые», «новички»), но вы заранее не знаете, кто есть кто.

Это задача обучения без учителя (Unsupervised Learning). Самый популярный метод здесь — Кластеризация.

Алгоритм K-Means (К-средних)

Это простой и эффективный алгоритм, который разбивает данные на $k$ групп (кластеров).

Как это работает:

1. Мы выбираем число кластеров $k$.
2. Алгоритм случайно ставит $k$ точек в пространстве данных — это начальные центры кластеров (центроиды).
3. Каждая точка данных приписывается к ближайшему центроиду.
4. Центроиды перемещаются в центр масс своих новых кластеров.
5. Шаги 3 и 4 повторяются, пока центроиды не перестанут двигаться.

Расстояние между точками обычно считается как Евклидово расстояние:

$$d(p, q) = \sqrt{\sum_{i=1}^{n} (q_i - p_i)^2}$$

Где:

• $d(p, q)$ — расстояние между точками $p$ и $q$.
• $n$ — количество признаков (измерений).
• $q_i, p_i$ — координаты точек по $i$-му измерению.
• $\sum$ — сумма квадратов разностей координат.

Метод локтя (Elbow Method)

Главная проблема K-Means — нужно заранее сказать, сколько кластеров мы ищем. Как узнать оптимальное число?

Мы строим график зависимости «ошибки» (суммы квадратов расстояний от точек до центров их кластеров, WCSS) от количества кластеров $k$.

$$WCSS = \sum_{j=1}^{k} \sum_{x \in C_j} (x - \mu_j)^2$$

Где:

• $WCSS$ — сумма квадратов внутрикластерных расстояний.
• $k$ — количество кластеров.
• $C_j$ — множество точек, принадлежащих кластеру $j$.
• $x$ — конкретная точка данных.
• $\mu_j$ — центр (центроид) кластера $j$.

С увеличением $k$ ошибка всегда падает. Но в какой-то момент падение замедляется, и график образует «локоть». Эта точка и считается оптимальным количеством кластеров.

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# Список для хранения значений ошибок
wcss = []

# Пробуем от 1 до 10 кластеров
for i in range(1, 11):
    kmeans = KMeans(n_clusters=i, random_state=42)
    kmeans.fit(X) # Обратите внимание: y здесь не нужен!
    wcss.append(kmeans.inertia_)

# Строим график
plt.plot(range(1, 11), wcss)
plt.title('Метод локтя')
plt.xlabel('Количество кластеров')
plt.ylabel('WCSS')
plt.show()

Заключение

Сегодня мы превратились из новичков, умеющих просто запускать fit/predict, в инженеров, которые:

1. Понимают, что accuracy — не панацея, и используют Precision/Recall.
2. Умеют честно оценивать модели через кросс-валидацию.
3. Автоматически подбирают лучшие настройки через Grid Search.
4. Познакомились с миром без учителя и алгоритмом K-Means.

В следующей части курса мы коснемся темы, которая сейчас у всех на слуху — Нейронные сети и Глубокое обучение (Deep Learning).