Нейросети: создание и оптимизация будущего

2. Обработка пропусков: Заменяем пропущенные значения на медианные.

3. Кодирование категориальных переменных: Кодируем целевой признак.

4. Нормализация данных: Применим Min-Max нормализацию.

5. Разделение на тренировочные и тестовые наборы: Разделяем данные для оценки.

6. Кросс-валидация: Применим k-fold кросс-валидацию.

Пример кода

```python

import numpy as np

import pandas as pd

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split, KFold, cross_val_score

from sklearn.preprocessing import MinMaxScaler, StandardScaler, LabelEncoder

from sklearn.ensemble import RandomForestClassifier

from sklearn.metrics import accuracy_score

# Шаг 1: Загрузка и подготовка данных

data = load_iris()

df = pd.DataFrame(data.data, columns=data.feature_names)

df['target'] = data.target

# Шаг 2: Обработка пропущенных данных (для примера добавим пропуски)

df.iloc[0, 0] = np.nan # добавляем пропущенное значение для примера

df.fillna(df.median(), inplace=True) # заполняем медианными значениями

# Шаг 3: Кодирование категориального признака (в данном случае уже числовой)

# Для других данных LabelEncoder может быть полезен

# Шаг 4: Нормализация данных

scaler = MinMaxScaler()

df[data.feature_names] = scaler.fit_transform(df[data.feature_names])

# Шаг 5: Разделение данных на тренировочные и тестовые наборы

X = df.drop('target', axis=1)

y = df['target']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Шаг 6: Обучение модели и оценка

model = RandomForestClassifier(random_state=42)

model.fit(X_train, y_train)

predictions = model.predict(X_test)

accuracy = accuracy_score(y_test, predictions)

print(f'Точность на тестовом наборе: {accuracy:.2f}')

# Шаг 7: Кросс-валидация

kf = KFold(n_splits=5, shuffle=True, random_state=42)

cv_scores = cross_val_score(model, X, y, cv=kf)

print(f'Средняя точность при кросс-валидации: {cv_scores.mean():.2f}')

```

Описание кода

– Загрузка данных: Набор данных `Iris` предоставляет четыре признака и один целевой признак – вид цветка.

– Обработка пропусков: Пример добавляет пропущенные значения в первый признак и затем заменяет их на медианное значение по этому признаку.

– Кодирование категориальных переменных: `LabelEncoder` может использоваться для преобразования категорий в числовой формат (не требуется в этом наборе данных).

– Нормализация данных: Min-Max нормализация применяется ко всем признакам, чтобы привести их к диапазону [0, 1]. Это улучшает процесс обучения, делая данные более однородными.

– Разделение данных: Данные разделяются на тренировочные и тестовые наборы в пропорции 70:30, чтобы обеспечить независимую проверку модели.

– Кросс-валидация: k-fold кросс-валидация (здесь с k=5) обеспечивает усреднённую оценку точности модели, разделяя данные на 5 подмножества и обучая модель на каждом из них, улучшая общую надёжность оценки.

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

2.3. Обратное распространение ошибки

Обратное распространение ошибки (backpropagation) – это алгоритм обучения нейронных сетей, который использует градиентный спуск для минимизации ошибки. Главная цель обратного распространения состоит в том, чтобы адаптировать веса сети так, чтобы минимизировать разницу между фактическими и ожидаемыми результатами. Ключевое преимущество метода в том, что он позволяет вычислить градиенты весов во всей сети, даже если она многослойная и содержит скрытые слои.

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

Шаги обратного распространения: от выходного к входному слою

Вычисление ошибки на выходном слое

Чтобы улучшить работу нейронной сети, на первом шаге мы оцениваем, насколько её предсказания отличаются от реальных значений. Эта оценка выражается через ошибку – разницу между тем, что сеть предсказала, и тем, что должно было быть. Ошибка показывает, насколько сильно сеть "промахнулась", и даёт основу для последующей корректировки её параметров.

Как оценивается ошибка?

1. Для числовых прогнозов (например, предсказание стоимости, температуры и т.п.):

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

2. Для задач классификации (например, когда нужно определить класс: "кошки" или "собаки"):

Здесь используется другая стратегия, которая сосредотачивается на точности вероятностей. Если сеть уверена, что перед ней "кошка", но это не так, ошибка будет очень большой, поскольку ошибка для уверенного прогноза наказывается сильнее, чем для "неуверенного". Это помогает быстрее адаптировать сеть к верным ответам в задачах классификации, где важна не только верность предсказания, но и уверенность в нём.

