Нейросети. Основы

Дэвид Рид (2024)

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

Глава 3. Процессы обучения нейросетей

Супервайзинговое обучение

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

Основные шаги супервайзингового обучения:

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

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

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

4. Оценка модели: После обучения модель проверяется на тестовом наборе данных для оценки её точности и способности обобщать новые данные.

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

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

Практический пример супервайзингового обучения

Задача: Классификация изображений кошек и собак с использованием библиотеки scikit-learn и нейронной сети Keras.

— Сбор данных

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

— Разделение данных

Разделим данные на обучающий и тестовый наборы. Обычно используется соотношение 80:20, где 80% данных идут на обучение, а 20% на тестирование.

— Обучение модели

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

— Оценка модели

Оценим точность модели на тестовом наборе данных.

— Корректировка и оптимизация

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

```python

# Импортируем необходимые библиотеки

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from tensorflow.keras.preprocessing.image import ImageDataGenerator

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

# Сбор данных и предварительная обработка

# Для примера используем ImageDataGenerator для загрузки изображений из папок

train_datagen = ImageDataGenerator(rescale=1./255, validation_split=0.2)

train_generator = train_datagen.flow_from_directory(

'data/train', # Путь к папке с изображениями

target_size=(150, 150),

batch_size=32,

class_mode='binary',

subset='training')

validation_generator = train_datagen.flow_from_directory(

'data/train',

target_size=(150, 150),

batch_size=32,

class_mode='binary',

subset='validation')

# Разделение данных уже происходит внутри ImageDataGenerator с использованием параметра validation_split

# Создание модели

model = Sequential([

Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)),

MaxPooling2D(2, 2),

Conv2D(64, (3, 3), activation='relu'),

MaxPooling2D(2, 2),

Conv2D(128, (3, 3), activation='relu'),

MaxPooling2D(2, 2),

Conv2D(128, (3, 3), activation='relu'),

MaxPooling2D(2, 2),

Flatten(),

Dense(512, activation='relu'),

Dropout(0.5),

Dense(1, activation='sigmoid')

])

# Компиляция модели

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Обучение модели

history = model.fit(

train_generator,

steps_per_epoch=train_generator.samples // train_generator.batch_size,

validation_data=validation_generator,

validation_steps=validation_generator.samples // validation_generator.batch_size,

epochs=10

)

# Оценка модели

loss, accuracy = model.evaluate(validation_generator)

print(f'Test Accuracy: {accuracy*100:.2f}%')

# Корректировка и оптимизация

# В данном примере можно попробовать изменить архитектуру модели, количество эпох,

# использование других оптимизаторов или функций активации для улучшения производительности.

# График точности обучения и валидации

plt.plot(history.history['accuracy'], label='Training Accuracy')

plt.plot(history.history['val_accuracy'], label='Validation Accuracy')

plt.title('Training and Validation Accuracy')

plt.legend()

plt.show()

# График потерь обучения и валидации

plt.plot(history.history['loss'], label='Training Loss')

plt.plot(history.history['val_loss'], label='Validation Loss')

plt.title('Training and Validation Loss')

plt.legend()

plt.show()

```

Описание шагов

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

— Разделение данных: Произошло в процессе генерации данных с использованием параметра `validation_split`.

— Обучение модели: Создали и обучили простую сверточную нейронную сеть (CNN) для классификации изображений.

— Оценка модели: Оценили точность модели на валидационном наборе данных.

— Корректировка и оптимизация: Визуализировали графики точности и потерь для определения возможностей улучшения модели.

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

Обучение без учителя

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

Основные методы обучения без учителя:

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

1. Кластеризация

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

K-means

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

1. Назначение точек кластерам: Каждая точка данных присваивается тому кластеру, центроид которого находится ближе всего.

2. Обновление центроидов: После распределения всех точек данные центроиды пересчитываются как среднее всех точек, принадлежащих каждому кластеру.

3. Конвергенция: Шаги назначения и обновления повторяются до тех пор, пока изменения в позициях центроидов не станут незначительными, что означает, что центроиды стабилизировались и алгоритм достиг сходимости.

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

Иерархическая кластеризация

Иерархическая кластеризация — метод, который создает иерархию вложенных кластеров, представляемую в виде дендрограммы. Существует два основных подхода к иерархической кластеризации: агломеративный и дивизионный.

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

2. Дивизионная кластеризация (сверху вниз): Все объекты начинают как один кластер, который на каждом шаге делится на два наиболее удаленных кластера, продолжая деление до тех пор, пока каждый объект не окажется в своем собственном кластере.

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

DBSCAN (Density-Based Spatial Clustering of Applications with Noise)

DBSCAN — алгоритм кластеризации, основанный на плотности данных. Он идентифицирует плотные регионы данных и выделяет их в кластеры, эффективно обрабатывая шумовые данные и выявляя кластеры произвольной формы. Основные параметры DBSCAN включают (epsilon) (eps), определяющий радиус соседства точки, и ( minPts ), указывающий минимальное количество точек в радиусе (epsilon) для формирования кластера.

Основные шаги алгоритма DBSCAN:

1. Плотностная связь: Для каждой точки определяется плотность, основанная на числе соседних точек в радиусе ( epsilon ).

2. Формирование кластеров: Начинается с произвольной точки. Если плотность точки выше порогового значения (minPts), она считается начальной точкой кластера, и все плотностно-связанные точки включаются в этот кластер.

3. Обработка шума: Точки, которые не могут быть включены ни в один кластер (имеющие менее ( minPts ) соседей в радиусе epsilon, считаются шумом и не относятся ни к одному кластеру.

DBSCAN особенно эффективен для выявления кластеров произвольной формы и работы с шумом. В отличие от K-means, он не требует заранее задавать число кластеров. Однако выбор параметров (epsilon) и (minPts) может быть нетривиальной задачей и требовать тщательной настройки для конкретного набора данных.

2. Снижение размерности

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

PCA (Principal Component Analysis)

Метод главных компонент (PCA) — это линейный метод снижения размерности, который преобразует данные в новое пространство меньшей размерности, сохраняя при этом максимальное возможное количество вариаций данных. Основная идея PCA заключается в нахождении новых осей (главных компонент), которые являются линейными комбинациями исходных признаков и упорядочены таким образом, что первая главная компонента объясняет наибольшую долю дисперсии в данных, вторая — вторую по величине, и так далее.

Процесс PCA включает следующие шаги:

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

2. Вычисление ковариационной матрицы: Определяется ковариационная матрица для центрированных данных, отражающая взаимосвязь между различными признаками.

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

4. Проекция данных: Данные проецируются на новое пространство, образованное главными компонентами.

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

t-SNE (t-distributed Stochastic Neighbor Embedding)

t-SNE (t-distributed Stochastic Neighbor Embedding) — это нелинейный метод снижения размерности, который часто используется для визуализации высокоразмерных данных. В отличие от PCA, который сохраняет глобальную структуру данных, t-SNE фокусируется на сохранении локальной структуры данных. Это означает, что t-SNE старается сохранять близкие расстояния между точками, которые были близки в исходном пространстве, и раздельные расстояния между точками, которые были далеко друг от друга.

Основные шаги t-SNE включают:

1. Вычисление вероятностей: Для каждой пары точек в высокоразмерном пространстве вычисляются вероятности близости.

2. Оптимизация: В новом пространстве меньшей размерности t-SNE находит такие расположения точек, чтобы вероятности близости были максимально похожи на исходные.

3. Минимизация Kullback-Leibler расхождения: Процесс оптимизации включает минимизацию расхождения Kullback-Leibler между распределениями вероятностей в исходном и новом пространствах.

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

UMAP (Uniform Manifold Approximation and Projection)

UMAP (Uniform Manifold Approximation and Projection) — это современный метод снижения размерности, который, подобно t-SNE, фокусируется на сохранении локальной структуры данных. Однако UMAP часто работает быстрее и лучше масштабируется на большие наборы данных. Основной принцип UMAP заключается в предположении, что данные лежат на многообразии меньшей размерности в исходном пространстве, и стремится сохранять топологическую структуру этого многообразия при проекции в пространство меньшей размерности.

Основные этапы UMAP включают:

1. Построение графа k-ближайших соседей: Определяется граф, где точки связаны с их ближайшими соседями.

2. Оптимизация графа: Граф оптимизируется, чтобы минимизировать расхождение между распределениями расстояний в высокоразмерном и низкоразмерном пространствах.

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

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

3. Ассоциативные правила

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

Алгоритм Apriori

Алгоритм Apriori является одним из самых известных и широко используемых методов для выявления частых наборов элементов и создания ассоциативных правил в больших наборах данных. Этот алгоритм используется в анализе транзакционных баз данных для поиска интересных корреляций и закономерностей, таких как"если покупатель купил товар A, то он, вероятно, купит товар B".

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

1. Создание начальных наборов: На первом этапе алгоритм находит все частые одиночные элементы, которые удовлетворяют заданному порогу поддержки (минимальное количество раз, которое элемент должен появиться в базе данных, чтобы считаться частым).

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

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

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

5. Создание ассоциативных правил: После нахождения всех частых наборов элементов алгоритм генерирует ассоциативные правила, которые представляют собой зависимости между элементами.

Основным недостатком алгоритма Apriori является необходимость многократного прохода по базе данных для генерации и проверки кандидатов, что делает его менее эффективным для больших наборов данных.

FP-Growth (Frequent Pattern Growth)

FP-Growth (Frequent Pattern Growth) — это более эффективный алгоритм для выявления частых наборов элементов и создания ассоциативных правил по сравнению с Apriori. Основная идея FP-Growth заключается в использовании структуры дерева (FP-дерево) для компактного представления набора частых элементов и быстрого обнаружения ассоциативных правил без необходимости генерировать кандидатов.

FP-Growth работает следующим образом:

1. Построение FP-дерева: На первом этапе алгоритм строит FP-дерево. Для этого сначала проводится один проход по базе данных для определения частоты всех элементов. Затем база данных повторно проходит для построения дерева, где каждая транзакция добавляется в дерево, обновляя счетчики частоты.

2. Разделение дерева: FP-дерево делится на поддеревья для каждого частого элемента. Этот процесс продолжается рекурсивно, пока не будут найдены все частые наборы элементов.

3. Генерация частых наборов: После построения FP-дерева и его разделения алгоритм извлекает все частые наборы элементов, используя структуру дерева и счетчики частоты.

FP-Growth значительно эффективнее Apriori, так как он избегает необходимости многократного прохода по базе данных для генерации и проверки кандидатов. Вместо этого он строит компактное FP-дерево, которое позволяет быстро находить все частые наборы элементов. Это делает FP-Growth особенно полезным для анализа больших наборов данных, где производительность алгоритма Apriori может быть ограничена.

Обе техники используются для анализа транзакционных данных, но FP-Growth часто предпочитается в ситуациях, требующих высокой производительности и масштабируемости.

Применение методов обучения без учителя

Методы обучения без учителя широко используются в различных областях:

— Сегментация клиентов: Кластеризация помогает разделить клиентов на группы с похожими характеристиками для целевого маркетинга.

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

— Сжатие данных: Снижение размерности позволяет уменьшить объем данных, сохраняя важную информацию и упрощая последующую обработку.

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

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

Обучение с подкреплением

Обучение с подкреплением (reinforcement learning) — это тип машинного обучения, при котором агент обучается взаимодействовать с окружающей средой с целью максимизации некоторой награды. Агент принимает решения, выполняя действия, которые влияют на состояние среды, и получает за это награды или наказания. Основная задача агента — научиться выбирать такие действия, которые приводят к максимальной суммарной награде в долгосрочной перспективе.

Основные компоненты обучения с подкреплением:

1. Агент: Объект, который принимает решения и выполняет действия.

2. Среда: Всё, с чем взаимодействует агент. Среда реагирует на действия агента, изменяя своё состояние и предоставляя агенту награды.

3. Действия: Набор возможных действий, которые агент может выполнить в каждом состоянии.

4. Состояния: Все возможные состояния среды, которые могут изменяться в ответ на действия агента.

5. Награда: Оценка полезности действий агента, которая может быть положительной или отрицательной.

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

Q-обучение

Q-обучение (Q-learning) — это метод обучения с подкреплением, при котором агент обучается через пробы и ошибки. Основная цель Q-обучения заключается в нахождении оптимальной политики, которая максимизирует накопленное вознаграждение агента в долгосрочной перспективе. В основе метода лежит оценка ценности действий (Q-значений) в различных состояниях. Агент взаимодействует со средой, выполняя действия и получая вознаграждения за каждое из них. Путем итеративного обновления Q-значений на основе полученного опыта, агент постепенно улучшает свою стратегию. Основное уравнение обновления в Q-обучении известно как уравнение Беллмана, которое позволяет агенту корректировать Q-значения на основе текущего вознаграждения и максимально возможного будущего вознаграждения.

Пример реализации Q-обучения на Python с использованием библиотеки `numpy` для обучения агента в простой среде, такой как"Cliff Walking"из OpenAI Gym.

Задача в приведенном коде заключается в обучении агента, который должен найти оптимальный путь по"обрыву"(Cliff Walking) в окружении OpenAI Gym. В этой задаче агент должен научиться перемещаться по сетке от начальной позиции до цели, избегая падения с обрыва.

Описание задачи Cliff Walking

В задаче"Cliff Walking"агент перемещается по сетке размером 4x12. Начальная позиция агента находится в левом нижнем углу, а цель — в правом нижнем углу. Ячейки между начальной позицией и целью представляют собой обрыв. Если агент попадает в обрыв, он получает большое отрицательное вознаграждение и возвращается в начальную позицию.

Цель агента — найти оптимальный путь от начальной позиции до цели, минимизируя общие штрафы (отрицательные вознаграждения) и избегая обрыва.

Основные компоненты задачи

1. Окружение:

— `CliffWalking-v0` представляет собой сетку размером 4x12.

— Агент начинает в ячейке (3, 0) и должен достичь ячейки (3, 11).

2. Действия:

— Агент может двигаться в четырех направлениях: влево, вправо, вверх и вниз.

3. Награды:

— Каждое движение агента дает штраф — 1.

— Падение с обрыва приводит к большому штрафу (например, — 100) и возвращает агента в начальную позицию.

4. Конечное состояние:

— Когда агент достигает цели в ячейке (3, 11), эпизод заканчивается.

Примерный процесс выполнения задачи

1. Инициализация:

— Создаем окружение и инициализируем параметры Q-обучения.

— Инициализируем Q-таблицу нулями.

2. Цикл обучения:

— В каждом эпизоде агент начинает в начальной позиции и выполняет действия, выбираемые согласно ε-жадной стратегии.

— Обновляем Q-таблицу на основе полученного опыта (текущее состояние, действие, вознаграждение и следующее состояние).

— Эпизод продолжается, пока агент не достигнет цели или не упадет в обрыв.

3. Тестирование:

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

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

Для начала нужно установить OpenAI Gym, если он еще не установлен:

```bash

pip install gym

```

Пример кода

```python

import numpy as np

import gym

# Создаем окружение"CliffWalking-v0"

env = gym.make('CliffWalking-v0')

# Параметры Q-обучения

alpha = 0.1 # Скорость обучения

gamma = 0.99 # Коэффициент дисконтирования

epsilon = 0.1 # Вероятность выбора случайного действия

# Инициализация Q-таблицы

q_table = np.zeros((env.observation_space.n, env.action_space.n))

def choose_action(state):

if np.random.uniform(0, 1) < epsilon:

return env.action_space.sample() # Случайное действие

else:

return np.argmax(q_table[state]) # Действие с максимальным Q-значением

def update_q_table(state, action, reward, next_state):

best_next_action = np.argmax(q_table[next_state])

td_target = reward + gamma * q_table[next_state][best_next_action]

td_error = td_target — q_table[state][action]

q_table[state][action] += alpha * td_error

# Основной цикл обучения

num_episodes = 500

for episode in range(num_episodes):

state = env.reset()

done = False

while not done:

action = choose_action(state)

next_state, reward, done, _ = env.step(action)

update_q_table(state, action, reward, next_state)

state = next_state

# Тестирование агента после обучения

state = env.reset()

done = False

total_reward = 0

while not done:

action = np.argmax(q_table[state])

state, reward, done, _ = env.step(action)

total_reward += reward

env.render()

print(f"Total reward after training: {total_reward}")

env.close()

```

Объяснение кода

1. Инициализация окружения и параметров:

— Создаем окружение `CliffWalking-v0` из OpenAI Gym.

— Устанавливаем параметры Q-обучения: `alpha` (скорость обучения), `gamma` (коэффициент дисконтирования) и `epsilon` (вероятность выбора случайного действия).

2. Инициализация Q-таблицы:

— Q-таблица инициализируется нулями. Она будет хранить Q-значения для всех пар «состояние-действие».

3. Выбор действия:

— Используем ε-жадную стратегию для выбора действия. С вероятностью `epsilon` выбирается случайное действие, иначе выбирается действие с максимальным Q-значением для текущего состояния.

4. Обновление Q-таблицы:

— Вычисляем целевое значение (TD target), состоящее из текущего вознаграждения и максимального Q-значения для следующего состояния.

— Обновляем Q-значение для текущей пары «состояние-действие» с использованием разности TD (TD error).

5. Основной цикл обучения:

— В каждом эпизоде агент взаимодействует с окружением, выполняя действия и обновляя Q-таблицу на основе полученного опыта.

— Процесс повторяется до тех пор, пока агент не достигнет конечного состояния.

6. Тестирование агента:

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

— Выводится общее вознаграждение, полученное агентом.

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

Случайные блуждания (Методы Монте-Карло)

Методы Монте-Карло (Monte Carlo methods) представляют собой класс алгоритмов, которые используют случайные блуждания для оценки стратегий на основе долгосрочных наград. В отличие от Q-обучения, методы Монте-Карло не требуют знания модели среды. Вместо этого, они основываются на многократных симуляциях взаимодействия агента со средой, в ходе которых вычисляются средние значения наград. Каждая симуляция представляет собой эпизод, включающий последовательность состояний, действий и полученных вознаграждений до достижения конечного состояния. После завершения эпизода метод Монте-Карло обновляет оценки значений состояний или действий, используя накопленные награды. Это позволяет агенту улучшать свою политику, опираясь на накопленный опыт.

Рассмотрим пример использования методов Монте-Карло для обучения агента в задаче"Blackjack"из OpenAI Gym. В этой задаче агент учится играть в блэкджек, используя эпизодическую оценку долгосрочных наград.

Описание задачи и игры"Blackjack"

"Blackjack"(или"21") — это популярная карточная игра, в которой игрок соревнуется против дилера. Цель игры — набрать количество очков, как можно ближе к 21, но не больше этого числа. В OpenAI Gym среда"Blackjack-v1"симулирует эту игру и предоставляет интерфейс для обучения агентов.

Правила игры

1. Карты и их значения:

— Номера карт от 2 до 10 имеют номинальную стоимость.

— Валет, Дама и Король (карты с картинками) имеют стоимость 10 очков.

— Туз может считаться как 1 очко или как 11 очков, в зависимости от того, что лучше для руки.

2. Начало игры:

— И игрок, и дилер получают по две карты.

— Одна из карт дилера открыта, а другая скрыта.

3. Действия игрока:

— Hit: Игрок берет еще одну карту.

— Stand: Игрок прекращает набор карт и передает ход дилеру.

4. Ход дилера:

— Дилер открывает свою скрытую карту.

— Дилер должен продолжать брать карты (hit), пока сумма его очков не станет 17 или больше.

5. Определение победителя:

— Если сумма очков игрока превышает 21, он проигрывает (bust).

— Если игрок и дилер остаются в игре (не превышают 21), выигрывает тот, у кого сумма очков ближе к 21.

— Если у дилера сумма очков превышает 21, дилер проигрывает (bust).

— Если сумма очков у игрока и дилера одинакова, игра заканчивается вничью (push).

Задача агента — научиться принимать оптимальные решения (hit или stand) в различных состояниях игры, чтобы максимизировать свое общее вознаграждение (выигрыши).

Установка необходимых библиотек

Для начала нужно установить OpenAI Gym, если он еще не установлен:

```bash

pip install gym

```

Пример кода

```python

import numpy as np

import gym

from collections import defaultdict

# Создаем окружение"Blackjack-v1"

env = gym.make('Blackjack-v1')

# Параметры Монте-Карло

num_episodes = 500000

gamma = 1.0 # Коэффициент дисконтирования

# Функция для выбора действия на основе ε-жадной стратегии

def epsilon_greedy_policy(state, Q, epsilon=0.1):

if np.random.rand() < epsilon:

return env.action_space.sample()

else:

return np.argmax(Q[state])

# Инициализация Q-таблицы и возвратов

Q = defaultdict(lambda: np.zeros(env.action_space.n))

returns_sum = defaultdict(float)

returns_count = defaultdict(float)

# Основной цикл обучения

for episode in range(num_episodes):

state = env.reset()

episode = []

done = False

while not done:

action = epsilon_greedy_policy(state, Q)

next_state, reward, done, _ = env.step(action)

episode.append((state, action, reward))

state = next_state

# Обновление Q-таблицы на основе эпизодических возвратов

G = 0

for state, action, reward in reversed(episode):

G = gamma * G + reward

if not any((s == state and a == action) for s, a, _ in episode[:-1]):

returns_sum[(state, action)] += G

returns_count[(state, action)] += 1

Q[state][action] = returns_sum[(state, action)] / returns_count[(state, action)]

# Тестирование агента после обучения

def test_policy(Q, num_episodes=10000):

wins = 0

draws = 0

losses = 0

for _ in range(num_episodes):

state = env.reset()

done = False

while not done:

action = np.argmax(Q[state])

state, reward, done, _ = env.step(action)

if reward > 0:

wins += 1

elif reward == 0:

draws += 1

else:

losses += 1

print(f"Wins: {wins / num_episodes:.2f}, Draws: {draws / num_episodes:.2f}, Losses: {losses / num_episodes:.2f}")

test_policy(Q)

```

Объяснение кода

1. Инициализация окружения и параметров:

— Создаем окружение `Blackjack-v1` из OpenAI Gym.

— Устанавливаем количество эпизодов для обучения и коэффициент дисконтирования `gamma`.

2. Функция для выбора действия:

— Используем ε-жадную стратегию для выбора действия. С вероятностью `epsilon` выбирается случайное действие, иначе выбирается действие с максимальным Q-значением для текущего состояния.

3. Инициализация Q-таблицы и возвратов:

— Q-таблица инициализируется нулями с использованием `defaultdict`.

— `returns_sum` и `returns_count` используются для хранения сумм и счетчиков возвратов для каждой пары «состояние-действие».

4. Основной цикл обучения:

— В каждом эпизоде агент взаимодействует с окружением, выполняя действия и записывая последовательность состояний, действий и наград.

— После завершения эпизода вычисляется общий возврат `G` путем обратного прохода по эпизоду и обновляется Q-таблица для уникальных пар «состояние-действие».

5. Тестирование агента:

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

— Выводится статистика побед, ничьих и поражений.

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

Deep Q-Learning

Deep Q-Learning — это расширение Q-обучения, которое использует глубокие нейронные сети для представления и обновления Q-значений. Это позволяет агентам принимать более сложные и информированные решения в средах с высоким уровнем сложности и большим количеством состояний и действий. В традиционном Q-обучении Q-таблица используется для хранения значений всех возможных пар «состояние-действие», что становится неосуществимым в задачах с большой размерностью. Deep Q-Learning решает эту проблему, используя нейронные сети для аппроксимации функции Q. Агент обучается обновлять параметры нейронной сети, минимизируя разницу между предсказанными и реальными Q-значениями, что делает возможным обучение на больших наборах данных и в сложных средах. Один из ключевых компонентов Deep Q-Learning — это опытный буфер (experience replay), который позволяет агенту запоминать и повторно использовать предыдущие опыты для обучения, что повышает стабильность и эффективность процесса обучения.

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

Описание задачи

Рассмотрим задачу"CartPole"из OpenAI Gym. В этой задаче агент управляет тележкой, на которой закреплен вертикально стоящий столб. Цель агента — балансировать столб, не позволяя ему упасть, двигая тележку влево или вправо.

Описание среды"CartPole"

Состояния:

— Положение тележки (отрицательное значение — тележка слева от центра, положительное — справа).

— Скорость тележки.

— Угол отклонения столба от вертикального положения.

— Угловая скорость столба.

Действия:

— Двигать тележку влево.

— Двигать тележку вправо.

Награды:

— Агент получает награду +1 за каждый шаг, пока столб остается вертикально.

Конечное состояние:

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

Пример кода для Deep Q-Learning

Для реализации DQN мы будем использовать библиотеку PyTorch для создания и обучения нейронной сети.

Установка необходимых библиотек

Для начала нужно установить OpenAI Gym и PyTorch, если они еще не установлены:

```bash

pip install gym torch

```

Пример кода

```python

import gym

import torch

import torch.nn as nn

import torch.optim as optim

import numpy as np

from collections import deque, namedtuple

import random

# Определение архитектуры нейронной сети

class DQN(nn.Module):

def __init__(self, state_size, action_size):

super(DQN, self).__init__()

self.fc1 = nn.Linear(state_size, 24)

self.fc2 = nn.Linear(24, 24)

self.fc3 = nn.Linear(24, action_size)

def forward(self, x):

x = torch.relu(self.fc1(x))

x = torch.relu(self.fc2(x))

return self.fc3(x)

# Параметры обучения

env = gym.make('CartPole-v1')

state_size = env.observation_space.shape[0]

action_size = env.action_space.n

batch_size = 64

gamma = 0.99 # Коэффициент дисконтирования

epsilon = 1.0 # Вероятность случайного действия

epsilon_min = 0.01

epsilon_decay = 0.995

learning_rate = 0.001

target_update = 10 # Как часто обновлять целевую сеть

memory_size = 10000

num_episodes = 1000

# Определение памяти для опыта

Transition = namedtuple('Transition', ('state', 'action', 'next_state', 'reward'))

memory = deque(maxlen=memory_size)

# Инициализация сети и оптимизатора

policy_net = DQN(state_size, action_size)

target_net = DQN(state_size, action_size)

target_net.load_state_dict(policy_net.state_dict())

target_net.eval()

optimizer = optim.Adam(policy_net.parameters(), lr=learning_rate)

# Функция для выбора действия

def select_action(state, epsilon):

if random.random() < epsilon:

return env.action_space.sample()

else:

with torch.no_grad():

return policy_net(torch.tensor(state, dtype=torch.float32)).argmax().item()

# Функция для обновления памяти

def store_transition(state, action, next_state, reward):

memory.append(Transition(state, action, next_state, reward))

# Функция для обучения сети

def optimize_model():

if len(memory) < batch_size:

return

transitions = random.sample(memory, batch_size)

batch = Transition(*zip(*transitions))

state_batch = torch.tensor(batch.state, dtype=torch.float32)

action_batch = torch.tensor(batch.action).unsqueeze(1)

reward_batch = torch.tensor(batch.reward, dtype=torch.float32)

non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, batch.next_state)), dtype=torch.bool)

non_final_next_states = torch.tensor([s for s in batch.next_state if s is not None], dtype=torch.float32)

state_action_values = policy_net(state_batch).gather(1, action_batch)

next_state_values = torch.zeros(batch_size)

next_state_values[non_final_mask] = target_net(non_final_next_states).max(1)[0].detach()

expected_state_action_values = reward_batch + (gamma * next_state_values)

loss = nn.functional.mse_loss(state_action_values.squeeze(), expected_state_action_values)

optimizer.zero_grad()

loss.backward()

optimizer.step()

# Основной цикл обучения

for episode in range(num_episodes):

state = env.reset()

total_reward = 0

done = False

while not done:

action = select_action(state, epsilon)

next_state, reward, done, _ = env.step(action)

total_reward += reward

if done:

next_state = None

store_transition(state, action, next_state, reward)

state = next_state

optimize_model()

if epsilon > epsilon_min:

epsilon *= epsilon_decay

if episode % target_update == 0:

target_net.load_state_dict(policy_net.state_dict())

print(f"Episode {episode}, Total Reward: {total_reward}")

# Тестирование агента после обучения

state = env.reset()

done = False

total_reward = 0

while not done:

action = select_action(state, epsilon=0.0) # Без ε-жадной стратегии

state, reward, done, _ = env.step(action)

total_reward += reward

env.render()

print(f"Total reward after training: {total_reward}")

env.close()

```

Объяснение кода

1. Определение архитектуры нейронной сети:

— Сеть состоит из трех полносвязных слоев. Входной слой принимает состояние среды, а выходной слой предсказывает Q-значения для каждого возможного действия.

2. Параметры обучения:

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

3. Память для опыта:

— Используется `deque` для хранения недавних переходов, что позволяет повторно использовать их в процессе обучения.

4. Инициализация сети и оптимизатора:

— Инициализируются две сети: `policy_net` для предсказания Q-значений и `target_net` для стабильного обучения.

— `target_net` копирует веса из `policy_net` каждые несколько эпизодов.

5. Функция для выбора действия:

— Выбирается действие на основе ε-жадной стратегии.

6. Функция для обновления памяти:

— Сохраняются переходы (состояние, действие, следующее состояние, вознаграждение) в памяти.

7. Функция для обучения сети:

— Проводится выборка случайного мини-пакета переходов из памяти.

— Вычисляются текущие Q-значения и целевые Q-значения.

— Обновляются параметры сети путем минимизации ошибки MSE.

8. Основной цикл обучения:

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

— Периодически обновляются веса целевой сети.

— Постепенно уменьшается вероятность случайного действия.

9. Тестирование агента:

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

— Выводится общее вознаграждение, полученное агентом.