Процесс расчёта ошибки

На выходном слое сеть "узнаёт" о своей ошибке, сравнивая свои прогнозы с реальными значениями. Эта информация – численное значение ошибки – станет основой для последующих шагов. Она показывает, в каком направлении и насколько нужно изменить внутренние параметры сети, чтобы в будущем её предсказания стали ближе к реальным данным. Этот первый этап задаёт "курс" для корректировок на всех других слоях.

2. Вычисление градиентов на выходном слое

После того как на выходном слое нейронной сети подсчитана ошибка, следующим шагом становится определение, какие именно внутренние параметры (веса) повлияли на это отклонение. Чтобы сеть могла исправить свои прогнозы, нужно понять, каким образом каждый вес в её структуре связан с ошибкой на выходе. Этот процесс называется вычислением градиентов.

Зачем нужны градиенты?

Градиенты можно представить как числовые индикаторы, показывающие, как сильно изменится ошибка на выходе, если чуть-чуть изменить конкретный вес. По сути, это направление и "степень" корректировки, которую нужно внести в каждый вес, чтобы сеть лучше соответствовала правильным ответам. Например, если изменение какого-то веса сильно повлияет на ошибку, его градиент будет большим, и сеть при обучении сделает на него больший "акцент".

Роль производной в вычислении градиентов

Чтобы найти связь между каждым весом и ошибкой, используется производная функции ошибки по значению каждого выхода сети. Производная показывает, насколько чувствительна ошибка к небольшому изменению веса. Когда ошибка невелика, производная тоже мала, указывая, что этот вес уже приближен к нужному значению. Если же ошибка велика, производная будет больше, намекая на необходимость более значительных корректировок. Процесс начинается с выходного слоя, где оценивается влияние весов, связанных с этим слоем, на общую ошибку.

Как градиенты помогают в обучении

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

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

3. Распространение градиентов на предыдущие слои

После вычисления градиентов на выходном слое следующая задача сети – передать эти градиенты обратно через слои, чтобы адаптировать каждый вес, начиная от самых близких к выходу и заканчивая входным слоем. Этот этап основывается на использовании **цепного правила дифференцирования**, которое позволяет оценить вклад каждого веса в общую ошибку, даже если этот вес находится не на выходном, а на одном из скрытых слоев.

Как работает цепное правило?

Цепное правило помогает рассчитать, как изменение параметров на скрытых слоях влияет на ошибку на выходе. Идея проста: если ошибка на выходе зависит от активаций, полученных на предыдущем слое, а активации, в свою очередь, зависят от параметров ещё предыдущего слоя, то можно последовательно "протянуть" градиенты от выходного слоя к каждому предыдущему, слой за слоем, используя "цепочку" производных. Это похоже на механизм "домино": изменения на одном уровне "передаются" назад, влияя на все предыдущие уровни.

Что происходит на каждом слое?

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

Эти вычисления проводятся последовательно для каждого слоя, двигаясь "назад" от выходного к входному слою, пока сеть не "обработает" все слои. На каждом шаге градиенты пересчитываются с учётом вклада текущего слоя, и передаются на следующий (предыдущий по отношению к выходу).

Зачем нужно распространять градиенты через слои?

Каждый слой нейронной сети играет свою роль в конечном прогнозе, так как активации скрытых слоев влияют на финальный результат. Распространяя градиенты ошибки через все слои, сеть может "учесть" влияние каждого веса на результат. Это позволяет постепенно улучшать весь процесс прогнозирования – не только для последнего слоя, но и для каждого промежуточного уровня, что повышает общую точность сети.

После распространения градиентов через все слои сеть получает детальное руководство по тому, как каждый параметр на каждом слое должен быть изменён, чтобы уменьшить ошибку. Это подготовка к финальному этапу обратного распространения ошибки – обновлению весов, что позволит сети в дальнейшем выдавать всё более точные результаты.

4. Обновление весов

После того как сеть рассчитала градиенты на всех слоях и получила информацию о том, какие веса нужно скорректировать, наступает этап обновления весов. Этот этап выполняется с использованием алгоритма оптимизации, обычно – градиентного спуска. Цель обновления весов заключается в том, чтобы "двинуться" в направлении, которое уменьшит ошибку сети, делая её предсказания точнее.

Как происходит обновление весов?

Для каждого веса сети используется формула, согласно которой новый вес рассчитывается на основе его текущего значения, градиента и параметра, называемого шагом обучения. Шаг обучения определяет, насколько сильно будет изменён каждый вес на основе вычисленного градиента. Процесс можно описать так:

1. Градиент показывает направление и величину коррекции. Градиент указывает, насколько и в какую сторону нужно изменить конкретный вес для минимизации ошибки.

2. Шаг обучения контролирует темп изменений. Чтобы не изменять веса слишком резко или, наоборот, слишком медленно, используется параметр шага обучения, который "ослабляет" градиент и придаёт изменениям стабильность. Маленький шаг обучения обеспечивает плавные корректировки, снижая риск "перепрыгнуть" правильные значения, но замедляет процесс обучения. Большой шаг ускоряет процесс, но может привести к тому, что сеть не найдёт оптимальное значение весов.

3. Обновление весов по формуле. Каждое значение веса корректируется следующим образом: от текущего значения веса отнимается произведение градиента и шага обучения. Этот процесс повторяется для всех весов сети.

Почему обновление весов так важно?

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

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

Вычисление градиентов

Для корректного обновления весов в нейронной сети требуется вычислить градиенты – величины, показывающие, как именно нужно изменить каждый вес, чтобы уменьшить общую ошибку сети. Это вычисление лежит в основе метода обратного распространения ошибки (backpropagation) и обычно основано на применении цепного правила (chain rule).

Метод вычисления градиентов для обновления весов

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

1. Оценка ошибки

Первым шагом в процессе обратного распространения ошибки является оценка ошибки на выходном слое. Это важный этап, поскольку именно здесь сеть "узнаёт", насколько её предсказание отклонилось от истинного значения и насколько далеко она находится от правильного результата. Оценка ошибки даёт начальное представление о точности текущего состояния модели.

Как оценивается ошибка?

Для оценки ошибки на выходном слое нейронная сеть сравнивает предсказанное значение с реальным значением (например, меткой класса или целевым числом). Ошибка показывает, насколько точно сеть "предсказала" реальный результат для текущего входного примера. Этот процесс основывается на **функции потерь** – специальной математической формуле, которая измеряет различие между предсказанием и действительным значением.

Существует несколько популярных функций потерь, каждая из которых оптимально подходит для разных типов задач:

– Среднеквадратичная ошибка (MSE): используется в задачах регрессии, когда нужно предсказать числовое значение. MSE фокусируется на разнице между предсказанными и истинными значениями, усиливая влияние больших ошибок.

– Кросс-энтропия: применяется в задачах классификации, где важно оценивать точность вероятностей. Она эффективно оценивает, насколько сильно предсказания отклоняются от истинного класса, придавая больший "вес" уверенным, но ошибочным прогнозам.

Почему оценка ошибки важна?

Этап оценки ошибки создаёт основу для всех последующих шагов обучения сети. Поняв, где и насколько она ошибается, сеть может адаптировать свои внутренние параметры (веса), чтобы лучше соответствовать данным. Ошибка на выходном слое служит отправной точкой, с которой сеть начнёт работать, чтобы исправить свои прогнозы.

2. Вычисление градиента функции потерь по каждому весу

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

Как работает вычисление градиентов?

Для того чтобы понять, как каждый вес в сети влияет на итоговую ошибку, нужно найти частную производную функции потерь по каждому весу. Частная производная показывает, как сильно изменится ошибка, если слегка изменить данный вес, при этом оставив остальные веса неизменными.

1. Градиент как направление и величина изменения: Градиент каждого веса указывает направление (вниз или вверх) и величину корректировки, которая поможет снизить ошибку. Если ошибка сильно "зависит" от данного веса, его градиент будет большим, что сигнализирует о необходимости более значительных изменений. Если же ошибка изменяется незначительно при изменении веса, то и градиент будет маленьким, показывая, что вес уже близок к нужному значению.

2. Важность локального влияния весов: На каждом слое сети градиенты зависят от предыдущих и последующих слоев. Чем ближе вес к выходному слою, тем более прямое влияние он оказывает на ошибку. Градиенты, рассчитанные для этих "близких" весов, сразу показывают, как изменить их, чтобы уменьшить ошибку на выходе. Для весов в скрытых слоях нужно учитывать ещё и влияние следующих слоёв.

Как градиенты направляют корректировку весов?

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

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

– Процесс итеративный: градиенты рассчитываются снова и снова для каждого набора данных, каждый раз обновляя веса на небольшую величину.

Таким образом, градиенты играют важную роль в оптимизации, помогая сети "двигаться" в сторону минимизации ошибки через последовательные обновления.

3. Применение градиента для корректировки весов

Градиенты помогают нейронной сети «учиться» и улучшать свои предсказания. Когда сеть делает ошибку, градиенты показывают, как нужно изменить её параметры (веса), чтобы эта ошибка уменьшилась. Вот как это работает:

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

– Градиенты показывают, как исправить ошибку: Градиенты – это как указатели, которые говорят, в каком направлении нужно двигаться, чтобы ошибка уменьшилась. Они говорят, на сколько и в какую сторону нужно изменить веса сети, чтобы она стала точнее.

– Алгоритм оптимизации: Чтобы модель действительно «выучила» правильные веса, используется специальный метод, называемый градиентным спуском. Он работает так: на основе рассчитанных градиентов мы меняем веса модели, чтобы ошибка стала меньше. Градиентный спуск подсказывает, насколько сильно нужно изменить веса, чтобы улучшить результаты, и делает это на каждом шаге.

– Шаг обучения: При этом важно не делать изменения слишком большими или слишком маленькими. Если шаг обучения будет слишком большим, модель может «перепрыгнуть» через оптимальное решение. Если слишком маленьким – обучение будет идти очень медленно.

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

Использование цепного правила (chain rule)

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

Как работает цепное правило в контексте нейронных сетей?

Цепное правило позволяет выразить влияние каждого веса на выходной результат сети через цепочку промежуточных значений, идущих от выхода сети к её скрытым слоям. Например, если у нас есть функция ошибки, зависящая от выходного значения, и это выходное значение зависит от активации на скрытых слоях, мы можем выразить зависимость ошибки от каждого веса как произведение нескольких частных производных (градиентов) по каждой переменной, включая активации и веса.

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

Проблемы обратного распространения

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

1. Затухание градиентов (Vanishing Gradients):

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

2. Взрыв градиентов (Exploding Gradients):

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

Для предотвращения этих проблем используются несколько методов:

– Нормализация (например, Batch Normalization):

Нормализация входов и промежуточных слоев помогает стабилизировать значения и улучшает эффективность обучения. Batch Normalization также снижает зависимость сети от начальных значений весов, ускоряя сходимость.

– Инициализация весов (например, He и Xavier):

Инициализация весов с учетом распределения значений помогает предотвратить как затухание, так и взрыв градиентов. Например, метод инициализации Xavier подходит для сигмоидных и гиперболических активаций, а He – для ReLU.

– Использование регуляризирующих методов (например, Dropout):

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

– Сокращение длины траектории ошибки (например, Gradient Clipping):

Метод Gradient Clipping ограничивает величину градиентов на каждом шаге, предотвращая их взрыв. Этот метод особенно эффективен в рекуррентных сетях, где ошибка распространяется по временной оси.

Рассмотрим эти методы на практических примерах.

Пример кода с использованием Batch Normalization можно реализовать в PyTorch. Этот метод нормализации стабилизирует обучение, нормализуя выходы слоя и добавляя обучаемые параметры смещения и масштабирования. Batch Normalization помогает улучшить сходимость и сделать обучение более стабильным, особенно в глубоких нейронных сетях.

```python

import torch

import torch.nn as nn

import torch.optim as optim

# Примерный класс нейронной сети с использованием Batch Normalization

class SimpleNet(nn.Module):

def __init__(self):

super(SimpleNet, self).__init__()

self.layer1 = nn.Linear(784, 256) # Первый полносвязный слой

self.bn1 = nn.BatchNorm1d(256) # Batch Normalization после первого слоя

self.layer2 = nn.Linear(256, 128) # Второй полносвязный слой

self.bn2 = nn.BatchNorm1d(128) # Batch Normalization после второго слоя

self.layer3 = nn.Linear(128, 10) # Выходной слой (10 классов, например, для MNIST)

def forward(self, x):

x = self.layer1(x)

x = self.bn1(x) # Применение Batch Normalization

x = torch.relu(x) # Активация ReLU

x = self.layer2(x)

x = self.bn2(x) # Применение Batch Normalization

x = torch.relu(x) # Активация ReLU

x = self.layer3(x) # Применение финального линейного слоя

return x

# Пример данных и оптимизации

model = SimpleNet()

criterion = nn.CrossEntropyLoss() # Функция потерь для классификации

optimizer = optim.Adam(model.parameters(), lr=0.001) # Оптимизатор Adam

# Пример одного шага обучения

inputs = torch.randn(64, 784) # Входной батч из 64 изображений размером 28x28 (784 = 28*28)

labels = torch.randint(0, 10, (64,)) # Случайные метки классов для примера

# Обнуление градиентов

optimizer.zero_grad()

# Прямой проход

outputs = model(inputs)