Machine Learning Methods in Image and Time Series Analysis M1

КОНСПЕКТ ПОДГОТОВЛЕН СТУДЕНТАМИ, НЕ ПРОХОДИЛ
ПРОФ. РЕДАКТУРУ И МОЖЕТ СОДЕРЖАТЬ ОШИБКИ.

МЕХАНИКА • СЛЕПКОВ АЛЕКСАНДР ИВАНОВИЧ СЛЕДИТЕ ЗА ОБНОВЛЕНИЯМИ НА VK.COM/TEACHINMSU.
ФИЗИЧЕСКИЙ
ФАКУЛЬТЕТ
МГУ ИМЕНИ
М.В. ЛОМОНОСОВА
МЕТОДЫ МАШИННОГО ОБУЧЕНИЯ

В АНАЛИЗЕ ИЗОБРАЖЕНИЙ И
ВРЕМЕННЫХ РЯДОВ
ДМИТРИЕВ
КОНСТАНТИН ВЯЧЕСЛАВОВИЧ
ФИЗФАК МГУ
КОНСПЕКТ ПОДГОТОВЛЕН
СТУДЕНТАМИ, НЕ ПРОХОДИЛ
ПРОФ. РЕДАКТУРУ И МОЖЕТ
СОДЕРЖАТЬ ОШИБКИ.
СЛЕДИТЕ ЗА ОБНОВЛЕНИЯМИ
НА VK.COM/TEACHINMSU.
ЕСЛИ ВЫ ОБНАРУЖИЛИ
ОШИБКИ ИЛИ ОПЕЧАТКИ,
ТО СООБЩИТЕ ОБ ЭТОМ,
НАПИСАВ СООБЩЕСТВУ
VK.COM/TEACHINMSU.
БЛАГОДАРИМ ЗА ПОДГОТОВКУ КОНСПЕКТА
СТУДЕНТКУ ФИЗИЧЕСКОГО ФАКУЛЬТЕТА МГУ
ЕМЕЛЬЯНОВУ АНАСТАСИЮ РОМАНОВНУ
МЕТОДЫ МАШИННОГО ОБУЧЕНИЯ В АНАЛИЗЕ
ИЗОБРАЖЕНИЙ И ВРЕМЕННЫХ РЯДОВ ПРОФ РЕДАКТУРУ И МОЖЕТ СОДЕРЖАТЬ ОШИБКИ
ДМИТРИЕВ КОНСТАНТИН ВЯЧЕСЛАВОВИЧ СЛЕДИТЕ ЗА ОБНОВЛЕНИЯМИ НА VK.COM/TEACHINMSU
Оглавление
Лекция 1. Введение. Задачи, подходы и возможности .................................................. 6
Введение. План курса. Источники информации ................................................................. 6
Предмет изучения: искусственный интеллект и машинное обучение ............................. 6
Постановка задачи МО. Классификация задач МО ........................................................... 7
Глубокое МО - построение признаков................................................................................. 8
Модель нейрона Мак-Каллока-Питтса. Линейная регрессия и классификация .............. 9
Построение моделей. Прямые и обратные задачи. Алгоритм решения ......................... 10
Лекция 2. Библиотеки Python, используемые для машинного обучения.
Практическое занятие....................................................................................................... 12
Google Colaboratory - облачный сервис на среде Jupyter Notebook ................................ 12
Библиотека Pandas - работа с таблицами ........................................................................... 12
Seaborn и matplotlib - библиотеки для визуализации данных.......................................... 26
Лекция 3. Байесовский классификатор. Метод максимального правдоподобия.
Априорная и апостериорная информация. ................................................................... 36
Проверка статистических гипотез ...................................................................................... 36
Принятие решений в бинарной ситуации, при нескольких возможных исходах.......... 39
Оценка постоянных параметров сигнала. Байесовский подход...................................... 40
Наблюдения параметра на фоне гауссового шума ........................................................... 42
Лекция 4. Линейные методы регрессии и классификации ....................................... 45
Схема постановки и решения задач обучения с учителем .............................................. 45
Недообучение и переобучение. Феномен Рунге ............................................................... 45
Гиперпараметры ................................................................................................................... 47
Задачи линейной регрессии и линейной бинарной классификации ............................... 47
Решение задачи линейной регрессии ................................................................................. 48
Вероятностный подход к задаче линейной регрессии и классификации ....................... 50
Лекция 5. Метрические методы регрессии и классификации .................................. 54
Разбор теории предыдущих лекций на практике .............................................................. 54
Схема постановки и решения задач обучения с учителем. Примеры ............................ 67
Расстояния между объектами. Классификация объектов по соседям ............................ 68
Метод k ближайших соседей (kNN) ................................................................................... 68
3
Метод парзеновского окна. Сравнение с линейным классификатором ......................... 70

Задача регрессии. Формула Надарая-Уотсона. Примеры ядер ....................................... 71
Лекция 6. Метод опорных векторов............................................................................... 73
Задача линейной бинарной классификации ...................................................................... 73
Метод опорных векторов .................................................................................................... 74
Условия Каруша-Куна-Таккера .......................................................................................... 75
Опорные и не опорные объекты. Двойственная задача, её решение .............................. 76
Kernel trick. Часто используемые ядра............................................................................... 77
SVM и метрические методы. SVM регрессия и метрические методы ........................... 79
Лекция 7. Многомерная линейная и нелинейная регрессия. Градиентные методы
................................................................................................................................................ 83
Линейная регрессия ............................................................................................................. 83
Метод наименьших квадратов ............................................................................................ 84
Линейное преобразование признаков. Метод главных компонент ................................ 85
Нелинейная регрессия ......................................................................................................... 86
Минимизации функционала качества. Методы 1, 2 порядка .......................................... 87
Лекция №8. Критерии оценки качества моделей. Логические закономерности .. 92
Критерии качества в задачах бинарной классификации .................................................. 92
Генерация семейств правил. Синтез правил на основе выбранных семейств ............... 94
Критерии информативности правил .................................................................................. 95
Решающие деревья............................................................................................................... 98
Рандомный лес. Плюсы и минусы...................................................................................... 99
Лекция №9. Ансамбли алгоритмов. Беггинг и бустинг. .......................................... 105
Ансамбль алгоритмов. Метод bootstrap. Метод рандомизации алгоритмов ................ 105
Беггинг. Рандомный лес - частный случай беггинга ...................................................... 106
Бустинг. Градиентный бустинг. ....................................................................................... 107
Сравнение беггинга и бустинга. Нелинейные ансамбли алгоритмов ........................... 110
Блендинг. Классический стекинг. Смесь алгоритмов .................................................... 111
Лекция №10. Искуственные нейронные сети. Базовые архитектуры и методы
обучения ............................................................................................................................. 113
Модель нейрона Мак-Каллока-Питтса. Ограниченность единственного нейрона ..... 113
4
Полносвязная нейронная сеть прямого распространения. Обучение сети. Метод

обратного распространения .............................................................................................. 114
Проблемы при обучении нейронных сетей. Выбор функции активации ..................... 116
Метод прореживания. Оптимальное прореживание ...................................................... 116
Пакетная нормализация. Начальная инициализация параметров ................................. 118
Светоточные и остаточные нейронные сети ................................................................... 119
Лекция №11. Нейронные сети для распознавания цифр. Задачи обучения без
учителя. Часть 1 ............................................................................................................... 125
Нейронные сети для распознавания цифр ....................................................................... 125
Нейронные сети для распознавания цифр: аугментация ............................................... 140
Нейронные сети в задачах обучения без учителя ........................................................... 148
Лекция №12. Задачи обучения без учителя. Часть 2 ................................................ 151
Схема постановки задачи сокращения размерности. Автокодировщики .................... 151
Архитектуры автокодировщиков. Самообучение .......................................................... 153
Генеративная состязательная сеть. Векторные представления текста ......................... 159
Лекция №13. Работа в временными рядами .............................................................. 162
Задача предсказания временных рядов. Стандартные процессы .................................. 162
Разложение сигнала по базисным функциям. Линейные инвариантные по времени
системы ............................................................................................................................... 163
Модель APCC (ARMA). Модель AR(1). Единичные корни .......................................... 165
Модель APПCC (ARIMA) и СAPПCC (SARIMA).......................................................... 168
Модель ARCH, GARCH. Нейросетевые методы прогнозирования .............................. 169
5
Лекция 1. Введение. Задачи, подходы и возможности

Введение. План курса. Источники информации
План курса:
• Введение. История вопроса и современное состояния проблемы
• Общие методы и особенности работы с данными
• Обзор алгоритмов машинного обучения (МО)
• Доклады аспирантов (представление современных методов МО
студентами)
Рекомендуемая литература:
• Шолле Ф.: Глубокое обучение на Python, 2018
• Саттон Ричард С., Барто Эндрю Г.: Обучение с подкреплением
• Саймон Хайкин: Нейронные сети. Полный курс
• Курвилль Аарон, Гудфеллоу Ян, Бенджио Иошуа: Глубокое обучение
• Г.И. Ивченко, Ю.И. Медведев: Введение в математическую статистику
• Васильев К.К.: Методы обработки сигналов
Рекомендуемые сайты, YouTube-каналы:
• https://kaggle.com/ - международные конкурсы по машинному обучению,
мини-курсы, сообщество
• DataRing.ru – русский сайт, задачи по машинному обучению
• https://ods.ai/ - Open Data Science, научное сообщество
• https://archive.ics.uci.edu/ml/
• https://www.youtube.com/c/MachineLearningPhystech
• https://www.youtube.com/c/ritvikmath
• https://www.youtube.com/c/DigitalSreeni
• https://www.youtube.com/user/SpartacanUsuals
• https://www.youtube.com/c/CompscicenterRu
Предмет изучения: искусственный интеллект и машинное обучение
Определение 1.1
Искусственный интеллект (ИИ; англ. artificial intelligence, AI) – свойство
интеллектуальных систем выполнять творческие функции, которые традиционно
считаются прерогативой человека; наука и технология создания интеллектуальных
машин, особенно интеллектуальных компьютерных программ.
Машинное обучение (МО; англ. machine learning, ML) – класс методов
искусственного интеллекта, характерной чертой которых является не прямое решение
задачи, а обучение за счёт применения решений множества сходных задач.
6
Задачи можно условно разделить на «формальные», решаемые с помощью

системы уравнений и компьютерных вычислений, и «неформальные», требующие
творческий подход (например, как научить машину сочинять симфонии).
Успехи машинного обучения
• в играх:
o 11 мая 1997 года Deep Blue выиграл матч у чемпиона мира по
шахматам Гарри Каспарова
o AlphaGo победил со счётом 4:1 в матче с Ли Седолем (9-й дан),
который прошёл с 9 по 15 марта 2016 года.
• в распознавании изображений: для человека не составит труда отличить
собаку от кошки, для машины это сложная задача, однако имеющая
практическое применение в жизни, например, распознавание лиц,
контроль качества изготовления изделий.
• в распознавании рукописных цифр (база данных MNIST). Проведён анализ
большого количества данных, что позволило получить высокоточный
распознаватель рукописных цифр.
• в распознавании изображений (база данных ImageNet). В результате
анализа сеть выдаёт до 5 категорий, которым может принадлежать тот или
иной объект на фотографии, каждой из категорий присваивается
вероятность, с которой может быть точен результат.
• в области понимания текстов (база данных SQuAD). Имеется текст в
печатном виде, человек задаёт вопросы в удобной ему формулировке
касаемо данного текста, алгоритм выдает ответ. С годами точность ответов
возрастает.
Причины успехов в машинном обучении:
• увеличение размера набора данных со временем;
• рост количества соединений в расчёте на один нейрон со временем;
• рост размера нейронной сети со временем.
Постановка задачи МО. Классификация задач МО
Признак - отображение f: 𝕏 → ⅅf, где X множество описаний объектов; D
множество допустимых значений признака. Если заданы признаки f1, f2,…fn, то вектор
𝑥⃗ = {𝑓1 (𝑥), 𝑓2 (𝑥) … 𝑓𝑛 (𝑥)} называется признаковым описанием объекта 𝑥⃗ ∈ 𝕏.
Множество 𝔻𝑓1 × 𝔻𝑓2 × … × 𝔻𝑓𝑛 , называют признаковым пространством.
В зависимости от класса признака изменяется решение поставленной задачи,
используются разные методы и способы. Классификация признаков по области
значения:
• бинарный: 𝔻𝑓 = {0,1}, "2 класса";
• номинальный: 𝔻𝑓 – конечное множество, «N классов»;
7
• порядковый: 𝔻𝑓 – конечное упорядоченное множество, «ранжирование

объектов»;
• количественный: 𝔻𝑓 – множество действительных чисел, «регрессия».
Все вышеописанные признаки относятся к задачам обучения с учителем, когда
машина получает на вход некоторые признаки «x», каждому из которых сопоставлен «y».
Целевой признак – один или несколько признаков объекта у, которые
представляют практический интерес с точки зрения предсказаний при решении задачи
машинного обучения.
Задача машинного обучения - располагая выборкой 𝕏𝑡𝑟𝑎𝑖𝑛 ⊂ 𝕏 объектов 𝑥⃗𝑖 ∈
𝕏𝑡𝑟𝑎𝑖𝑛 , для которых известны значения 𝑦𝑖 , построить алгоритм 𝑎(𝑥⃗), максимально
хорошо аппроксимирующий значения у для всех 𝑥⃗ ∈ 𝕏.
Задача человека в рамках машинного обучения состоит в следующем: обладая
некоторыми знаниями об объектах (признаками), уметь сказать что-либо об этих
объектах (целевые признаки).
Если целевой признак не определён – это задачи обучения без учителя.
Например, задача на сортировку объектов. Даны фотографии, которые необходимо
систематизировать и определить ту часть, которая соответствует одному человеку, часть
другому и т.д.
Есть также такой тип задач как обучение с подкреплением, о которых подробнее
будет рассказано в курсе. Некоторый объект взаимодействует со средой и получает от
неё либо награды, либо наказания, но при этом описания каждой ситуации нет.
Глубокое МО - построение признаков
Глубокое машинное обучение и машинное обучение – разные вещи.
Обучаем алгоритм операцией «нахождение признаков», заставим машину
придумывать признаки самостоятельно (1ый этап), а затем будем классифицировать то,
что имеем, по тем признакам, которые выделила машина (2ой этап).
В частности, касаемо распознавания объектов на изображениях:
1) в качестве первого слоя используем градиенты на изображении, выделяются
некоторые геометрические фигуры;
2) на втором слое мы можем распознавать отдельные объекты в изображении;
3) на третьем слое из отдельных частей, фрагментов собирается целостная
картина.
Кратко: детали изображения → фрагменты → объекты.
Чем больше слоёв, тем более детальный анализ картинки машина может провести.
8
Модель нейрона Мак-Каллока-Питтса. Линейная регрессия и классификация
Рисунок 1.1 Модель нейрона Мак-Каллока-Питтса

Одна из самых первых моделей нейрона. Многие элементы, связанные с
машинным обучением, основаны на элементах из биологии, на том, как работает мозг.
Принцип работы: есть входы x1, x2, … xn – значения признаков. Входы умножаются на
набор весов w1, w2, … wn, результат суммируется и подаётся на функцию активации
(нелинейная функция, которая оперирует с числом). Результат подаётся на выход,
который, в свою очередь, можно подать на вход нового нейрона и т.д.
Получаем сложную, но обучаемую сеть. Обучаема она за счёт того, что веса мы
можем подбирать так, чтобы на выходе мы получили то, что нам нужно.
𝑦 = 𝜑 (∑ 𝑥𝑖 𝑤𝑖 )
Самые простейшие задачи, выполняемые нейроном: линейная регрессия и
линейная классификация.
Рисунок 1.2 Задачи, выполняемые нейроном, а) линейная регрессия б) линейная

классификация
Линейная регрессия: веса и значения «х» подбираются таким образом, чтобы все
«х» можно было аппроксимировать прямой линией.
9
Линейная классификация: в зависимости от данной на вход выборки, происходит

её разделение на два класса. В зависимости от весов проводится линия, которая разделяет
группу точек на те, что под прямой и над прямой. Линия проводится как можно точнее.
Для оптимизации весов wi необходимо указать функционал качества (функцию
потерь) ℒ(𝑎, 𝑥⃗, 𝑦).
Построение моделей. Прямые и обратные задачи. Алгоритм решения
Модель – совокупность имеющихся или предполагаемых правил и параметров,
которые определяют поведение объекта или характеристики исследуемых сигналов. Она
позволяет свести описание сложной системы к (относительно) небольшому числу
параметров и обладает предсказательной силой.
Некоторые типичные примеры моделей:
• Полиномиальная 𝑓(𝑥) = 𝛼0 + 𝛼1 𝑥 + 𝛼2 𝑥 2 + ⋯
• Циклическая 𝑓(𝑥) = 𝐴1 sin(𝑤1 𝑥) + 𝐴2 sin(𝑤2 𝑥) + ⋯
• Модель скользящего среднего
𝑀
𝑓𝑛 = ∑ 𝛼𝑚 𝑔𝑛−𝑚 + 𝜉𝑛
𝑚=1
• Авторегрессионная модель
𝑀
𝑓𝑛 = ∑ 𝛼𝑚 𝑓𝑛−𝑚 + 𝜉𝑛
𝑚=1
• Модель гауссовского процесса
1 (𝑥−𝑥̅ )2
2) −
𝑁(𝑥̅ , 𝜎 = 𝑒 2𝜎2
√2𝜋𝜎
Прямая задача – необходимо определить, как будет вести себя модель, все
характеристики которой заданы.
Обратная задача – необходимо по заданному поведению объекта построить
модель и определить все ее характеристики. В ряде случаев для этого объект можно
подвергнуть заданному внешнему воздействию.
Общая схема постановки и решения задач машинного обучения:
1) Имеется множество объектов 𝕏, каждый из которых задан вектором
признаков 𝑥⃗.
2) Имеется обучающая выборка объектов 𝕏𝑡𝑟𝑎𝑖𝑛 ⊂ 𝕏 из L объектов, для
которых задан целевой признак у.
10
3) Задается функционал качества ℒ(𝑎, 𝑥⃗, 𝑦), характеризующий, насколько

хорошо алгоритм а аппроксимирует значения целевого признака для
объектов из множества 𝕏.
4) Выбирается параметрическая модель 𝑎(𝑥⃗, 𝜃⃗).
5) Параметры модели 𝜃⃗ оптимизируются для достижения минимума ℒ.
11
Лекция 2. Библиотеки Python, используемые для машинного обучения.

Практическое занятие
Рассмотрим применение библиотек языка программирования Python, которые
используются в машинном обучении. Разбор задачи.
Google Colaboratory - облачный сервис на среде Jupyter Notebook
Google предоставляет бесплатный вычислительный комплекс, который можно
использовать в обработке данных. Чтобы им воспользоваться, нужно выполнить
следующую последовательность действий: открыть личный Google-диск, нажать на
кнопку «Создать», выбрать тип файла «Google Colaboratory». При создании такого
документа получается Jupyter Notebook, в котором в дальнейшем можно работать.
Jupyter Notebook – документ, в котором есть возможность программировать на
языке Python. При первом запуске кода выполняется подключение к виртуальной
машине, что может незначительно замедлить первоначальную скорость выполнения
алгоритма.
Есть возможность отслеживать занимаемую оперативную память, подключать
ускорители, что позволит распараллелить код и решать задачи, требующие большого
количества вычислений, достаточно быстро.
Библиотека Pandas - работа с таблицами
Адрес ноутбука с материалами, показанными в лекции:
https://colab.research.google.com/drive/1tzekUR7XYY6UixcwWQwIjs4wi_FQBoIe#
scrollTo=RjJocNVNQFyw&uniqifier=1
Курс kaggle по pandas: https://www.kaggle.com/learn/pandas
Курс kaggle по seaborn: https://www.kaggle.com/learn/data-visualization
1. Импорт библиотеки. Создание, чтение и запись таблиц
import pandas as pd
Таблица - объект DataFrame
Создадим таблицу из словаря. Ключи задают названия колонок, а массивы
значений - данные. Они должны быть одной длины.
df1 = pd.DataFrame({'Column1': [1, 23, 5, 9], 'Column2': [2, 4
, 7, 8]})
df1
#df1.head()
df1.tail(2)
#df1.shape # (число строк - R; число столбцов - C)
12
Можно создать таблицу и из списка, но тогда требуется явно указывать названия

колонок.
В отличие от словаря, теперь каждый элемент списка задает отдельный объект.
# По умолчанию колонки именуются числами
#df2 = pd.DataFrame([[1, 23, 5], [2, 4, 7]])
#df2
# Именованные колонки
#df3 = pd.DataFrame([[1, 23, 5], [2, 4, 7]], columns=['A','B',
'C'])
#df3
# Используем именованные индексы
df4 = pd.DataFrame([[1, 23, 5], [2, 4, 7]], columns=['A','B','
C'],index=['First object','Second object'])
df4
Таблица с единственной колонкой - объект Series

# Простая колонка
#pd.Series([1, 2, 3, 4, 5])
# Именованная колонка
#pd.Series([1, 2, 3, 4, 5], index=['A','B','C','D','E'])
# Используем именованные индексы
pd.Series([1, 2, 3, 4, 5], index=['A','B','C','D','E'], name='
letters')
Можно прочитать CSV файл, расположенный локально или на внешнем сайте
irisDataURL = 'https://archive.ics.uci.edu/ml/machine-
learning-databases/iris/iris.data'
iris_data = pd.read_csv(irisDataURL, names=['Длина чашелистика
','Ширина чашелистика','Длина лепестка','Ширина лепестка','cla
ss'])
iris_data.head()
13
Теперь можно сохранить файл локально

iris_data.to_csv('iris_data.txt') # Сохраним в текстовый файл,
чтобы посмотреть, как он устроен
iris_data.to_csv('iris_data.csv') # Сохраним в CSV файл с наст
ройками по умолчанию
iris_data.to_csv('iris_data2.csv', sep=';', header=False) # Со
храним в CSV файл, задав некоторые настройки
iris_data.to_excel('iris_data.xlsx') # Сохраним в XLS файл, за
дав некоторые настройки
2. Индексирование, выборка и присваивание значений

2.1. «Нативная выборка»
Сделаем выборку по имени колонки (в зависимости от того, где стоит #,
получается разный результат)
df1
df1.Column1
df1['Column1']
iris_data
iris_data['Длина чашелистика']
#iris_data.class
Можно сделать выборку по индексу в колонке

print(iris_data.head())
print("\n", "-"*80, "\n")
print(iris_data['Длина чашелистика'][0])
print("\n", "-"*80, "\n")
print(df4)
print("\n", "-"*80, "\n")
14
print(df4['A']['First object'])
Можно переименовать колонки или индекс

df4.rename(columns={'A': 'AAA','B':'b'}).rename(index={'First
object':'Third object'})
2.2. Выборка по номеру с помощью iloc

print(iris_data.iloc[0]) # Напечатать первый объект (строку
) таблицы
print("\n", "-"*80, "\n")
print(iris_data.iloc[0,1]) # Напечатать вторую колонку первой

строки таблицы
print("\n", "-"*80, "\n")
print(iris_data.iloc[0:10, 0:4:2])# Можно использовать слайсы
15
2.3. Выборка по имени с помощью loc

print(iris_data.loc[0]) # Напечатать первый объект (строку)
таблицы
print("\n", "-"*80, "\n")
print(iris_data.loc[0, 'Ширина чашелистика']) # Напечатать

вторую колонку первой строки таблицы
print("\n", "-"*80, "\n")
print(iris_data.loc[0:10, ['Длина чашелистика', 'Длина лепестк

а']]) # Можно явно указать колонки по именам
Отличие в индексировании iloc и loc связано с тем, что loc работает с

индексами, как с именами, и поэтому правый край диапазона включается
16
print(iris_data.iloc[0:5])
print("\n", "-"*80, "\n")
print(iris_data.loc[0:5])
В таблице можно задать одну колонку как индексную

iris_data.set_index('class')
А можно задать и несколько колонок

iris_data2cols = iris_data.set_index(['class', 'Длина чашелист
ика'])
iris_data2cols
17
Работать с таким индексом сложнее

iris_data2cols.loc['Iris-setosa'].loc[5.1]
2.4. Условные выборки

print( iris_data[iris_data['Длина чашелистика']>5.0].head()
)
print("\n", "-"*80, "\n")
print( iris_data[(iris_data['Длина чашелистика']>6.0) & (iris

_data['class']=='Iris-virginica')].head() )
print("\n", "-"*80, "\n")
print( iris_data[(iris_data['Длина чашелистика']>6.0) & (iris

_data['class'].isin(['Iris-setosa','Iris-
virginica']))].head() )
print("\n", "-"*80, "\n")
print( iris_data[iris_data['class'].isnull()].head() )
# notnull()
18
2.5. Присваивание
Можно присвоить одинаковое значение всей колонке
iris_data2 = iris_data.copy()
iris_data2['class'] = 'newclass'
iris_data2.head()
Или можно сделать выборку и присвоить значение элементам выборки

iris_data2.loc[0:2, 'class'] = 'newclass'
iris_data2.head()
Можно присвоить выборке список с разными значениями

classes = ['class1', 'class2', 'class2']
iris_data2.loc[0:2, 'class'] = classes

iris_data2.head()
2.6. map и apply
19
Функция map позволяет преобразовать одно значение в другое путем применения

переданной ей функции.
Обратите внимание: она применяется к объекту Series
iris_square = iris_data['Длина чашелистика'].map(lambda l: l**
2).rename('Квадрат длины чашелистика')
print(iris_square)
Функция apply позволяет преобразовать одну строку в таблице в другую путем

применения переданной ей функции.
Обратите внимание: она применяется к объекту DataFrame
def iris_transform_row(row):
row['Квадрат длины чашелистика'] = row['Длина чашелистика']*
*2
return row
iris_data.apply(iris_transform_row, axis='columns').head()
Можно использовать apply, обрабатывая столбцы

def iris_transform_column(col):
return col.mode()[0]
iris_data.apply(iris_transform_column, axis='index')
3. Агрегатные функции. Группировка, сортировка, комбинирование

3.1. Агрегатные функции
describe - описывает все колонки
iris_data.describe()
20
unique - выдает уникальные значения value_counts - считает число

вхождений каждого уникального значения
print(iris_data['class'].unique())
print('-'*80)
print(iris_data['class'].value_counts())
print("mean=%f; median=%f; max=%f" % (iris_data['Длина чашелис

тика'].mean(), iris_data['Длина чашелистика'].median(), iris_d
ata['Длина чашелистика'].max()) )
print("mean=%f; median=%f; max=%f" % tuple(iris_data['Длина ча

шелистика'].agg(['mean','median','max']).to_list()) )
3.2. Группировка
iris_data.groupby('class')['Длина чашелистика'].mean()
Можно группировать по нескольким колонкам

iris_data.groupby(['class','Длина лепестка'])['Длина чашелисти
ка'].agg(['min','mean','max'])
21
3.3. Сортировка
iris_data.sort_values(by='Ширина чашелистика')
iris_data.sort_values(by='Ширина чашелистика', ascending=False

)
3.4. Комбинирование таблиц

iris_data1 = iris_data[(iris_data['class']=='Iris-
setosa') & (iris_data['Длина чашелистика']<4.5)]
iris_data2 = iris_data[(iris_data['class']=='Iris-
virginica') & (iris_data['Ширина лепестка']>2.3)]
print(iris_data1, "\n", '-'*80, "\n", iris_data2)
22
Объединим 2 таблицы "вертикально"

pd.concat([iris_data1, iris_data2])
Можно объединить таблицы "горизонтально", с учетом индексов.

Поскольку индексы двух таблиц могут не совпадать, есть различные варианты
выполнить такое слияние
pd.concat([iris_data1, iris_data2], axis='columns')
Сбросим индекс, чтобы соответствующие по порядку строки слились.

По умолчанию (join='outer') выбирается объединение множеств индексов таблиц.
Недостающие значения заполняются NaN.
pd.concat([iris_data1.reset_index(), iris_data2.reset_index()]
, axis='columns')
23
Можно поставить (join='inner'), тогда выбирается пересечение множеств индексов

таблиц, и пропущенных значений не возникает.
pd.concat([iris_data1.reset_index(), iris_data2.reset_index()]
, axis='columns', join='inner') # default join='outer'
Другой вариант - заполнить дополнительные колонки только для индексов из

первой таблицы
iris_data1.join(iris_data2, lsuffix='_data1', rsuffix='_data2'
) # Здесь индексы не сброшены, поэтому все поля, соответствующ
ие 2 таблице, заполнены NaN
iris_data1.reset_index().join(iris_data2.reset_index(), lsuffi
x='_data1', rsuffix='_data2') # Здесь индексы сброшены, все по
ля заполняются
iris_data21 = iris_data2.reset_index().join(iris_data1.reset_i
ndex(), lsuffix='_data2', rsuffix='_data1') # Здесь индексы сб
рошены, но не для всех нашлись значения, поэтому пристутсвуют
NaN
iris_data21
24
4. Типы данных и работа с пропущенными значениями

Очень просто можно узнать тип данных. Строка обозначается как object
При необходимости тип данных можно преобразовать к другому типу
Теперь посмотрим, как отображаются пропущенные значения - это особый тип

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

pd.isnull(iris_data21) # pd.notnull()
Можно заполнить пропущенное значение каким-то образом
25
iris_data21['Длина чашелистика_data1']=iris_data21['Длина чаше

листика_data1'].fillna('Unknown')
iris_data21
Бывает полезно осуществить замену одного значения другим

iris_data21['Длина чашелистика_data1'].replace('Unknown','I do
n\'t know')
Seaborn и matplotlib - библиотеки для визуализации данных

1. Matplotlib
1.1. Построение простых графиков
x = np.arange(-2, 2, 0.01)
y = np.exp(-x**2)*np.cos(4*np.pi*x)
y1 = np.exp(-x**2)*np.sin(4*np.pi*x)
y2 = np.exp(-(x-1)**2)
y3 = np.exp(-(x+1)**2)*np.sin(2*np.pi*x)
plt.plot(x, y)
# Цвет и стиль линии

plt.plot(x, y1, 'r:')
# Цвет, толщина и стиль линии по-отдельности

plt.plot(x, y2, 'g', linewidth=4, linestyle='--')
# Маркеры (o, s, x, X, d, D, v, <, >, ^, h)

plt.plot(x[::5], y3[::5], 'k--h')
plt.show()
26
1.2. Управление отображением нескольких графиков

# Одиночный график
fig = plt.figure(figsize=(12, 4), dpi=80) # Задаем размер фи
гуры
fig.suptitle('Импульс') # Заголовок
plt.plot(x, y) # Строим саму фигу
ру
plt.show() # Отображаем резул
ьтат
# Несколько графиков
fig, axs = plt.subplots(nrows=1, ncols=2) # Задаем сетку для
отображения графиков
fig.suptitle('Много импульсов') # Общий заголовок
fig.set_size_inches(12, 4) # Задаем размер ка
ртинки в дюймах
# Первый график, его заголовок и подписи осей

axs[0].plot(x, y1)
axs[0].set_title('Plot of $y_1$') # Можно использова
ть latex в названиях
axs[0].set_xlabel('x')
axs[0].set_ylabel('$y_1$')
# Второй график, его заголовок и подписи осей

axs[1].plot(x, y2, 'r')
axs[1].set_title('Plot of $y_2$')
axs[1].set_xlabel('x')
axs[1].set_ylabel('$y_2$')

ьтат
fig.savefig('result.png', dpi=100) # Сохраняем резуль
тат в картинку
27
1.3. График двух величин (диаграмма рассеяния)

N=500
x = np.random.randn(N)
y = np.random.randn(N)
color = list('r'*(N//3) + 'b'*(N-

N//3)) # Треть точек будет красными, а остальные - синими

гуры
fig.suptitle('Две независимые гауссовские величины') # Заголов
ок
plt.scatter(x, y, c=color, marker='v') # Строим саму фигу
ру
ьтат
28
2. Seaborn
Импорт библиотеки
import seaborn as sns
2.1. Построение графиков
plt.figure(figsize=(16,6))
_ = sns.lineplot(data=x)
Можно построить графики сразу для всей таблицы

_ = sns.lineplot(data = iris_data)
Можно выбрать, что конкретно строить и настроить отображение результатов

plt.title("Свойства цветов ириса")
29
sns.lineplot(data=iris_data['Длина чашелистика'], label="Длина

чашелистика")
sns.lineplot(data=iris_data['Ширина чашелистика'], label="Шири
на чашелистика")
plt.xlabel("Номер образца")
plt.ylabel("Размер, мм")
plt.show()
2.2. Столбцовая диаграмма

plt.title("Свойства цветов ириса")
sns.barplot(data=iris_data, x='class', y='Длина чашелистика')

plt.show()
2.3. Тепловая карта

й flights = sns.load_dataset("flights")
print(flights.head())
print("\n","-"*80,"\n")
flights_data = flights.pivot("month", "year", "passengers")

print(flights_data)
plt.title("Данные полетов")
30
sns.heatmap(data=flights_data, annot=True, fmt="d", linewidths

=.5)
plt.show()
2.4. График двух величин (диаграмма рассеяния)

й N=500
y = np.random.randn(N)
color = list('r'*(N//3) + 'b'*(N-

N//3)) # Треть точек будет красными, а остальные - синими

гуры
fig.suptitle('Две независимые гауссовские величины') # Заголов
ок
sns.scatterplot(x=x, y=y, c=color, marker='v') # Строим с
аму фигуру
ьтат
31
N=500
y1 = 2*x + 4*np.random.randn(N)
y3 = x**3 - 2*x**2 + x + 4*np.random.randn(N)
fig, axs = plt.subplots(nrows=1, ncols=2) # Задаем сетку для

отображения графиков
fig.suptitle('Две зависимые величины')
fig.set_size_inches(12, 4) # Задаем размер ка
ртинки в дюймах
sns.regplot(x=x, y=y1, color='r', marker='^', ci=68, ax=axs[0]

) # Можно задать цвет тип маркера, доверительный уровень
sns.regplot(x=x, y=y3, order=3, ax=axs[1]) # Можно задать цв

ет тип маркера, доверительный уровень
plt.show()
Можно выделить цветом разные типы объектов

_ = sns.scatterplot(data=iris_data, x='Длина чашелистика', y='
Ширина чашелистика', hue='class')
Можно провести регрессионную зависимость для каждого типа объектов
32
_ = sns.lmplot(data=iris_data, x='Длина чашелистика', y='Ширин

а чашелистика', hue='class')
2.5. Графики для отображения категориальных и количественных признаков

й fig, axs = plt.subplots(nrows=1, ncols=4)
fig.set_size_inches(20, 4)
sns.stripplot(data=iris_data, x='class', y='Ширина чашелистика

', ax = axs[0])
sns.swarmplot(data=iris_data, x='class', y='Ширина чашелистика
', ax = axs[1])
sns.violinplot(data=iris_data, x='class', y='Ширина чашелистик
а', ax = axs[2])
sns.boxplot(data=iris_data, x='class', y='Ширина чашелистика',
ax = axs[3])
plt.show()
2.6. Распределения
Гистограммы и приближения для восстановления плотности распределения
fig, axs = plt.subplots(nrows=1, ncols=3)

sns.histplot(data=iris_data, x='Ширина чашелистика', kde=False

, ax=axs[0])
33
sns.histplot(data=iris_data, x='Ширина чашелистика', kde=True,

bins=25, ax=axs[1])
sns.kdeplot(data=iris_data[iris_data['class']=='Iris-
setosa']['Ширина чашелистика'], ax=axs[2], bw_adjust=1.0, shad
e=True)
versicolor']['Ширина чашелистика'], ax=axs[2], bw_adjust=1.0,
shade=True)
virginica']['Ширина чашелистика'], ax=axs[2], bw_adjust=1.0, s
hade=True)
_ = plt.plot()
Визуализация попарных распределений признаков
sns.jointplot(x=iris_data['Длина чашелистика'], y=iris_data['Ш
ирина чашелистика'], kind="kde");
_ = plt.show()
sns.pairplot(data=iris_data, hue='class');
34
Итог: какую функцию использовать в каждом случае
35
Лекция 3. Байесовский классификатор. Метод максимального правдоподобия.

Априорная и апостериорная информация.
В машинном обучении можно представить две возможные парадигмы
1. Вероятностная (когда признаки x – случайны, появляются с некоторой
вероятностью, работаем с распределениями)
2. Детерминированная (все данные – «результат эксперимента», на вход
получаем точные данные)
В данной лекции будут рассмотрены обе парадигмы.
Проверка статистических гипотез
• X - полученная в эксперименте выборка
• 𝔽 - множество априори допустимых распределений Х
• 𝐹𝑋 ∈ 𝔽 - истинное распределение X
• Нулевая гипотеза 𝐻0 : 𝐹𝑋 ∈ 𝔽0 ⊂ 𝔽
• Альтернатива 𝐻1 : 𝐹𝑋 ∈ 𝔽1 = 𝔽 \ 𝔽0
Простая гипотеза (или альтернатива) – такая, при которой множество 𝔽0 (или
𝔽1 ) содержит единственный элемент. Иначе гипотеза (или альтернатива) называется
сложной.
Если мы предположим, что 𝔽1 – единственный элемент, то это означает, что 𝐹𝑋
мы сравниваем с единственным элементом. Соответствующая гипотеза полностью
определяет распределения вероятностей, с которыми производится работа.
Статистический критерий – правило, согласно которому, наблюдая Х, можно
принять решение об отклонении гипотезы 𝐻0 .
Мы никогда не можем ничего подтвердить с помощью статистики, но некоторые
факты можно опровергнуть. Можно сказать, что мы принимаем некоторую гипотезу 𝐻0
и оказывается, что данные, полученные в эксперименте, плохо соответствуют этой
гипотезе.
Общий принцип - если при справедливости гипотезы 𝐻0 наблюдаемое событие
(выборка X) маловероятно, то такую гипотезу следует
отклонить.
Критическая область – множество выборок 𝕏1 ,
для которых гипотеза 𝐻0 отклоняется.
Истина
Нет Да
36
Нет
Отклонить
Ошибка 2 рода β Правильное не отклонение
?
Да
Правильное отклонение Ошибка 1 рода α
Таблица 3.1 Проверка статистических гипотез. Ошибки 1 и 2 рода

Ошибка 1 рода – гипотеза отклоняется, а на самом деле она была верна.
Ошибка 2 рода – гипотеза подтверждается, а на самом деле она была не верна.
Линию Г (гамма) необходимо провести таким образом, чтобы минимизировать
ошибки α и β.
1. Если всегда отклонять 𝐻0 , то получится β = 0; α > 0
2. Если никогда не отклонять 𝐻0 , то получится α = 0; β > 0
3. Пусть ошибка 1 рода не превышает α, а ошибка 2 рода будет минимальная -
критерий Неймана-Пирсона
4. Пусть "цена" ошибок 1 и 2 рода будет в среднем минимальная - байесовский
критерий
a. Если «цена» ошибок неизвестна, но заданы их вероятности – критерий
Котельникова (апостериорной плотности распределения)
b. Если неизвестны ни «цена», ни вероятность ошибок – критерий
максимального правдоподобия
Алгоритм тестирования
1. Определить нулевую гипотезу и альтернативу;
2. Задать уровень значимости (максимальную ошибку 1 рода) α;
3. Определить правила принятия решений;
4. Вычислить статистику теста;
5. Установить результат (отклонение или не отклонение нулевой гипотезы).
Пример Z-тест (z-критерий Фишера)
Результаты тестирования студентов распределены нормально со средним m = 100
и стандартным отклонением 𝜎0 = 10. После приёма волшебной таблетки группа из n =
25 студентов получила средний балл ℳ{𝑥} = 104 (математическое ожидание от x).
Следует ли пить таблетку перед тестом?
• Нулевая гипотеза 𝐻0 : таблетка не влияет на результат.
• Альтернатива 𝐻1 : таблетка изменяет результаты теста.
• Примем уровень значимости α = 0.05.
• Примем 𝐻0 . Тогда
1 (𝑥 − 𝑚)2
𝑤(𝑥)~𝒩(𝑚, 𝜎0 ) = exp (− ).
√2𝜋𝜎0 2𝜎0 2
1 (ℳ{𝑥} − 𝑚)2 𝜎0
𝑤(ℳ{𝑥})~𝒩(𝑚, 𝜎) = exp (− 2
); 𝜎 = .
√2𝜋𝜎 2𝜎 √𝑛
37
ℳ{𝑥}−𝑚
• Тогда 𝑧= √𝑛~𝒩(0,1). При условиях задачи z = 2.
𝜎0
Рисунок 3.2 К задаче на проверку статистической гипотезы

p-value – вероятность получить для данной модели распределения такое же или
более экстремальное значение статистики, по сравнению с наблюдаемым, при условии,
что 𝐻0 верна.
Если p-value мало (𝑝(𝑧) ≤ 𝛼), следует отклонить 𝐻0 .
Если p-value велико (𝑝(𝑧) > 𝛼), данных для отклонения 𝐻0 мало.
Другой подход - определить критическое значение 𝑧𝑐𝑟𝑖𝑡 : 𝑝(𝑧𝑐𝑟𝑖𝑡 ) = 𝛼.
При условиях задачи p-value = 0.046 и 𝑧𝑐𝑟𝑖𝑡 = 1.96. Гипотезу нужно отклонить
(таблетка всё-таки влияет на результат студента)
Пример t-критерий Стьюдента
Результаты тестирования студентов распределены нормально со средним m = 100.
После приёма волшебной таблетки группа из n = 25 студентов получила средний балл
ℳ{𝑥} = 104 при стандартном отклонении 𝜎𝑥 = 10. Следует ли пить таблетку перед
тестом?
Разница в задачах: в первой было известно стандартное отклонение для
изначального распределения. Во второй же задаче мы имеем эмпирическое стандартное
отклонение, полученное для группы из 25 студентов.
• Примем уровень значимости α = 0.05.
• Примем 𝐻0 . Тогда
ℳ{𝑥} − 𝑚
𝑡= √𝑛~𝑡(𝑛 − 1), где
𝜎𝑥
𝑛 2
(𝑥𝑗 − ℳ {𝑥})
𝜎𝑥2 =∑ − оценка дисперсии.
𝑛−1
𝑗=1
• При условиях задачи 𝑡 = 2 и 𝑡𝑐𝑟𝑖𝑡 (𝛼 = 0.05, 𝑛 − 1 = 24) = 2.064
В этом случае мы не можем принять решение об отклонении гипотезы 𝐻0 .
Пример – задача (для самостоятельного решения)
38
В двух группах по п студентов прошло тестирование. В первой группе студенты

не принимали таблетки, и средний балл оказался равен 100. Во второй группе студенты
принимали таблетки, и средний балл оказался равен 104.
• Принят уровень значимости α = 0.05. Получено p-value = 0.04.
Какие утверждения справедливы?
1. Таблетка - причина повышенных результатов с вероятностью 0.96.
2. Вероятность того, что результаты не связаны с таблеткой, равна 0.04.
3. При p-value = 0.06 результаты не связаны с таблеткой.
4. Вероятность получить такие различия случайно равна 0.04.
5. Все утверждения неверные.
Принятие решений в бинарной ситуации, при нескольких возможных исходах
Истина
Нет, p0 Да, p1
1
Альтернати
Ложная тревога Правильное обнаружение

ва
0
Правильное необнаружение Пропуск цели
Таблица 3.2 Метод Байеса
• Известна "матрица платежей" (в бинарном случае 2х2)

• Известны p0 и p1 – априорные вероятности событий
• Для каждого 𝑥 ∈ 𝑋 известны 𝑝(x|1) и 𝑝(x|0) (1 – наличие, 0 – отсутствие)
1, 𝑥 ∈ 𝑋1 1, 𝑥 ∈ 𝑋0
Да(𝑥) = { Нет(𝑥) = {
0, 𝑥 ∈ 𝑋0 0, 𝑥 ∈ 𝑋1
ЦЛТ – цена ложной тревоги, ЦПЦ – цена пропуска цели
Риск = ЦЛТ ∙ 𝑝(𝑥 ∈ 𝑋1 , 0) + ЦПЦ ∙ 𝑝(𝑥 ∈ 𝑋0 , 1)
= ЦЛТ ∫ 𝑝(𝑥|0)𝑝0 𝑑𝑥 + ЦПЦ ∫ 𝑝(𝑥|1)𝑝1 𝑑𝑥
𝑋1 𝑋0
= ЦЛТ ∫ 𝑑𝑥(ЦЛТ ∙ Да(𝑥)𝑝(𝑥|0)𝑝0 + ЦПЦ ∙ Нет(𝑥)𝑝(𝑥|1)𝑝1 )

𝑋
Минимизируем риск, выбирая для каждого x значения Да или Нет
ЦЛТ ∙ 𝑝(𝑥|0)𝑝0 Да
≶ 1
ЦПЦ ∙ 𝑝(𝑥|1)𝑝1
Нет
Отношение правдоподобия L:
𝑝(𝑥|0) Да ЦЛТ ∙ 𝑝0
𝐿= ≶
𝑝(𝑥|1) ЦПЦ ∙ 𝑝1
Нет
39
Рисунок 3.3 Построение разделяющих поверхностей

Наивный байесовский классификатор (naive Bayes) – специальный частный
случай байесовского классификатора, основанный на дополнительном предположении,
что объекты описываются статистически независимыми признаками.
𝑘
𝑤(𝑥1 , 𝑥2 , … , 𝑥𝑛 |𝜃) = ∏ 𝑤(𝑥𝑗 |𝜃)

𝑗=1
Условно говоря, интересующий нас признак 𝑥 похож на «вектор», он имеет
компоненты. Каждая компонента вектора рассматривается как независимый признак.
На практике это условие почти никогда не выполняется, но позволяет упростить
задачу.
Метод Байеса:
• Известна цена ошибки λy для каждого события (класса) 𝑦 ∈ 𝑌
• Известны априорные вероятности событий 𝑝𝑦
• Для каждого 𝑥 ∈ 𝑋 известны 𝑝(𝑥|𝑦)
Если 𝑎(𝑥) – алгоритм, который для значения 𝑥 выдаёт его класс, то можно
ввести функцию ошибки:
1, 𝑎(𝑥) ≠ 𝑦
Ошибка(𝑥) = {
0, 𝑎(𝑥) = 𝑦
Риск = ∑ 𝜆𝑦 ∫ 𝑝(𝑥, 𝑦)Ошибка(𝑥)𝑑𝑥
𝑦∈𝑌
Минимум риска достигается, если алгоритм 𝑎(𝑥)
𝑎(𝑥) = arg max 𝜆𝑦 𝑝𝑦 𝑝(𝑥|𝑦)
𝑦∈𝑌
Недостаток метода Байеса заключается в том, что человеку необходимо
учитывать много фактов, иметь немало сведений о признаках, знать модельные
зависимости.
Оценка постоянных параметров сигнала. Байесовский подход
Необходимо построить оценку 𝜃̂ параметра 𝜃
40
В эксперименте получены значения 𝑦⃗ = 𝑦1 , 𝑦2,…, 𝑦𝑛 ,

причем 𝑤(𝑦⃗|𝜃) зависит от 𝜃
Априори известно распределение 𝑤(𝜃)
Пример:
1⁄𝑎 |𝜃 − 𝜃0 | ≤ 𝑎⁄2
𝑤(𝜃) = {
0 |𝜃 − 𝜃0 | > 𝑎⁄2
Если 𝑎 → 0, то играет роль априорная информация; Рисунок 3.4 Оценка постоянных
параметров сигнала
Если 𝑎 → ∞, то важны экспериментальные данные.
В эксперименте получены данные 𝑦⃗

Ошибка оценки 𝜖 (𝜃; 𝜃̂(𝑦⃗)) = 𝜃̂(𝑦⃗) − 𝜃
Характеристика потерь ℒ(𝜖) = ℒ (𝜃; 𝜃̂(𝑦⃗)) – по сути и есть цена ошибки
Нужно найти минимум средней функции потерь
∞ ∞
ℳ {ℒ (𝜃; 𝜃̂(𝑦⃗))} = ∫ 𝑑𝜃 ∬ 𝑑𝑦⃗ℒ (𝜃; 𝜃̂ (𝑦⃗)) 𝑤(𝜃, 𝑦⃗)
−∞ −∞
Примеры функции потерь:
• Квадратичная: ℒ𝑞𝑢𝑎𝑑 (𝜃; 𝜃̂) = (𝜃 − 𝜃̂)2
• Модульная: ℒ𝑚𝑜𝑑 (𝜃; 𝜃̂) = |𝜃 − 𝜃̂|
• Простая: ℒ𝑠𝑖𝑚𝑝𝑙𝑒 (𝜃; 𝜃̂) = −𝛿(𝜃 − 𝜃̂)
∞ ∞
ℳ {ℒ (𝜃; 𝜃̂(𝑦⃗))} = ∫ 𝑑𝜃 ∬ 𝑑𝑦⃗ℒ (𝜃; 𝜃̂(𝑦⃗)) 𝑤(𝜃, 𝑦⃗)
−∞ −∞
∞ ∞
= ∬ 𝑑𝑦⃗ ∫ 𝑑𝜃ℒ (𝜃; 𝜃̂(𝑦⃗)) 𝑤(𝜃, 𝑦⃗)𝑤(𝑦⃗)
−∞ −∞
∞ ∞
= ∬ 𝑑𝑦⃗𝑤(𝑦⃗) ∫ 𝑑𝜃ℒ (𝜃; 𝜃̂ (𝑦⃗)) 𝑤(𝜃, 𝑦⃗)
−∞ ⏟−∞
ℒ𝑎
𝜕ℒ𝑎
ℒ𝑎 → min; =0
𝜕𝜃̂
Квадратичная функция потерь: ℒ𝑞𝑢𝑎𝑑 (𝜃; 𝜃̂) = (𝜃 − 𝜃̂)2

∞
∫ 𝜃𝑤(𝜃|𝑦⃗)𝑑𝜃
∫ 𝑑𝜃 (𝜃 − 𝜃̂(𝑦⃗)) 𝑤(𝜃|𝑦⃗) = 0 ⇒ 𝜃̂(𝑦⃗) = = ∫ 𝜃𝑤(𝜃|𝑦⃗)𝑑𝜃
−∞ ∫ 𝑤 (𝜃|𝑦⃗)𝑑𝜃
Это математическое ожидание для апостериорного распределения 𝑤(𝜃|𝑦⃗).
Простая функция потерь: ℒ𝑠𝑖𝑚𝑝𝑙𝑒 (𝜃; 𝜃̂) = −𝛿(𝜃 − 𝜃̂)
𝜕 𝜕𝑤(𝜃|𝑦⃗)
∫ 𝑤(𝜃|𝑦⃗)𝛿(𝜃̂(𝑦⃗) − 𝜃)𝑑𝜃 = =0
𝜕𝜃̂ 𝜕𝜃̂
Это максимум апостериорного распределения 𝑤(𝜃|𝑦⃗).
41
Рисунок 3.5 Оценки для симметричных и асимметричных распределений
Формула Байеса: 𝑤(𝜃|𝑦⃗)𝑤(𝑦⃗) = 𝑤(𝑦⃗|𝜃)𝑤(𝜃)

1
𝑤(𝜃|𝑦⃗) = 𝑤(𝑦⃗|𝜃)𝑤(𝜃)
𝑤(𝑦⃗)
Функция правдоподобия – условная вероятность 𝐿(𝜃) ≡ 𝑤(𝑦⃗|𝜃), взятая при
фиксированных (полученных в эксперименте) значениях 𝑦⃗.
• Метод максимума апостериорной функции распределения 𝑤(𝜃̂|𝑦⃗)
• Метод максимального правдоподобия 𝐿(𝜃) – если неизвестно априорное
распределение
𝑦⃗ = {𝑦1 , 𝑦2 , … , 𝑦𝑘 } − наблюдения параметра 𝜃 на фоне шума 𝑛⃗⃗
= {𝑛1 , 𝑛2 , … , 𝑛𝑘 }, (0; 𝜎 2 )
Модель такой системы: 𝑦𝑗 = 𝜃 + 𝑛𝑗
Априорное распределение θ нормально:
1 (𝜃 − 𝜃0 )2
𝑤(𝜃) = exp (− ).
√2𝜋𝜎0 2𝜎0 2
Наблюдения параметра на фоне гауссового шума
𝑦𝑗 = 𝜃 + 𝑛𝑗 ⇒ 𝑛𝑗 = 𝑦𝑗 − 𝜃
Распишем функцию правдоподобия:
𝑘
1 1 2
𝐿(𝜃) ≡ 𝑤(𝑦⃗|𝜃) = ∏ 𝑤(𝑦𝑗 |𝜃) = 𝑘 ⁄2 𝑘
exp (− 2 ∑(𝑦𝑗 − 𝜃) )
(2𝜋) 𝜎 2𝜎
𝑗 𝑗=1
max 𝐿(𝜃) ⇔ max ln 𝐿(𝜃)
𝑘 𝑘 𝑘
𝜕 2 1
∑(𝑦𝑗 − 𝜃) = 0 ⇒ ∑ 𝑦𝑗 − 𝜃 ⇒ 𝜃̂𝑚𝑙𝑒 = ∑ 𝑦𝑗
𝜕𝜃̂ 𝑘
𝑗=1 𝑗=1 𝑗=1
2 2 2
𝑘 𝑘
2 2}
1 1 𝜎2
𝜎 𝑚𝑙𝑒 = ℳ{(𝜃𝑚𝑙𝑒 − 𝜃) = ℳ {( ∑ 𝑦𝑗 − 𝜃) } = ℳ ( ∑ (𝑦⏟𝑗 − 𝜃 ) ) =
𝑘 𝑘 𝑘
𝑗=1 𝑗=1 𝑛𝑗
{ }
42
1
𝑤(𝜃|𝑦⃗) = 𝑤(𝑦⃗|𝜃)𝑤(𝜃) =
𝑤(𝑦⃗)
𝑘
1 1 1 2 1
= ⁄
exp (− 2 ∑(𝑦𝑗 − 𝜃) − (𝜃 − 𝜃0 )2 )
𝑤(𝑦⃗) (2𝜋) (𝑘+1) 2 𝑘
𝜎 𝜎0 2𝜎 2𝜎0 2
𝑗=1
max 𝑤(𝜃|𝑦⃗) ⇔ max ln 𝑤(𝜃|𝑦⃗)
𝑘
1 1
∑(𝑦𝑗 − ̂𝑚𝑎𝑝 ) +
𝜃 (𝜃̂ − 𝜃0 ) = 0
𝜎2 𝜎0 2 𝑚𝑎𝑝
𝑗=1
𝑘
𝑘 1 𝜃0 1 𝑘
𝜃̂𝑚𝑎𝑝 ( + 2 ) = 2 + ∑ 𝑦𝑗
⏟2
𝜎 𝜎0 𝜎0 𝑘 ⏟2
𝜎
1⁄𝜎2 𝑚𝑙𝑒
⏟𝑗=1 1⁄𝜎2
𝑚𝑙𝑒
̂2
𝜃 𝑚𝑙𝑒
𝜎 2 𝑚𝑙𝑒 𝜎0 2
𝜃̂𝑚𝑎𝑝 = 𝜃 + 𝜃̂𝑚𝑙𝑒
𝜎0 2 + 𝜎 2 𝑚𝑙𝑒 0 𝜎0 + 𝜎 2 𝑚𝑙𝑒
2
Если 𝜎0 2 ≫ 𝜎 2 𝑚𝑙𝑒 , то 𝜃̂𝑚𝑎𝑝 ≈ 𝜃̂𝑚𝑙𝑒 , т.е. эксперимент имеет решающее значение

Если 𝜎0 2 ≪ 𝜎 2 𝑚𝑙𝑒 , то данные эксперимента почти не существенны
Метод максимального правдоподобия в ряде случаев сложен.
Пусть 𝜃⃗ = {𝜃1 , 𝜃2 , … , 𝜃𝑚 } – неизвестные параметры
∞
𝑚𝑘 (𝜃⃗) = ∫ 𝑦 𝑘 𝑤(𝑦|𝜃⃗)𝑑𝑦 – начальные моменты (момент – средние значения от
−∞
данных экспериментов в некоторой степени)
∞
𝜇𝑘 (𝜃⃗) = ∫ (𝑦 − ℳ{𝑦})𝑘 𝑤(𝑦|𝜃⃗ )𝑑𝑦 – центральные моменты
−∞
1
𝑚̆ 𝑘 = 𝑛 ∑ 𝑦𝑗𝑘 – выборочные начальные моменты
1
𝜇̆𝑘 = 𝑛 ∑(𝑦𝑗 − 𝑚 ̂ 1 )2 – выборочные центральные моменты
̆ 𝑘 = 𝑚𝑘 (𝜃⃗𝑚𝑜𝑚 ) или 𝜇̆𝑘 = 𝜇𝑘 (𝜃⃗𝑚𝑜𝑚 ) – уравнение не обязательно линейное
𝑚
Пример: есть распределение
1
𝑤(𝑥|𝛼, 𝛽) = 𝑥 𝛼−1 exp(− 𝑥⁄𝛽 ) , 𝑥 ≥ 0; 𝛽 > 0
Г(𝛼)𝛽𝛼
Его параметры
𝑚1 = 𝛼𝛽; 𝑚2 = 𝛼(𝛼 + 1)𝛽 2 ; 𝜇2 = 𝛼𝛽 2 ; 𝜇3 = 2𝛼𝛽 3
1 1
𝑚1 (𝛼, 𝛽) = 𝑚
̆ 1 ⇒ 𝛼𝛽 = ∑ 𝑦𝑗 𝑚2 (𝛼, 𝛽) = 𝑚 ̆ 2 ⇒ 𝛼(𝛼 + 1)𝛽 2 = ∑ 𝑦𝑗 2
𝑛 𝑛
2 2
𝑚̆1 𝑚
̆2 − 𝑚̆1
𝛼̂𝑚𝑜𝑚 = ̂
2 ; 𝛽𝑚𝑜𝑚 = 𝑚
̆1
𝑚̆2 − 𝑚 ̆1
Такие оценки для 𝛼̂𝑚𝑜𝑚 и 𝛽̂𝑚𝑜𝑚 довольно просто получить.
Ещё один пример, применение метода максимального правдоподобия для
которого даёт особый результат: дана плотность распределения
43
1⁄𝜃 , 0 ≤ 𝑦𝑗 ≤ 𝜃
𝑤(𝑦𝑗 |𝜃) = {
0, 𝑦𝑗 < 0; 𝑦𝑗 > 𝜃
Метод максимального правдоподобия
1⁄𝜃 𝑘 , 0 ≤ 𝑦1 , 𝑦2 , … , 𝑦𝑘 ≤ 𝜃
𝐿(𝜃) = ∏ 𝑤(𝑦𝑗 |𝜃) = {
0, ∃𝑡: 𝑦𝑡 < 0; 𝑦𝑡 > 𝜃
Рисунок 3.6 Метод максимального правдоподобия

Функция распределения
𝐹(𝑥) = 𝑃(𝑋 < 𝑥) = 𝑃(max 𝑦𝑗 < 𝑥) = ∏ 𝑃(𝑦𝑗 < 𝑥) = 𝑥 𝑘 ⁄𝜃 𝑘
Плотность распределения:
𝑑𝐹
𝑤(𝑥) = = 𝑘𝑥 𝑘−1⁄𝜃 𝑘
𝑑𝑥
∞
𝑘
ℳ{𝜃̂𝑚𝑙𝑒 (𝑦⃗)} = ∫ 𝑥𝑤(𝑥)𝑑𝑥 = 𝜃
0 𝑘+1
Значит, оценка 𝜃̂𝑚𝑙𝑒 (𝑦⃗) – смещённая!
𝑘
Несмещённая оценка 𝜃̂𝑚𝑙𝑒−𝑛𝑜𝑏𝑖𝑎𝑠 (𝑦⃗) = max 𝑦𝑗
𝑘+1
Оценка дисперсии несмещённой оценки:
𝜃2
ℳ{(𝜃̂𝑚𝑙𝑒−𝑛𝑜𝑏𝑖𝑎𝑠 (𝑦⃗) − 𝜃)2 } =
𝑘(𝑘 + 2)
Метод моментов
𝜃 1 𝜃̂𝑚𝑜𝑚 (𝑦⃗)
𝑚1 (𝜃) = ; ∑ 𝑦𝑗 =
2 𝑘 2
2
𝜃̂𝑚𝑜𝑚 (𝑦⃗) = ∑ 𝑦𝑗
𝑘
2
2 2 𝜃2 𝜃2 𝑘+2 𝜃2
ℳ {(𝜃̂𝑚𝑙𝑒−𝑛𝑜𝑏𝑖𝑎𝑠 (𝑦⃗) − 𝜃) } = ℳ {( ∑ 𝑦𝑗 − 𝜃) } = = ∙ >
𝑘 3𝑘 𝑘(𝑘 + 2) 3 𝑘(𝑘 + 2)
Метод максимального правдоподобия оказывается точнее, так как дисперсия
метода моментов больше, однако метод моментов проще и быстрее в расчётах.
44
Лекция 4. Линейные методы регрессии и классификации

Схема постановки и решения задач обучения с учителем
• Имеется множество объектов 𝕏, каждый из которых задан вектором
признаков объектов 𝑥⃗
• Имеется обучающая выборка объектов 𝕏𝑡𝑟𝑎𝑖𝑛 ⊂ 𝕏 из 𝐿 объектов, для
которых задан целевой признак 𝑦
• Задаётся функционал качества ℒ(𝑎, 𝑥⃗, 𝑦), характеризующий насколько
хорошо алгоритм 𝑎 аппроксимирует значения целевого признака для
объектов из множества 𝕏
• Выбирается параметрическая модель 𝑎(𝑥⃗, 𝜃⃗)
• Параметры модели 𝜃⃗ оптимизируются для достижения минимума
Недообучение и переобучение. Феномен Рунге
Задача машинного обучения – задача экстраполяции данных из 𝕏𝑡𝑟𝑎𝑖𝑛 в 𝕏.
Алгоритм должен обладать обобщающей способностью.
Насколько сложным должен быть алгоритм?
1
Пример. (Феномен Рунге) Пусть значения функции 𝑦 = 1+𝑥 2 заданы в точках
𝑥𝑖 ,равномерно расположенных на промежутке от -5 до 5. Требуется найти полином
𝑃𝑁 (𝑥) = ∑𝑁 𝑛
𝑛=0 𝐴𝑛 𝑥 , наилучшим образом приближающий 𝑦(𝑥).
В качестве функционала качества можно взять среднеквадратичную ошибку:
𝐿
1
ℒ(𝑁) = 𝑀𝑆𝐸 ≡ ∑(𝑃𝑁 (𝑥𝑖 ) − 𝑦(𝑥𝑖 ))2
𝐿
𝑖=1
Степень полинома N определяет сложность модели и число коэффициентов.
Рисунок 4.1 Недообучение: модель слишком простая.
45
Рисунок 4.2 Модель удовлетворительно описывает функцию.
Рисунок 4.3 Переобучение: модель слишком сложная.

Причина переобучения – слишком большое число параметров модели,
подстроенных под конкретную обучающую выборку приводит к снижению
обобщающей способности.
Способ выявить переобучение – разбить выборку на обучающую и контрольную
и сравнить результаты.
Рисунок 4.4 Способ выявить переобучение

Как минимизировать вклад переобучения?
• Ввести регуляризацию в виде ограничений на параметры модели 𝜃⃗
• Разделить обучающую выборку на независимые части:
o 𝕏𝑡𝑟𝑎𝑖𝑛 – тренировочная подвыборка
46
o 𝕏𝑣𝑎𝑙 – валидационная подвыборка, причем 𝕏𝑡𝑟𝑎𝑖𝑛 ∩ 𝕏𝑣𝑎𝑙 = ∅

Обучать модель на 𝕏𝑡𝑟𝑎𝑖𝑛 , добиваясь минимальной ошибки на 𝕏𝑣𝑎𝑙
Неявно 𝕏𝑣𝑎𝑙 всё равно влияет на результаты обучения, поэтому на новых данных,
не включенных ни в 𝕏𝑡𝑟𝑎𝑖𝑛 , ни в 𝕏𝑣𝑎𝑙 , ожидается увеличение ошибки.
Эмпирические способы разбиения обучающей выборки
1. Hold-Out
a. Статическое разбиение обучающей выборки на 𝕏𝑡𝑟𝑎𝑖𝑛 и 𝕏ℎ𝑜
b. Определяются параметры 𝜃⃗: ℒ(𝑎(𝜃⃗), 𝑥⃗ ∈ 𝕏𝑡𝑟𝑎𝑖𝑛 ) → 𝑚𝑖𝑛
⃗𝜃⃗
c. Критерий качества – это значение ℒ(𝑎(𝜃⃗), 𝑥⃗ ∈ 𝕏ℎ𝑜 )

2. Leave-One-Out
a. Каждый элемент обучающей выборки по разу участвует в контроле
b. Определяются параметры ⃗⃗⃗⃗ ⃗⃗⃗⃗𝑖 ), 𝑥⃗ ∈ 𝕏𝑡𝑟𝑎𝑖𝑛 \{𝑥
𝜃𝑖 : ℒ(𝑎(𝜃 ⃗⃗⃗⃗})
𝑖 → 𝑚𝑖𝑛 ⃗⃗⃗⃗
𝜃𝑖
1
⃗⃗⃗⃗𝑖 ), ⃗⃗⃗⃗)
c. Критерий качества – это значение 𝐿 ∑𝐿𝑖=1 ℒ(𝑎(𝜃 𝑥𝑖
3. Cross-Validation
a. Обучающая выборка N раз разбивается на 𝕏𝑡𝑟𝑎𝑖𝑛,𝑖 и 𝕏𝑣𝑎𝑙,𝑖
b. Определяются параметры ⃗⃗⃗⃗ ⃗⃗⃗⃗𝑖 ), 𝑥⃗ ∈ 𝕏𝑡𝑟𝑎𝑖𝑛,𝑖 ) → 𝑚𝑖𝑛
𝜃𝑖 : ℒ(𝑎(𝜃
⃗⃗⃗⃗
𝜃𝑖
1
c. Критерий качества – это значение 𝑁 ∑𝑁 ⃗⃗⃗⃗ ⃗⃗⃗⃗𝑖 ∈ 𝕏𝑣𝑎𝑙,𝑖 )
𝑖=1 ℒ(𝑎(𝜃𝑖 ), 𝑥
Гиперпараметры
Гиперпараметры — параметры алгоритма, значения которых устанавливаются
перед запуском процесса обучения
Рисунок 4.5 Поиск значения гиперпараметров

Задачи линейной регрессии и линейной бинарной классификации
Задача линейной регрессии
𝑥𝑖 ∈ ℛ 𝑛 ; 𝑦𝑖 ∈ ℛ
⃗⃗⃗⃗
Выбирается линейная модель: 𝑎(𝑥⃗, 𝜃⃗) = (𝑥⃗; 𝜃⃗) = ∑𝑛𝑗=1 𝑥𝑗 𝜃𝑗
Квадратичная функция потерь: ℒ(𝑎, 𝑥⃗, 𝑦) = (𝑎 − 𝑦)2
Ставится задача оптимизации при ⃗⃗⃗⃗
𝑥𝑖 ∈ 𝕏𝑡𝑟𝑎𝑖𝑛 :
47
𝐿 𝐿
1 1 2
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ∑ ℒ(𝑎(𝑥
⃗⃗⃗⃗,𝑖 𝜃⃗), ⃗⃗⃗⃗,
𝑥𝑖 𝑦𝑖 ) = ∑ ((𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 ) − 𝑦𝑖 ) → 𝑚𝑖𝑛
𝐿 𝐿 ⃗⃗⃗⃗
𝜃𝑖
𝑖=1 𝑖=1
Решение проверяется при ⃗⃗⃗⃗
𝑥𝑖 ∈ 𝕏𝑣𝑎𝑙 :
𝐾
1 2
𝑄𝑣𝑎𝑙 (𝜃⃗) = ∑ ((𝑥
⃗⃗⃗⃗;
𝑖
⃗
𝜃 ) − 𝑦𝑖 )
𝐾
𝑖=1
Задача линейной бинарной классификации
⃗⃗⃗⃗𝑖 ∈ ℛ 𝑛 ; 𝑦𝑖 ∈ {−1; 1}
𝑥
Выбирается линейная модель: 𝑎(𝑥⃗, 𝜃⃗) = 𝑠𝑔𝑛(𝑥⃗; 𝜃⃗) = 𝑠𝑔𝑛 ∑𝑛𝑗=1 𝑥𝑗 𝜃𝑗
Квадратичная функция потерь: ℒ(𝑎, 𝑥⃗, 𝑦) = [𝑎𝑦 < 0]
𝐿 𝐿
1 1
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ∑[𝑎(𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 )𝑦𝑖 < 0] = ∑ [ ⏟
(𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 )𝑦𝑖 < 0] → 𝑚𝑖𝑛
𝐿 𝐿 ⃗⃗⃗⃗
𝜃𝑖
𝑖=1 𝑖=1 отступ объекта
𝐾
1
𝑄𝑣𝑎𝑙 (𝜃⃗) = ∑[(𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 )𝑦𝑖 < 0]
𝐾
𝑖=1
Идея: заменить пороговую функцию потерь непрерывной функцией
Отступ объекта (margin) 𝑀 = (𝑥⃗; 𝜃⃗)𝑦
𝐴∶ [𝑀 < 0] – пороговая
𝐵∶ (1 − 𝑀)+ – SVM
𝐶∶ 𝑒 −𝑀 – экспоненциальная
𝐷∶ (1 − 𝑀)2 – квадратичная
𝐸∶ 𝑙𝑜𝑔2 (1 + 𝑒 −𝑀 ) – логарифмическая
Рисунок 4.6 Графики функций потерь

Решение задачи линейной регрессии
𝐿 𝐿
1 1 2
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ∑ ℒ(𝑎(𝑥
⃗⃗⃗⃗,𝑖 𝜃⃗), ⃗⃗⃗⃗,
𝑥𝑖 𝑦𝑖 ) = ∑ ((𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 ) − 𝑦𝑖 ) → 𝑚𝑖𝑛
𝐿 𝐿 ⃗⃗⃗⃗
𝜃𝑖
𝑖=1 𝑖=1
Пусть 𝒳 = {𝑥⃗1 , 𝑥⃗2 , … , 𝑥⃗𝐿 } и 𝑦⃗ = {𝑦1 , 𝑦2 , … , 𝑦𝐿 }, тогда
1 2
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ‖𝒳𝜃⃗ − 𝑦⃗‖2 → 𝑚𝑖𝑛
𝐿 ⃗𝜃⃗
∇⃗𝜃⃗ 𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = 0 ⟹ 𝒳 𝑇 (𝒳𝜃⃗ − 𝑦⃗) = 0

Формальное решение 𝜃⃗0 = (𝒳 𝑇 𝒳)−1 𝒳 𝑇 𝑦⃗
Мультиколлинеарность — наличие линейной зависимости между
объясняющими переменными (факторами) регрессионной модели
48
𝒳 = {𝑥⃗1 , 𝑥⃗2 , … , 𝑥⃗𝐿 } и 𝑦⃗ = {𝑦1 , 𝑦2 , … , 𝑦𝐿 }

Столбцы матрицы 𝒳 линейно зависимы: ∃𝜃⃗1 ≠ ⃗0⃗: 𝒳𝜃⃗1 = ⃗0⃗
Найдено решение 𝜃⃗0 = (𝒳 𝑇 𝒳)−1 𝒳 𝑇 𝑦⃗
𝜃⃗ = 𝜃⃗0 + ξ𝜃⃗1 – тоже решение задачи при любом ξ
Регуляризация — метод добавления некоторых дополнительных ограничений к
условию с целью решить некорректно поставленную задачу или предотвратить
переобучение. Эта информация часто имеет вид штрафа за сложность модели. Например,
это могут быть ограничения гладкости результирующей функции или ограничения по
норме векторного пространства
Пусть одновременно 𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) → 𝑚𝑖𝑛 и ‖𝜃⃗‖ → 𝑚𝑖𝑛 𝑃 𝜃
⃗⃗
𝜃 ⃗⃗
1
Норма вектора 𝐿𝑃 : ‖𝑥⃗‖𝑃 = (∑|𝑥𝑖 |𝑃 ) . Часто применяются 𝐿1 и 𝐿2
𝑃
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) + 𝜆‖𝜃⃗ ‖ → 𝑚𝑖𝑛 𝑃 ⃗𝜃⃗

Примеры регуляризации
Регуляризация по Тихонову (ridge regression)
2
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) + 𝛼|𝜃⃗| → 𝑚𝑖𝑛
⃗𝜃⃗
𝜃⃗0 = (𝒳 𝑇
𝒳 + 𝜖𝐈) 𝒳 𝑇 𝑦⃗ −1
Регуляризация через манхэттенское расстояние (lasso regression, Least Absolute

Shrinkage and Selection Operator)
𝑛
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) + 𝛼 ∑|𝜃𝑗 | → 𝑚𝑖𝑛

⃗𝜃⃗
𝑗=1
Elasticnet regression
𝑛
2
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) + 𝛼 ∑|𝜃𝑗 | + 𝛽|𝜃⃗| → 𝑚𝑖𝑛
⃗⃗
𝜃
𝑗=1
Рисунок 4.7 Ridgeрегрессия (P = 2), отбор признаков не происходит
49
Рисунок 4.8 Отбор признаков при lassoрегрессии (P = 1)
Рисунок 4.9 Отбор признаков при P = 0.5
Рисунок 4.10 Регуляризация и отбор признаков

Вероятностный подход к задаче линейной регрессии и классификации
Модель: 𝑦⃗ = 𝒳𝜃⃗ + 𝜖⃗; 𝜖𝑗 ~𝒩(0, 𝜎 2 )
Предполагается, что неизвестные коэффициенты 𝜃⃗ = {𝜃1 , 𝜃2 , … , 𝜃𝑛 } распределены
нормально:
50
𝜆 𝜆2 2
𝑤(𝜃⃗) = 𝑛 exp (− |𝜃⃗| )
(2𝜋) 2 2
Метод максимального правдоподобия
𝐿 2
1 (𝑦𝑖 − ∑𝑛𝑗=1 𝒳𝑖𝑗 𝜃𝑗 )
⃗ ⃗ 2)
ln 𝐿(𝜃) = ln 𝑤(𝑦⃗|𝒳, 𝜃 ) = ∑ [− ln(2𝜋𝜎 − ]
2 2𝜎 2
𝑖=1
2
𝐿 𝑛
1
∑ (𝑦𝑖 − ∑ 𝒳𝑖𝑗 𝜃𝑗 ) → 𝑚𝑖𝑛
2𝜎 2
𝑖=1 𝑗=1
2
В матричной записи: 𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ‖𝒳𝜃⃗ − 𝑦⃗‖2 → 𝑚𝑖𝑛
Метод апостериорной плотности распределения
𝐿 𝐿 2
1 (𝑦𝑖 − ∑𝑛𝑗=1 𝒳𝑖𝑗 𝜃𝑗 ) 𝜆 𝜆2 2
ln 𝐿(𝜃⃗) + ln 𝑤(𝜃⃗ ) = − ∑ ln(2𝜋𝜎 2 ) − ∑ + ln − |𝜃⃗|
2 2𝜎 2 (2𝜋)𝑙⁄2 2
𝑖=1 𝑖=1
2
𝐿 𝑛
1 𝜆2 2
∑ (𝑦𝑖 − ∑ 𝒳 𝜃
𝑖𝑗 𝑗 ) + |𝜃⃗| → 𝑚𝑖𝑛
2𝜎 2 ⏟
2
⏟ 𝑖=1 𝑗=1
𝐿2 − регуляризация
Квадратичная ошибка
2 2
В матричной записи: 𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ‖𝒳𝜃⃗ − 𝑦⃗‖2 + (𝜎𝜆)2 ‖𝜃⃗‖2 → 𝑚𝑖𝑛
Если неизвестные коэффициенты 𝜃⃗ = {𝜃1 , 𝜃2 , … , 𝜃𝑛 } распределены согласно
распределению Лапласа:
𝛼
𝑤(𝜃⃗𝑖 ) = exp(−|𝜃𝑖 |)
2
2
𝐿 𝑛 𝑛
1
∑ (𝑦𝑖 − ∑ 𝒳𝑖𝑗 𝜃𝑗 ) + 𝜆 ∑|𝜃𝑖 | → 𝑚𝑖𝑛
2𝜎 2
⏟ 𝑖=1 𝑗=1 ⏟𝑗=1
Квадратичная ошибка 𝐿1 − регуляризация
2
В матричной записи: 𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ‖𝒳𝜃⃗ − 𝑦⃗‖2 + 𝜎 2 𝜆‖𝜃⃗‖1 → 𝑚𝑖𝑛
Эксперимент с монеткой: метод максимального правдоподобия
Необходимо оценить вероятность выпадения орла, имея данные эксперимента
𝑦⃗ = {𝑦1 , 𝑦2 , … , 𝑦𝑁 }
𝑝(𝑦𝑗 |𝑞) = 𝑞 𝑦𝑗 (1 − 𝑞)1−𝑦𝑗
𝑁 𝑁
1
ℒ𝑙𝑜𝑔 = − ln 𝐿 = − ∑ ln 𝑝(𝑦𝑗 |𝑞) = − ∑(𝑦𝑗 ln 𝑞 + (1 − 𝑦𝑗 ) ln(1 − 𝑞)) → 𝑚𝑖𝑛
𝑁
𝑗=1 ⏟ 𝑗=1
Логистическая функция потерь
51
𝑁
1
𝑞̂𝑚𝑙𝑒 = ∑ 𝑦𝑗
𝑁
𝑗=1
Перекрестная энтропия
Объект, обладающий признаками 𝑥⃗, относится к j-му классу с вероятностью
𝑝𝑗 ; 𝑗 = 1, 2, … , 𝑠.
Алгоритм на основе 𝑥⃗ определяет эту вероятность как 𝑞𝑗 . При 𝑁 ≫ 1
испытаниях j-й класс реализовался 𝑛𝑗 = 𝑁𝑝𝑗 раз.
𝑠
𝑁𝑝𝑗
𝐿(𝑞1 , 𝑞2 , … , 𝑞𝑠 ) = 𝑝(𝑛1 , 𝑛2 , … , 𝑛𝑠 |𝑞1 , 𝑞2 , … , 𝑞𝑠 ) = ∏ 𝑞𝑗
𝑗=1
𝑠
1
− ln 𝐿(𝑞1 , 𝑞2 , … , 𝑞𝑠 ) = − ∑ 𝑝𝑗 ln 𝑞𝑗 = 𝐻(𝑝, 𝑞) → 𝑚𝑖𝑛
𝑁
𝑗=1
Перекрестная энтропия (cross entropy) — функция между двумя
распределениями вероятностей 𝐻(𝑝, 𝑞) = − ∑ 𝑝𝑗 ln 𝑞𝑗 .
Минимум перекрестной энтропии
𝐻(𝑝, 𝑞) = − ∑ 𝑝𝑗 ln 𝑞𝑗
𝜕𝐻
= 0; ∑ 𝑞𝑗 = 1
𝜕𝑞𝑗
𝜉 = − ∑ 𝑝𝑗 ln 𝑞𝑗 + 𝜆 (1 − ∑ 𝑞𝑗 )
𝜕𝜉 𝑝𝑗 𝑝𝑗
= 0; − − 𝜆 = 0; 𝑞𝑗 = −
𝜕𝑞𝑗 𝑞𝑗 𝜆
∑ 𝑞𝑗 = − ∑ 𝑝𝑗 ⁄𝜆 = −1⁄𝜆 ; 𝜆 = −1
𝑝𝑗 = 𝑞𝑗
Объект определенного класса
𝑠
ℒ = − ∑ 𝑝𝑗 ln 𝑞𝑗
𝑗=1
Если точно известно, что объект принадлежит классу t, то
𝑝𝑗 = 𝛿(𝑗, 𝑡) и ℒ = − ln 𝑞𝑡
Бинарная классификация
Логистическая функция потерь: ℒ = −𝑦 ln 𝑞 − (1 − 𝑦) ln(1 − 𝑞)
Модель вероятности:
1 1
𝑞 = 𝑠𝑖𝑔𝑚𝑜𝑖𝑑(𝑥⃗; 𝜃⃗ ) ≡ ⃗⃗
и 1 − 𝑞 = ⃗⃗
1 + 𝑒 −(𝑥⃗;𝜃) 1 + 𝑒 (𝑥⃗;𝜃)
Вместо класса 𝑦 ∈ {0; 1} удобно взять 𝑧 = (2𝑦 − 1) ∈ {−1; 1}
52
1+𝑧 ⃗⃗ 1−𝑧 ⃗⃗ ⃗⃗
ℒ= ln (1 + 𝑒 −(𝑥⃗;𝜃) ) + ln (1 + 𝑒 (𝑥⃗;𝜃) ) = ln (1 + 𝑒 −𝑧∙(𝑥⃗;𝜃) )
2 2
Логарифмическая функция потерь: ℒ = 𝑙𝑜𝑔2 (1 + 𝑒 −𝑀 )
Рисунок 4.11 К выводу логарифмической функции потерь

Многоклассовая классификация:
exp(𝑥⃗𝜃𝑗 )
𝑞𝑗 = softmax(𝑥⃗𝜃𝑗 ) ≡
∑𝑠𝑖=1 exp(𝑥⃗𝜃𝑗 )
53
Лекция 5. Метрические методы регрессии и классификации

Разбор теории предыдущих лекций на практике
Адрес ноутбука с материалами, показанными в лекции:
https://colab.research.google.com/drive/1_u8-gkyx1THBp8Oe9pI7vpWCTGGu6rgM
0. Формируем данные
Импорт библиотек
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams.update({'font.size': 12})
Класс Problem позволяет сгенерировать обучающую и тестовую выборки для
заданной функции, а затем осуществлять проверку результата
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
class Problem():
X_train = []
X_test = []
y_train = []
_y_test = []
def __init__(self, func: callable, sigma: float=1, size: int

=100):
# Инициализация генератора случайных чисел
np.random.seed(10)
self.x = np.arange(0, 10, 10/size)

self.y = func(self.x) + sigma*np.random.randn(size)
def get_data(self, test_size: float=0.3, random_state: int=0

) -> tuple:
self.X_train, self.X_test, self.y_train, self._y_test = tr
ain_test_split(self.x, self.y, test_size=test_size, random_sta
te=random_state)
return self.X_train, self.X_test, self.y_train
def get_mse(self, prediction: list) -> float:

return mean_squared_error(self._y_test, prediction)
def plot(self) -> None:

plt.figure(figsize=[20,5])
plt.plot(self.X_train, self.y_train, 'o')
plt.plot(self.X_test, self._y_test, 'ro')
54
# Создаем задачу для некоторой функции

p1 = Problem(lambda x: 1-2*x+0.5*x**2-0.08*x**3, sigma=0.5)
# Получаем данные задачи

X, X_test, y = p1.get_data()
# Отображаем данные графически

p1.plot()
Нужно научиться определять качество модели по обучающим данным, поэтому

их надо разделить на тренировочную и валидационную выборку
X_train, X_valid, y_train, y_valid = train_test_split(X, y, te
st_size=0.3, random_state=10)
1. Решаем задачу №1 на обучающих данных
Будем решать задачу с помощью линейной регрессии, приближая функцию
полиномом степени N
from sklearn.linear_model import LinearRegression, Ridge
def polynom_solution(X_train: list, X_valid: list, y_train: li

st, y_valid: list, N: int= 2, plot: bool=True, alpha: float=0.
0) -> tuple:
# Формируем матрицы признаков для тренировочной и валидацион
ной выборок
# Для этого дополняем массивы x их степенями от 1 до N включ
ительно
X_train_poly = np.stack([X_train**n for n in range(1,N+1)])
.T
X_valid_poly = np.stack([X_valid**n for n in range(1,N+1)])
.T
# Строим линейную регрессию полученных признаков на результа

т
# fit_intercept=True (по умолчанию) добавляет в регрессию св
ободный член
# alpha - регуляризация (по умолчанию нет)
if alpha == 0:
55
reg = LinearRegression(fit_intercept=True).fit(X_train_pol
y, y_train)
else:
reg = Ridge(alpha=alpha, fit_intercept=True).fit(X_train_p
oly, y_train)
# Если указано, что нужно построить графики

if plot:
# Отобразим исходные данные на графике
plt.plot(X_train, y_train, 'bo')
plt.plot(X_valid, y_valid, 'ro')
# Отобразим результат линейной регрессии на графике

x_predictions = np.arange(0,10,0.01)
x_predictions_poly = np.stack([x_predictions**n for n in r
ange(1,N+1)]).T
y_predictions = reg.predict(x_predictions_poly)
plt.plot(x_predictions, y_predictions, 'k')
plt.ylim(-2*max(abs(y_train)), 2*max(abs(y_train)))
plt.show()
# Посчитаем среднеквадратичные ошибки для тренировочных и ва

лидационных данных
mse_train = mean_squared_error(y_train, reg.predict(X_train_
poly))
mse_valid = mean_squared_error(y_valid, reg.predict(X_valid_
poly))
return mse_train, mse_valid, reg
mse_train, mse_valid, _ = polynom_solution(X_train, X_valid, y

_train, y_valid, N=1)
print("Ошибка на тренировке = %.3f\t Ошибка на валидации = %.3
f" % (mse_train, mse_valid))
56
Попробуем изменять сложность модели (степень полинома) и отобразим ошибки

на графике
mses_train=[]
mses_valid=[]
regs = []
Ns = range(1, 50)
for N in Ns:
mse_train, mse_valid, reg = polynom_solution(X_train, X_vali
d, y_train, y_valid, N=N, plot=False)
print("N=%i;\t Ошибка на тренировке = %.3f\t Ошибка на валид
ации = %.3f" % (N, mse_train, mse_valid))
mses_train.append(mse_train)
mses_valid.append(mse_valid)
regs.append(reg)
…….
# Отобразим график
plt.plot(Ns, mses_train, 'b', label='Тренировка')
plt.plot(Ns, mses_valid, 'r', label='Валидация')
plt.legend()
plt.show()
# Наилучшие результаты по валидации

ind = np.argmin(mses_valid)
reg = regs[ind]
print("Лучший результат на валидации при N=%i;\t Ошибка на тре

нировке = %.3f\t Ошибка на валидации = %.3f\t Коэффициенты = [
%.2f; %s]" %
(Ns[ind], mses_train[ind], mses_valid[ind], reg.intercep
t_, '; '.join(["%.2f" % c for c in reg.coef_])))
57
# p1 = Problem(lambda x: 1-2*x+0.5*x**2-0.08*x**3, sigma=0.5)
Теперь узнаем, насколько хорошо мы решили задачу на тестовых данных

X_test_poly = np.stack([X_test**n for n in range(1,Ns[ind]+1)
]).T
print("Ошибка на тесте = %.3f" % p1.get_mse(reg.predict(X_test
_poly)))
Ошибка на тесте = 0.276
2. Решаем задачу №2 на обучающих данных (меньше шума)
p2 = Problem(lambda x: 1-2*x+0.5*x**2-0.08*x**3, sigma=0.05)


mses_train=[]
mses_valid=[]
regs = []
Ns = range(1, 50)
for N in Ns:
regs.append(reg)
plt.legend()
plt.show()
58

reg = regs[ind]

%.2f; %s]" %
X_test_poly = np.stack([X_test**n for n in range(1, Ns[ind]+1

)]).T
_poly)))
#p2 = Problem(lambda x: 1-2*x+0.5*x**2-0.08*x**3, sigma=0.05)
3. Решаем задачу №3 на обучающих данных (больше шума)

p3 = Problem(lambda x: 1-2*x+0.5*x**2-0.08*x**3, sigma=5)


mses_train=[]
mses_valid=[]
regs = []
Ns = range(1, 50)
for N in Ns:
59
regs.append(reg)
plt.legend()
plt.show()

reg = regs[ind]

%.2f; %s]" %
X_test_poly = np.stack([X_test**n for n in range(1, Ns[ind]+1

)]).T
_poly)))
# p3 = Problem(lambda x: 1-2*x+0.5*x**2-0.08*x**3, sigma=5)
4. Решаем задачу №3 на обучающих данных с применением регуляризации

Коэффициент регуляризации α - гиперпараметр
mses_train=[]
mses_valid=[]
regs = []
na = []
Ns = range(1, 8)
alphas = np.arange(0.1, 3.0, 0.1)
for N in Ns:
60
for alpha in alphas:

mse_train, mse_valid, reg = polynom_solution(X_train, X_va
lid, y_train, y_valid, N=N, plot=False, alpha=alpha)
na.append((N, alpha))
regs.append(reg)

reg = regs[ind]
N_best, alpha_best = na[ind]
print("Лучший результат на валидации при N=%i;\talpha=%.1f;\t

Ошибка на тренировке = %.3f\t Ошибка на валидации = %.3f\t Коэ
ффициенты = [%.2f; %s]" %
(N_best, alpha_best, mses_train[ind], mses_valid[ind], r
eg.intercept_, '; '.join(["%.2f" % c for c in reg.coef_])))
X_test_poly = np.stack([X_test**n for n in range(1, N_best+1)

]).T
_poly)))

Лучший результат на валидации при N=3; alpha=2.9;
Ошибка на тренировке = 21.633
Ошибка на валидации = 25.288
Коэффициенты = [2.85; -2.28; 0.43; -0.07]
Изменим разбиение на тренировочную и валидационную выборки
(random_state=5 вместо random_state=10)
mses_train=[]
mses_valid=[]
regs = []
na = []
Ns = range(1, 8)
for N in Ns:
61
mse_train, mse_valid, reg = polynom_solution(X_train, X_va

lid, y_train, y_valid, N=N, plot=False, alpha=alpha)
regs.append(reg)

reg = regs[ind]


]).T
_poly)))

Коэффициенты = [-1.50; 2.12; -0.63]
5. Решаем задачу №3 с применением K-fold кросс-валидации
from sklearn.model_selection import KFold
# Разбиваем обучающую выборку на наборы данных

kf = KFold(n_splits=5)
# Осуществляем поиск наилучших гиперпараметров

mses_train=[]
mses_valid=[]
na = []
Ns = range(1, 8)
for N in Ns:
62
# Вместо единственного делаем разные разбиения

local_mses_train=[]
local_mses_valid=[]
for train_ind, val_ind in kf.split(X):
# Для каждого разбиения выбираем данные, обучаемся и опр
еделяем ошибки
local_mse_train, local_mse_valid, _ = polynom_solution(X
[train_ind], X[val_ind], y[train_ind], y[val_ind], N=N, plot=F
alse, alpha=alpha)
local_mses_train.append(local_mse_train)
local_mses_valid.append(local_mse_valid)
# print("\tN=%i; alpha=%.1f;\t Ошибка на тренировке = %.

3f\t Ошибка на валидации = %.3f" % (N, alpha, local_mse_train,
local_mse_valid))
# Теперь усредняем полученные ошибки

mse_train = np.mean(local_mses_train)
mse_valid = np.mean(local_mses_valid)
# print("N=%i; alpha=%.1f;\t Ошибка на тренировке = %.3f\t

Ошибка на валидации = %.3f" % (N, alpha, mse_train, mse_valid
))

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

_, _, reg = polynom_solution(X, X_valid, y, y_valid, N=N_best,
plot=False, alpha=alpha_best)

63


]).T
_poly)))

Коэффициенты = [2.90; -2.38; 0.49; -0.08]
6. Решаем задачу №3 с применением LOO кросс-валидации
from sklearn.model_selection import LeaveOneOut
# Разбиваем обучающую выборку на наборы данных

loo = LeaveOneOut()
# Осуществляем поиск наилучших гиперпараметров

mses_train=[]
mses_valid=[]
na = []
Ns = range(1, 8)
for N in Ns:
# Вместо единственного делаем разные разбиения

local_mses_train=[]
local_mses_valid=[]
for train_ind, val_ind in loo.split(X):
# Для каждого разбиения выбираем данные, обучаемся и опр
еделяем ошибки
local_mse_train, local_mse_valid, _ = polynom_solution(X
[train_ind], X[val_ind], y[train_ind], y[val_ind], N=N, plot=F
alse, alpha=alpha)
local_mses_train.append(local_mse_train)
local_mses_valid.append(local_mse_valid)
64
# print("\tN=%i; alpha=%.1f;\t Ошибка на тренировке = %.

3f\t Ошибка на валидации = %.3f" % (N, alpha, local_mse_train,
local_mse_valid))
# Теперь усредняем полученные ошибки

mse_train = np.mean(local_mses_train)
mse_valid = np.mean(local_mses_valid)
# print("N=%i; alpha=%.1f;\t Ошибка на тренировке = %.3f\t

Ошибка на валидации = %.3f" % (N, alpha, mse_train, mse_valid
))

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

_, _, reg = polynom_solution(X, X_valid, y, y_valid, N=N_best,
plot=False, alpha=alpha_best)


]).T
_poly)))

Коэффициенты = [1.87; -1.37; 0.26; -0.06]
7. Регуляризация и отбор признаков
65
from sklearn.linear_model import LinearRegression, Ridge, Lass

o
import warnings
warnings.filterwarnings("ignore")
mses_train=[]
mses_valid=[]
regs = []
na = []
N = 10
ridge_coeff = []
lasso_coeff = []
X_poly = np.stack([X**n for n in range(1,N+1)]).T
#reg = LinearRegression(fit_intercept=True).fit(X_poly, y)

reg = Ridge(alpha=alpha, fit_intercept=True).fit(X_poly, y)
ridge_coeff.append([reg.intercept_, *reg.coef_])
reg = Lasso(alpha=alpha, fit_intercept=True).fit(X_poly, y)

lasso_coeff.append([reg.intercept_, *reg.coef_])
ridge_coeff = np.array(ridge_coeff)
lasso_coeff = np.array(lasso_coeff)
fig, axs = plt.subplots(nrows=2, ncols=2)

axs[0,0].set_title("Ridge-регрессия")
axs[0,1].set_title("Lasso-регрессия")
for n in range(2):
axs[0,n].set_xlabel(r"$\alpha$")
axs[0,n].set_ylabel(r"$A_n$")
axs[1,n].set_xlabel(r"$\alpha$")
axs[1,n].set_ylabel(r"Число ненулевых $A_n$")
for n in range(N+1):
axs[0,0].plot(alphas, ridge_coeff[:, n], label='n=%i' %n)
axs[0,1].plot(alphas, lasso_coeff[:, n], label='n=%i' %n)
66
axs[1,0].plot(alphas, np.sum(abs(ridge_coeff)>1e-
5, axis=1), label='n=%i' %n)
axs[1,1].plot(alphas, np.sum(abs(lasso_coeff)>1e-
5, axis=1), label='n=%i' %n)
axs[0,0].legend(loc='upper right')
axs[0,1].legend(loc='upper right')
plt.rcParams.update({'font.size': 18})
plt.show()
Схема постановки и решения задач обучения с учителем. Примеры

• Параметры модели 𝜃⃗ оптимизируются для достижения минимума
67
Примеры задач
• Сравнение последовательностей символов (текст, ДНК и т.д.)
• Сравнение объектов по фотографиям
• Выделение групп людей на основе графа связей в социальных сетях
• Распознавание рукописного текста с помощью анализа траектории пера
Расстояния между объектами. Классификация объектов по соседям
Расстояние между объектами
Для объектов 𝑥⃗𝑗 ∈ 𝕏 вводится функция расстояния 𝜌(𝑥⃗1 , 𝑥⃗2 ) ≥ 0.
Выполнение неравенства треугольника 𝜌(𝑥⃗1 , 𝑥⃗2 ) + 𝜌(𝑥⃗2 , 𝑥⃗3 ) ≥ 𝜌(𝑥⃗1 , 𝑥⃗3 ) не
обязательно.
Гипотеза: если расстояние между объектами мало, то
• в задачах классификации близкие объекты относятся к одному классу;
• в задачах регрессии значения целевого признака у этих объектов близки.
1 случай
По условию задачи известны расстояния между всеми объектами 𝜌(𝑥⃗𝑖 , 𝑥⃗𝑗 ).
2 случай
По условию задачи объекты заданы своими признаками 𝑥⃗.
Тогда расстояние определяется согласно обобщенной метрике Минковского:
𝑛 1⁄𝑃
𝑃
𝜌𝑃 (𝑥⃗𝑖 , 𝑥⃗𝑗 , 𝜃⃗) = (∑ 𝜃𝑘 |𝑥𝑖,𝑘 − 𝑥𝑗,𝑘 | )
𝑘=1
Классификация объектов по соседям
1. Для выбранного 𝑥⃗ расстояния сортируются
по возрастанию: 𝜌(𝑥⃗, 𝑥⃗𝑖 ) ≤ 𝜌(𝑥⃗, 𝑥⃗𝑖+1 )
2. Определяется “близость” 𝜚(𝑥⃗, 𝑦) объекта 𝑥⃗ к
классу 𝑦 Рисунок 5.1 Классификация
3. 𝑎(𝑥⃗) = arg max 𝜚(𝑥⃗, 𝑦) объектов по соседям
𝑦
Метод k ближайших соседей (kNN)
1. Для выбранного 𝑥⃗ расстояния сортируются по возрастанию: 𝜌(𝑥⃗, 𝑥⃗𝑖 ) ≤
𝜌(𝑥⃗, 𝑥⃗𝑖+1 )
2. Близость объекта 𝑥⃗ к классу 𝑦 : 𝜚(𝑥⃗, 𝑦) = ∑𝑘𝑖=1[𝑦𝑖 = 𝑦]
3. 𝑎(𝑥⃗) = arg max 𝜚(𝑥⃗, 𝑦)
𝑦
Преимущества:
• Не нужно обучать (lazylearning)
Недостатки:
• Не учитываются расстояния
• Возможно неоднозначное определение класса
68
Рисунок 5.2 kNN(k = 1)
Рисунок 5.3 kNN(k = 20): с ростом k границы сглаживаются
Рисунок 5.4 kNN(k = 110): с ростом k форма границ приближается к прямой
Рисунок 5.5 Линейный классификатор

Метод k ближайших соседей с весами
69
1. Для выбранного 𝑥⃗ расстояния сортируются по возрастанию: 𝜌(𝑥⃗, 𝑥⃗𝑖 ) ≤

𝜌(𝑥⃗, 𝑥⃗𝑖+1 )
2. Близость объекта 𝑥⃗ к классу 𝑦:
𝑘 𝑘
𝑘+1−𝑖
𝜚𝑙𝑖𝑛𝑒𝑎𝑟 (𝑥⃗, 𝑦) = ∑[𝑦𝑖 = 𝑦] или 𝜚𝑒𝑥𝑝 (𝑥⃗, 𝑦) = ∑[𝑦𝑖 = 𝑦]𝛼 𝑖
𝑘
𝑖=1 𝑖=1
𝑦
Недостатки:
Веса зависят от номера, но не от расстояний 𝜌(𝑥⃗, 𝑥⃗𝑖 )
Возможно неоднозначное определение класса для 𝜚𝑙𝑖𝑛𝑒𝑎𝑟
Метод парзеновского окна. Сравнение с линейным классификатором
1. Вводится функция-ядро 𝐾(𝜌), которая
• положительна на [0;1]
• не возрастает на [0;1]
2. Близость объекта 𝑥⃗ к классу 𝑦:
𝐿
𝜌(𝑥⃗, 𝑥⃗𝑖 )
𝜚𝑓𝑖𝑥 (𝑥⃗, 𝑦, ℎ) = ∑[𝑦𝑖 = 𝑦] 𝐾 ( ) или
ℎ
𝑖=1
𝐿
𝜌(𝑥⃗, 𝑥⃗𝑖 )
𝜚𝑣𝑎𝑟 (𝑥⃗, 𝑦, 𝑘) = ∑[𝑦𝑖 = 𝑦] 𝐾 ( )
𝜌(𝑥⃗, 𝑥⃗𝑘+1 )
𝑖=1
𝑦
Обобщение – метод потенциальных функций
𝐿
𝜌(𝑥⃗, 𝑥⃗𝑖 )
𝜚𝑝𝑜𝑡 (𝑥⃗, 𝑦) = ∑[𝑦𝑖 = 𝑦] ∙⏟
𝐴𝑖 ∙ 𝐾( )
ℎ⏟𝑖
𝑖=1 Амплитуда i−го объекта
“Радиус действия” i−го объекта
Сравнение с линейным классификатором
Алгоритм классификации методом потенциальных функций
𝐿
𝜌(𝑥⃗, 𝑥⃗𝑖 )
⃗⃗) = arg max ∑[𝑦𝑖 = 𝑦] 𝐴𝑖 𝐾 (
𝑎(𝑥⃗, 𝐴⃗, ℎ )
𝑦 ℎ𝑖
𝑖=1
Алгоритм для линейного классификатора
𝑛
𝑎(𝑥⃗, 𝜽) = arg max ∑ 𝜃𝑦,𝑖 𝑓𝑖 (𝑥⃗)

𝑦
𝑖=1
Две задачи эквивалентны при
𝜌(𝑥⃗, 𝑥⃗𝑖 )
𝑓𝑖 (𝑥⃗) = 𝐾 ( );
ℎ𝑖
𝜃𝑦,𝑖 = 𝐴𝑖 [𝑦𝑖 = 𝑦];
{ 𝑛 = 𝐿.
70
Задача регрессии. Формула Надарая-Уотсона. Примеры ядер

▪ Если расстояние между объектами мало, то значения их целевого признака
близки
▪ Для вычисления значения функции следует использовать средневзвешенные
значения на обучающей выборке 𝑥⃗𝑖 ∈ 𝕏𝑡𝑟𝑎𝑖𝑛 :
∑𝐿𝑖=1 𝑤𝑖 𝑦𝑖 𝜌(𝑥⃗, 𝑥⃗𝑖 )
𝑎(𝑥⃗) = 𝐿 , где веса 𝑤𝑖 = 𝐾 ( )
∑𝑖=1 𝑤𝑖 ℎ𝑖
𝐾𝑟𝑒𝑐𝑡 (𝜌) = [𝜌 < 1]
𝐾𝑡𝑟𝑖 (𝜌) = max(0, 1 − 𝜌)
2
𝐾𝑔𝑎𝑢𝑠𝑠 (𝜌) = 𝑒 −2𝜌
𝐾𝑞𝑢𝑎𝑟𝑡 (𝜌) = (1 − ρ2 )2 · [ρ < 1]
71
72
Лекция 6. Метод опорных векторов

Задача линейной бинарной классификации
⃗⃗⃗⃗𝑖 ∈ ℛ 𝑛 ; 𝑦𝑖 ∈ {−1; 1}
𝑥
Выбирается линейная модель: 𝑎(𝑥⃗, 𝜃⃗) = 𝑠𝑔𝑛(𝑥⃗; 𝜃⃗) = 𝑠𝑔𝑛 ∑𝑛𝑗=1 𝑥𝑗 𝜃𝑗
𝐿 𝐿
1 1
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ∑[𝑎(𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 )𝑦𝑖 < 0] = ∑ [ (𝑥
⏟⃗⃗⃗⃗; ⃗
𝑖 𝜃 )𝑦𝑖 < 0] → 𝑚𝑖𝑛
𝐿 𝐿 ⃗⃗⃗⃗
𝜃𝑖
𝑖=1 𝑖=1 отступ объекта
𝐾
1
𝑄𝑣𝑎𝑙 (𝜃⃗) = ∑[(𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 )𝑦𝑖 < 0]
𝐾
𝑖=1
Свободный член учитывается отдельно
⃗⃗⃗⃗𝑖 ∈ ℛ 𝑛 ; 𝑦𝑖 ∈ {−1; 1}
𝑥
Выбирается линейная модель: 𝑎(𝑥⃗, 𝜃⃗) = 𝑠𝑔𝑛 ((𝑥⃗; 𝜃⃗ ) − 𝜃0 )
𝐿
1
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗, 𝜃0 ) = ∑ [((𝑥
⏟ ⃗⃗⃗⃗;
⃗
𝑖 𝜃 ) − 𝜃0 ) 𝑦𝑖 < 0] → 𝑚𝑖𝑛
𝐿 ⃗𝜃⃗,𝜃0
𝑖=1 отступ объекта
𝐾
1
𝑄𝑣𝑎𝑙 (𝜃⃗, 𝜃0 ) = ∑ [((𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 ) − 𝜃0 ) 𝑦𝑖 < 0]
𝐾
𝑖=1
Как разделить выборку на классы “наилучшим” образом?
Рисунок 6.1 Существует неоднозначность построения гиперплоскости

Случай линейно разделимой выборки
Идея: провести гиперплоскость так, чтобы расстояния от нее до ближайших
объектов каждого класса были максимальны.
73
Рисунок 6.2 Случай линейно разделимой выборки
Для каждого объекта вычисляется его отступ 𝑀𝑖 = ((𝑥

⃗⃗⃗⃗; ⃗
𝑖 𝜃 ) − 𝜃0 ) 𝑦𝑖
Если выборка линейно разделима, то все объекты классифицируются правильно

min 𝑀𝑖 = 𝑚 > 0
Для объектов 𝑥⃗+1 и 𝑥⃗−1, лежащих на границах полосы, выполнено
(𝑥⃗+1 ; 𝜃⃗) − 𝜃0 = 𝑚, (𝑥⃗−1 ; 𝜃⃗ ) − 𝜃0 = −𝑚
Тогда ширина полосы равна
(𝜃⃗(𝑥⃗+1 − 𝑥⃗−1 )) 2𝑚 ‖𝜃⃗‖ → min
𝑆= = → max ⟹ {
‖𝜃⃗‖ ‖𝜃⃗‖ min 𝑀𝑖 = 1
Метод опорных векторов
Для линейно разделимой выборки:
‖𝜃⃗‖ → min ‖𝜃⃗ ‖ → min
{ ⟹{
min 𝑀𝑖 = 1 𝑀𝑖 ≥ 1
Для линейно неразделимой выборки вводятся параметры 𝜖𝑖 :
2 𝐿
1 2 𝐿
‖𝜃⃗‖ + 𝐶 ∑ 𝜖𝑖 → min; 1
⃗
2 ‖𝜃‖ + 𝐶 ∑ 𝜖𝑖 → min;
𝑖=1 ⟹{ 2
𝑖=1
𝑀𝑖 ≥ 1 − 𝜖𝑖 ;
𝜖𝑖 ≥ max(0; 1 − 𝑀𝑖 ) = [1 − 𝑀𝑖 ]+
{ 𝜖𝑖 ≥ 0
2 𝐿
1
‖𝜃⃗‖ + 𝐶 ∑[1 − 𝑀𝑖 ]+ → min
2 ⃗⃗,𝜃0
𝜃
𝑖=1
Сравнение методов
• Пороговая классификация
𝐿
1
∑[𝑀𝑖 < 0] → 𝑚𝑖𝑛
𝐿 ⃗𝜃⃗
𝑖=1
• Логистическая регрессия
Рисунок 6.3 Сравнение методов
74
𝐿
1
∑ log 2 (1 + 𝑒 −𝑀𝑖 ) → 𝑚𝑖𝑛
𝐿 ⃗𝜃⃗
𝑖=1
• Метод опорных векторов

𝐿
1
∑[1 − 𝑀𝑖 ]+ → 𝑚𝑖𝑛
𝐿 ⃗⃗,𝜃0
𝜃
𝑖=1
Условия Каруша-Куна-Таккера
Задача условной минимизации
𝑓(𝑥) → min;
{𝑔𝑖 (𝑥) ≤ 0, 𝑖 = 1,2, … , 𝑚;
ℎ𝑗 (𝑥) = 0, 𝑗 = 1,2, … , 𝑘.
Вводится функция Лагранжа
𝑚 𝑘
𝐿(𝑥, 𝜇⃗, 𝜆⃗) = 𝑓(𝑥) + ∑ 𝜇𝑖 𝑔𝑖 (𝑥) + ∑ 𝜆𝑗 ℎ𝑗 (𝑥)

𝑖=1 𝑗=1
Если x – локальный минимум, то
𝜕𝐿
= 0;
𝜕𝑥
∃𝜇𝑖 , 𝜆𝑗 : 𝑔𝑖 (𝑥) ≤ 0; ℎ𝑗 (𝑥) = 0, – исходные ограничения
𝜇𝑖 ≥ 0; – двойственные ограничения
{𝜇𝑖 𝑔𝑖 (𝑥) = 0. – условия дополняющей нежесткости
Применение условий Каруша-Куна-Таккера
Исходная задача минимизации
2 𝐿
1 2 𝐿
⃗
‖𝜃‖ + 𝐶 ∑ 𝜖𝑖 → min; 1
2 ⃗
‖𝜃‖ + 𝐶 ∑ 𝜖𝑖 → min;
𝑖=1 ⟹ 2 𝑖=1
𝑀𝑖 = ((𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 ) − 𝜃0 ) 𝑦𝑖 ≥ 1 − 𝜖𝑖 ; 1 − 𝜖𝑖 − 𝑀𝑖 ≤ 0;
{ 𝜖𝑖 ≥ 0 { −𝜖𝑖 ≤ 0
Функция Лагранжа
2 𝐿 𝐿 𝐿
1
⃗ ⃗ ⃗
𝐿(𝜃, 𝜃0 , 𝜖⃗, 𝜇⃗, 𝜆) = ‖𝜃‖ + 𝐶 ∑ 𝜖𝑖 + ∑ 𝜇𝑖 (1 − 𝜖𝑖 − 𝑀𝑖 ) − ∑ 𝜈𝑖 𝜖𝑖
2
𝑖=1 𝑖=1 𝑖=1
2 𝐿 𝐿
1
= ‖𝜃⃗‖ − ∑ 𝜇𝑖 ((𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 )𝑦𝑖 − 𝜃0 𝑦𝑖 − 1) − ∑ 𝜖𝑖 (𝜇𝑖 + 𝜈𝑖 − 𝐶)
2
𝑖=1 𝑖=1
75
𝐿
𝜕𝐿
= 0; ⟹ 𝜃⃗ = ∑ 𝜇𝑖 𝑦𝑖 𝑥⃗𝑖
𝜕𝜃⃗ 𝑖=1
𝐿
𝜕𝐿
= 0; ⟹ ∑ 𝜇𝑖 𝑦𝑖 = 0;
𝜕𝜃⃗0 𝑖=1
𝜕𝐿
= 0; ⟹ 𝜇𝑖 + 𝜈𝑖 = 𝐶
𝜕𝜖⃗
𝜖𝑖 ≥ 0; 𝜇𝑖 ≥ 0; 𝜈𝑖 ≥ 0;
𝜇𝑖 (1 − 𝜖𝑖 − 𝑀𝑖 ) = 0;
{ 𝜈𝑖 𝜖𝑖 = 0.
Опорные и не опорные объекты. Двойственная задача, её решение
𝐿
𝜃⃗ = ∑ 𝜇𝑖 𝑦𝑖 𝑥⃗𝑖
𝑖=1
𝐿
∑ 𝜇𝑖 𝑦𝑖 = 0;
𝑖=1
𝜇𝑖 + 𝜈𝑖 = 𝐶;
𝜖𝑖 ≥ 0; 𝜇𝑖 ≥ 0; 𝜈𝑖 ≥ 0;
𝜇𝑖 (1 − 𝜖𝑖 − 𝑀𝑖 ) = 0;
{ 𝜈𝑖 𝜖𝑖 = 0.
• Если 𝜇𝑖 = 0, то
𝜈𝑖 = 𝐶;
𝜖𝑖 = 0;
{ 𝑀𝑖 ≥ 1;
𝜃⃗ не зависит от 𝑖 − го объекта
Это не опорный объект, лежащий в глубине своего класса
• Если 0 < 𝜇𝑖 < 𝐶, то
𝜈𝑖 = 𝐶 − 𝜇𝑖 > 0;
𝜖𝑖 = 0;
{ 𝑀𝑖 = 1;
𝜃⃗ зависит от 𝑖 − го объекта
Это опорный граничный объект
• Если 𝜇𝑖 = 𝐶, то
𝜈𝑖 = 0;
𝜖𝑖 > 0;
{ 𝑀𝑖 = 1 − 𝜖𝑖 ;
𝜃⃗ зависит от 𝑖 − го объекта
Это опорный объект, лежащий в глубине чужого класса или внутри разделяющей
полосы.
76
2 𝐿 𝐿
1
𝐿(𝜃⃗, 𝜃0 , 𝜖⃗, 𝜇⃗, 𝜆⃗) = ‖𝜃⃗‖ − ∑ 𝜇𝑖 ((𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 )𝑦𝑖 − 𝜃0 𝑦𝑖 − 1) − ∑ 𝜖𝑖 (𝜇𝑖 + 𝜈𝑖 − 𝐶)
2
𝑖=1 𝑖=1
𝐿 𝐿
𝜃⃗ = ∑ 𝜇𝑖 𝑦𝑖 𝑥⃗𝑖 ; ∑ 𝜇𝑖 𝑦𝑖 = 0; 𝜇𝑖 + 𝜈𝑖 = 𝐶;
{
𝑖=1 𝑖=1
𝜖𝑖 ≥ 0; 𝜇𝑖 ≥ 0; 𝜈𝑖 ≥ 0; 𝜇𝑖 (1 − 𝜖𝑖 − 𝑀𝑖 ) = 0; 𝜈𝑖 𝜖𝑖 = 0.
𝐿 𝐿
1
−𝐿(𝜇⃗) = ∑ 𝜇𝑖 𝜇𝑗 𝑦𝑖 𝑦𝑗 (𝑥⃗𝑖 ; 𝑥⃗𝑗 ) − ∑ 𝜇𝑖 → min
2
𝑖,𝑗=1 𝑖=1
𝐿
∑ 𝜇𝑖 𝑦𝑖 = 0;
𝑖=1
{ 0 ≤ 𝜇𝑖 ≤ 𝐶
Решение задачи методом опорных векторов
1. Постановка двойственной задачи относительно 𝜇⃗
𝐿 𝐿
1
−𝐿(𝜇⃗) = ∑ 𝜇𝑖 𝜇𝑗 𝑦𝑖 𝑦𝑗 (𝑥⃗𝑖 ; 𝑥⃗𝑗 ) − ∑ 𝜇𝑖 → min
2
𝑖,𝑗=1 𝑖=1
𝐿
∑ 𝜇𝑖 𝑦𝑖 = 0; − 𝜇⃗ лежит на 𝐿 − мерной гиперплоскости;

𝑖=1
{0 ≤ 𝜇𝑖 ≤ 𝐶; − 𝜇⃗ лежит на 𝐿 − мерном кубе со стороной 𝐶.
2. Двойственная задача – поиск минимума квадратичной формы на выпуклом
множестве – имеет единственное решение и для этого существуют эффективные
численные алгоритмы.
3. Переход к решению исходной задачи
𝐿 𝐿
𝜃⃗ = ∑ 𝜇𝑖 𝑦𝑖 𝑥⃗𝑖 ; ⟹ 𝑎(𝑥⃗) = sgn (∑ 𝜇𝑖 𝑦𝑖 (𝑥⃗𝑖 ; 𝑥⃗𝑗 ) − 𝜃0 )

𝑖=1 𝑖=1
{𝜃0 = (𝜃⃗; 𝑥⃗𝑏 ) − 𝑦𝑏 ; 𝑥⃗𝑏 – граничный опорный объект, т. е. 0 < 𝜇𝑏 < 𝐶.

Kernel trick. Часто используемые ядра
Двойственная задача содержит лишь скалярные произведения (𝑥⃗𝑖 ; 𝑥⃗𝑗 ), но не сами
признаки объектов:
𝐿 𝐿 𝐿
1
−𝐿(𝜇⃗) = ∑ 𝜇𝑖 𝜇𝑗 𝑦𝑖 𝑦𝑗 (𝑥⃗𝑖 ; 𝑥⃗𝑗 ) − ∑ 𝜇𝑖 → min ; ∑ 𝜇𝑖 𝑦𝑖 = 0; 0 ≤ 𝜇𝑖 ≤ 𝐶.
2
𝑖,𝑗=1 𝑖=1 𝑖=1
Классификатор исходной задачи зависит лишь от скалярных произведений (𝑥⃗𝑖 ; 𝑥⃗),
но не от самих признаков объектов:
𝐿
𝑎(𝑥⃗) = sgn (∑ 𝜇𝑖 𝑦𝑖 (𝑥⃗𝑖 ; 𝑥⃗𝑗 ) − 𝜃0 )

𝑖=1
77
Можно решить задачу классификации, если можно вычислять скалярные

произведения объектов.
Можно заменить скалярные произведения исходных признаков (𝑥⃗𝑖 ; 𝑥⃗𝑗 ) на
функцию-ядро 𝐾(𝑥⃗𝑖 ; 𝑥⃗𝑗 ) = (𝜙⃗⃗(𝑥⃗𝑖 ); 𝜙⃗⃗(𝑥⃗𝑗 )), обладающую свойствами скалярного
произведения.
𝜙⃗⃗: 𝕏 → ℍ, ℍ − гильбертово пространство.
Функция 𝐾(𝑥⃗𝑖 ; 𝑥⃗𝑗 ) – ядро, тогда и только тогда, когда
𝐾(𝑥⃗𝑖 ; 𝑥⃗𝑗 ) = 𝐾(𝑥⃗𝑗 ; 𝑥⃗𝑖 );
{
∬ 𝐾(𝑥⃗1 ; 𝑥⃗2 )𝑓(𝑥1 )𝑓(𝑥2 )𝑑𝑥1 𝑑𝑥2 ≥ 0 ∀𝑓: 𝕏 → ℝ.
𝕏
Часто используемые ядра
• Линейное ядро: 𝐾𝑙𝑖𝑛𝑒𝑎𝑟 (𝑥⃗1 ; 𝑥⃗2 ) = (𝑥⃗1 ; 𝑥⃗2 )
• Полиномиальное ядро: 𝐾𝑝𝑜𝑙𝑦 (𝑥⃗1 ; 𝑥⃗2 ) = (𝛾(𝑥⃗1 ; 𝑥⃗2 ) + 𝑟)𝑑
• Гауссово ядро (радиальные базисные функции):
𝐾𝑟𝑏𝑓 (𝑥⃗1 ; 𝑥⃗2 ) = exp(−𝛾‖𝑥⃗1 − 𝑥⃗2 ‖2 )
• Сигмоидное ядро: 𝐾sigmoid (𝑥⃗1 ; 𝑥⃗2 ) = tanh(𝛾(𝑥⃗1 ; 𝑥⃗2 ) + 𝑟)
Размерность спрямляющего пространства. Квадратичное ядро
2
Пусть 𝐾2 (𝑎⃗; 𝑏⃗⃗) = (𝑎⃗; 𝑏⃗⃗)
𝐾2 (𝑎⃗; 𝑏⃗⃗) = ((𝑎1 , 𝑎2 ); (𝑏1 , 𝑏2 ))2 = (𝑎1 𝑏1 + 𝑎2 𝑏2 )2 = 𝑎12 𝑏12 + 𝑎22 𝑏22 + 2𝑎1 𝑏1 𝑎2 𝑏2
= ((𝑎12 , 𝑎22 , √2𝑎1 𝑎2 ); (𝑏12 , 𝑏22 , √2𝑏1 𝑏2 ))
Это скалярное произведение в 3-мерном пространстве.
𝑑
В общем случае для степенного ядра 𝐾𝑑 (𝑎⃗; 𝑏⃗⃗) = (𝑎⃗; 𝑏⃗⃗ ) размерность
𝑑
dim ℍ = 𝐶𝑛+𝑑−1
Гауссово ядро
𝐾𝑟𝑏𝑓 (𝑥⃗1 ; 𝑥⃗2 ) = exp(−𝛾‖𝑥⃗1 − 𝑥⃗2 ‖2 )
2
𝐾𝑟𝑏𝑓 (𝑎⃗; 𝑏⃗⃗) = exp(−𝛾‖𝑥⃗1 − 𝑥⃗2 ‖2 ) = exp (−𝛾 (‖𝑎⃗‖2 + ‖𝑏⃗⃗‖ − 2(𝑎⃗; 𝑏⃗⃗)))
2
= exp(−𝛾‖𝑎⃗‖2 ) exp (−𝛾‖𝑏⃗⃗‖ ) exp (2𝛾(𝑎⃗; 𝑏⃗⃗))
∞ 𝑘
(2𝑘)𝑘 (𝑎⃗; 𝑏⃗⃗ )
2
= exp(−𝛾‖𝑎⃗‖2 ) exp (−𝛾‖𝑏⃗⃗‖ ) ∑
𝑘!
𝑘=0
Пространство ℍ имеет бесконечную размерность из-за бесконечного числа
членов ряда.
Часто используемые ядра
78
Рисунок 6.4 Линейное ядро: 𝐾𝑙𝑖𝑛𝑒𝑎𝑟 (𝑥⃗1 ; 𝑥⃗2 ) = (𝑥⃗1 ; 𝑥⃗2 )
Рисунок 6.5 Полиномиальное ядро: 𝐾𝑝𝑜𝑙𝑦 (𝑥⃗1 ; 𝑥⃗2 ) = (𝛾(𝑥⃗1 ; 𝑥⃗2 ) + 𝑟)𝑑
Рисунок 6.6 Гауссово ядро: 𝐾𝑟𝑏𝑓 (𝑥⃗1 ; 𝑥⃗2 ) = 𝑒𝑥𝑝(−𝛾‖𝑥⃗1 − 𝑥⃗2 ‖2 )
• Рисунок 6.7 Сигмоидное ядро: 𝐾𝑠𝑖𝑔𝑚𝑜𝑖𝑑 (𝑥⃗1 ; 𝑥⃗2 ) = 𝑡𝑎𝑛ℎ(𝛾(𝑥⃗1 ; 𝑥⃗2 ) + 𝑟)
SVM и метрические методы. SVM регрессия и метрические методы

Алгоритм для SVM
𝐿
𝑎(𝑥⃗) = sgn (∑ 𝜇𝑖 𝑦𝑖 𝐾𝑟𝑏𝑓 (𝑥⃗; 𝑥⃗𝑖 ) − 𝜃0 )

𝑖=1
• 𝐾𝑟𝑏𝑓 (𝑥⃗1 ; 𝑥⃗2 ) = exp(−𝛾‖𝑥⃗1 − 𝑥⃗2 ‖2 ) – функция близости
• Уже определены амплитуды объектов 𝜇𝑖 и “радиусы” потенциальных функций
79
• Уже проведена селекция объектов, учитывается минимальное число “нужных”

объектов
Получается алгоритм классификации методом потенциальных функций
𝐿
𝜌(𝑥⃗, 𝑥⃗𝑖 )
⃗⃗) = arg max ∑[𝑦𝑖 = 𝑦]𝐴𝑖 𝐾 (
𝑎(𝑥⃗, 𝐴⃗, ℎ )
𝑦 ℎ𝑖
𝑖=1
Разные значения параметра C
Рисунок 6.8 C = 2.0 – “слабая” регуляризация (α = 2/C = 0.5), много объектов
Рисунок 6.9 C = 0.1 – “сильная” регуляризация (α = 2/C = 10.0), много объектов

SVM регрессия
⃗⃗⃗⃗
Выбирается модель: 𝑎(𝑥⃗, 𝜃⃗) = (𝑓⃗(𝑥⃗); 𝜃⃗ ) − 𝜃0
Функция потерь SVM: ℒ(𝑎, 𝑥⃗, 𝑦) = (|𝑎 − 𝑦| − 𝜖)+
Ставится задача оптимизации 𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃, ⃗⃗⃗⃗ 𝜃0 ) при 𝑥
⃗⃗⃗⃗𝑖 ∈ 𝕏𝑡𝑟𝑎𝑖𝑛 :
𝑥𝑖 ∈ 𝕏𝑣𝑎𝑙
Рисунок 6.10 SVM регрессия
80
Исходная задача
2 𝑙
1
⃗
‖𝜃‖ + 𝐶 ∑(𝜁𝑖 + 𝜁𝑖′ ) → min;
2
𝑖=1
−𝜖 − ≤ 𝑦𝑖 − (𝜃⃗, 𝑥⃗) − 𝜃0 ≤ 𝜖 + 𝜁𝑖 ;
𝜁𝑖′
{ 𝜁𝑖 ≥ 0; 𝜁𝑖′ ≥ 0.
Для нее ставится и решается двойственная задача
𝐿
1
∑ (𝜇𝑖 − 𝜇𝑖′ )(𝜇𝑗 − 𝜇𝑗′ )𝑦𝑖 𝑦𝑗 (𝑥⃗𝑖 ; 𝑥⃗𝑗 ) + 𝜖(𝜇𝑖 + 𝜇𝑖′ ) − (𝑦⃗, 𝜇𝑖 − 𝜇𝑖′ ) → min
2
𝑖,𝑗=1
𝐿
∑(𝜇𝑖 − 𝜇𝑖′ ) = 0; 0 ≤ 𝜇𝑖 , 𝜇𝑖′ ≤ 𝐶

{ 𝑖=1
Разные типы ядер
Рисунок 6.11 Линейное ядро
Рисунок 6.12 Гауссово ядро
Рисунок 6.13 Сигмоидное ядро
81
Рисунок 6.14 Гауссово ядро
Рисунок 6.15 Формула НадараяУотсона с гаусовым ядром

Jupyter notebook “SVM классификация и регрессия”:
https://colab.research.google.com/drive/1xPxXUkcLu2OBYgOkxExBmZ7DulQjHi_S
82
Лекция 7. Многомерная линейная и нелинейная регрессия. Градиентные методы

Линейная регрессия
Метод наименьших квадратов: гомоскедастичность
⃗⃗⃗⃗
Квадратичная функция потерь: ℒ(𝑎, 𝑥⃗, 𝑦) = (𝑎 − 𝑦)2
𝐿
1 2
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ∑ ((𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 ) − 𝑦𝑖 ) → 𝑚𝑖𝑛
𝐿 ⃗⃗
𝜃
𝑖=1
𝐾
1 2
𝑄𝑣𝑎𝑙 (𝜃⃗) = ∑ ((𝑥
⃗⃗⃗⃗;
𝑖
⃗
𝜃 ) − 𝑦𝑖 )
𝐾
𝑖=1
Метод наименьших квадратов с весами: гетероскедастичность
⃗⃗⃗⃗
1
Квадратичная функция потерь: ℒ(𝑎, 𝑥⃗, 𝑦) = 𝜎2 (𝑥⃗) (𝑎 − 𝑦)2
𝐿 2
1 1
⃗
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃) = ∑ 2 ((𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 ) − 𝑦𝑖 ) → 𝑚𝑖𝑛
𝐿 𝜎 (𝑥⃗𝑖 ) ⃗𝜃⃗
𝑖=1
𝐾 2
1 1
𝑄𝑣𝑎𝑙 (𝜃⃗) = ∑ 2 ((𝑥
⃗⃗⃗⃗;
𝑖
⃗
𝜃 ) − 𝑦𝑖 )
𝐾 𝜎 (𝑥⃗𝑖 )
𝑖=1
Пример: амплитуда затухающих колебаний маятника 𝐴(𝑡) = 𝐴0 𝑒 −𝛾𝑡
В эксперименте измерены значения 𝑦(𝑡𝑖 ) = 𝐴(𝑡𝑖 ) + 𝜖𝑖 , где 𝜖𝑖 ~𝒩(0, 𝜎 2 )
Способ 1
Исходная модель: 𝑦(𝑡𝑖 ) = 𝐴0 𝑒 −𝛾𝑡𝑖 + 𝜖𝑖
𝐴(𝑡) = 𝐴0 𝑒 −𝛾𝑡 ⇒ ln 𝐴(𝑡) = ln 𝐴0 − 𝛾𝑡
Новая линейная модель: ln 𝑦(𝑡𝑖 ) = ln 𝐴0 −
𝛾𝑡𝑖 + 𝜖′𝑖
Это задача линейной регрессии
относительно 𝐴0 и 𝛾.
Способ 2 Рисунок 7.1 Гетероскедастичность
Исходная модель: 𝑦(𝑡𝑖 ) = 𝐴0 𝑒 −𝛾𝑡𝑖 + 𝜖𝑖

Это задача нелинейной регрессии относительно 𝐴0 и 𝛾.
83
Метод наименьших квадратов

Формальное решение
𝐿
1 2
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ∑ ((𝑥
⃗⃗⃗⃗; ⃗
𝑖 𝜃 ) − 𝑦𝑖 ) → 𝑚𝑖𝑛
𝐿 ⃗𝜃⃗
𝑖=1
2
Пусть 𝒳 = {𝑥⃗1 , 𝑥⃗2 , … , 𝑥⃗𝐿 }; 𝑦⃗ = {𝑦1 , 𝑦2, … , 𝑦𝐿 }, тогда ‖𝒳𝜃⃗ − 𝑦⃗‖2 → 𝑚𝑖𝑛
⃗⃗
𝜃
Формальное решение имеет вид 𝜃⃗0 = (𝒳𝑇
⏟ 𝒳) 𝒳 −1 𝑇
∙ 𝑦⃗
𝒳 + – псевдообратная матрица
Геометрический смысл
2
𝑄(𝜃) = ‖𝒳𝜃⃗ − 𝑦⃗‖2 → min ⇒ 𝜃⃗0 = (𝒳 𝑇 𝒳)−1 𝒳 𝑇 𝑦⃗
⃗𝜃⃗
2
𝒳(𝒳 𝑇 𝒳)−1 𝒳 𝑇 𝑦⃗‖ = ‖𝑦⃗ − 𝑃𝑥 𝑦⃗‖22 → min

𝑄(𝜃0 ) = ‖𝑦⃗ − ⏟
⃗⃗
𝜃
𝑃𝑥 2
• 𝒳[𝐿×𝑛] – матрица признаков
• 𝜃⃗[𝑛] – вектор параметров модели
• (𝒳𝜃⃗ )[𝐿] – аппроксимация МНК, вектор из линейной оболочки 𝑥⃗𝑖
• 𝑦⃗[𝐿] – вектор целевых переменных
• 𝑃𝑥[𝐿×𝐿] – проекционная матрица на линейную оболочку 𝑥⃗𝑖
• (𝑦⃗ − 𝑃𝑥 𝜃⃗)[𝐿] – вектор остатков
Рисунок 7.2 Геометрический смысл метода наименьших квадратов

Сингулярное разложение
Произвольная матрица 𝒳[𝐿×𝑛] может быть представлена в виде сингулярного
разложения:
𝒳[𝐿×𝑛] = 𝑉[𝐿×𝑛] 𝐷[𝑛×𝑛] 𝑈 𝑇 [𝑛×𝑛]
• 𝑉[𝐿×𝑛] состоит из n собственных векторов 𝑣⃗𝑖[𝐿] матрицы (𝒳𝒳 𝑇 )[𝐿×𝐿] .
• ⃗⃗𝑖[𝐿] матрицы (𝒳 𝑇 𝒳)[𝑛×𝑛] .
𝑉[𝐿×𝑛] состоит из n собственных векторов 𝑢
• Собственные значения 𝜆1 , … , 𝜆𝑛 матриц 𝒳𝒳 𝑇 и 𝒳 𝑇 𝒳 совпадают.
• Собственные значения 𝜆1 , … , 𝜆𝑛 ≥ 0.
84
• V и U – ортонормированные матрицы: 𝑉 𝑇 𝑉 = 𝐼[𝑛×𝑛] ; 𝑈 𝑇 𝑈 = 𝐼[𝑛×𝑛] .

• Матрица 𝐷[𝑛×𝑛] диагональна и равна 𝐷[𝑛×𝑛] = diag(√𝜆1 , … , √𝜆𝑛 ).
Применение сингулярного разложения
Решение задачи МНК: 𝜃⃗0 = 𝒳 + 𝑦⃗ = (𝒳 𝑇 𝒳)−1 𝒳 𝑇 𝑦⃗.
Сингулярное разложение: 𝒳 = 𝑉𝐷𝑈 𝑇 ⇒ 𝒳 𝑇 = 𝑈𝐷𝑉 𝑇 .
Псевдообратная матрица:
+
𝒳[𝑛×𝐿] = (𝒳 𝑇 𝒳)−1 𝒳 𝑇 = (𝑈𝐷𝑉 𝑇 ∙ 𝑉𝐷𝑈 𝑇 )−1 ∙ 𝑈𝐷𝑉 𝑇 = (𝑈𝐷 ∙ 𝐷𝑈 𝑇 )−1 ∙ 𝑈𝐷𝑉 𝑇
= (𝐷𝑈 𝑇 )−1 (𝑈𝐷)−1 ∙ 𝑈𝐷𝑉 𝑇 = (𝐷𝑈 𝑇 )−1 ∙ 𝑉 𝑇 = (𝑈 𝑇 )−1 𝐷−1 ∙ 𝑉 𝑇
𝑛
1
= 𝑈𝐷 −1
∙𝑉 =∑𝑇
⃗⃗𝑗 𝑣⃗𝑗𝑇 .
𝑢
𝑗=1
√𝜆𝑗
Решение задачи МНК:
𝑛
1
𝜃⃗0 = 𝒳 + 𝑦⃗ = 𝑈𝐷−1 ∙ 𝑉 𝑇 𝑦⃗ = ∑ ⃗⃗𝑗 (𝑣⃗𝑗𝑇 𝑦⃗)
𝑢
𝑗=1
√𝜆𝑗
Аппроксимация:
𝑛
𝒳𝜃⃗0 = 𝑉𝐷𝑈 ∙ 𝑈𝐷 𝑉 𝑦⃗ = 𝑉𝑉 𝑦⃗ = ∑ 𝑣⃗𝑗 (𝑣⃗𝑗𝑇 𝑦⃗)

𝑇 −1 𝑇 𝑇
𝑗=1
𝑇
Сингулярное разложение: 𝒳[𝐿×𝑛] = 𝑉𝐷𝑈 .
Псевдообратная матрица
+ 1
𝒳[𝑛×𝐿] = 𝑈𝐷−1 ∙ 𝑉 𝑇 = ∑𝑛𝑗=1 ⃗⃗𝑗 𝑣⃗𝑗𝑇 – неустойчива.
𝑢
√𝜆𝑗
Решение задачи МНК

1
𝜃⃗0[𝑛] = 𝒳 + 𝑦⃗ = 𝑈𝐷−1 𝑉 𝑇 𝑦⃗ = ∑𝑛𝑗=1 ⃗⃗𝑗 (𝑣⃗𝑗𝑇 𝑦⃗) – неустойчиво.
𝑢
√𝜆𝑗
Аппроксимация:
(𝒳𝜃⃗0 )[𝐿] = 𝑉𝑉 𝑇 𝑦⃗ = ∑𝑛𝑗=1 𝑣⃗𝑗 (𝑣⃗𝑗𝑇 𝑦⃗) – устойчива.
Проблема мультиколлинеарности: комбинация почти линейно зависимых
признаков приводит к существованию малых собственных значений 𝜆𝑖 .
Следствия: неустойчивость, рост ‖𝜃⃗0 ‖, переобучение.
Методы борьбы с мультиколлинеарностью
• Регуляризация (например, ridgeрегрессия).
• Отбор независимых признаков (например, LASSOрегрессия).
• Переход к новому пространству независимых признаков.
Линейное преобразование признаков. Метод главных компонент
Преобразование без потери информации:
85
𝐺[𝐿×𝑛] −новые признаки матрица преобразования
𝒳[𝐿×𝑛] = ⏞𝑉 ⏞
𝑈 𝑇 [𝑛×𝑛]
⏟[𝐿×𝑛] ∙ 𝐷
⏟[𝑛×𝑛] ∙
⃗⃗1 ,𝑣
{𝑣 ⃗⃗2 ,…,𝑣
⃗⃗𝑛 } √𝜆1 0 ⋯ 0
0 √𝜆2 ⋮ 0
⋮ ⋮ ⋱ ⋮
( 0 0 ⋯ √𝜆𝑛 )
Преобразование с потерей информации:
• 𝜆′𝑖 = 𝜆𝑖 [𝑖 ≤ 𝑚] – выбираются m наибольших собственных значений
𝐷′[𝑛×𝑛] = diag(𝜆′1 , 𝜆′2 , … , 𝜆′𝑛 ); 𝒳′[𝐿×𝑛] = 𝑉[𝐿×𝑛] 𝐷′[𝑛×𝑛] 𝑈 𝑇 [𝑛×𝑛]
• 𝒳′[𝐿×𝑛] ≈ 𝒳[𝐿×𝑛]
Метод главных компонент
• Для матрицы 𝒳[𝐿×𝑛] строится матрица (𝒳 𝑇 𝒳)[𝑛×𝑛]
• У нее отбираются m наибольших собственных значений 𝜆1 , … , 𝜆𝑚
• Соответствующие собственные векторы формируют матрицу 𝑈[𝑛×𝑚]
• U – матрица перехода между n-мерным и m-мерным признаковыми
пространствами. Новые признаки вычисляются как 𝐺[𝐿×𝑚] = 𝒳𝑈
• Матрица U ортонормирована: 𝑈 𝑇 𝑈 = 𝐼[𝑚×𝑚]
• 𝒳 ≈ 𝐺𝑈 𝑇
Рисунок 7.3 Метод главных компонент
𝑥⃗𝑗 – линейно зависимые признаки

𝑔⃗𝑗 – линейно независимые признаки с разной дисперсией
Нелинейная регрессия
𝑥⃗𝑖 ∈ ℛ 𝑛 ; 𝑦𝑖 ∈ ℛ
Выбирается линейная модель: 𝑎(𝑥⃗, 𝜃⃗) = 𝑓(𝑥⃗; 𝜃⃗)
Квадратичная функция потерь: ℒ(𝑎, 𝑥⃗, 𝑦)
Ставится задача оптимизации при 𝑥⃗𝑖 ∈ 𝕏𝑡𝑟𝑎𝑖𝑛 :
𝐿
1
𝑄𝑡𝑟𝑎𝑖𝑛 (𝜃⃗) = ∑ ℒ(𝑓(𝑥⃗𝑖 ; 𝜃⃗), 𝑥⃗𝑖 , 𝑦𝑖 ) → 𝑚𝑖𝑛
𝐿 ⃗𝜃⃗
𝑖=1
86
𝐾
1
𝑄𝑣𝑎𝑙 (𝜃⃗) = ∑ ℒ(𝑓(𝑥⃗𝑖 ; 𝜃⃗ ), 𝑥⃗𝑖 , 𝑦𝑖 ) → 𝑚𝑖𝑛
𝐾 ⃗𝜃⃗
𝑖=1
𝐿
2
𝑄(𝜃⃗) = ∑(𝑓(𝑥⃗𝑖 ; 𝜃⃗) − 𝑦𝑖 ) → 𝑚𝑖𝑛
⃗⃗
𝜃
𝑖=1
1. Инициализация начальных значений параметров 𝜃⃗
2. Цикл, пока 𝜃⃗ и 𝑄 не сошлись к определенным значениям:
a. Линейное приближение функции 𝑓(𝑥⃗𝑖 ; 𝜃⃗)
̂ ̂ ̂
𝑓(𝑥⃗𝑖 ; 𝜃⃗) ≈ 𝑓 (𝑥⃗𝑖 ; 𝜃⃗0 ) + ∇⃗𝜃⃗ 𝑓 (𝑥⃗𝑖 ; 𝜃⃗) (𝜃⃗ − 𝜃⃗)
̂⃗ ̂⃗ ̂⃗ ̂⃗ ⃗
=𝑓
⏟(𝑥⃗𝑖 ; 𝜃 ) − ∇⃗𝜃⃗ 𝑓 (𝑥⃗𝑖 ; 𝜃) 𝜃 + ∇
⏟⃗𝜃⃗ 𝑓 (𝑥⃗𝑖 ; 𝜃) 𝜃 =
⃗̂⃗)
𝛼(𝑥⃗𝑖 ;𝜃 ⃗̂⃗)
𝛽(𝑥⃗𝑖 ;𝜃
̂ ̂
= 𝛼 (𝑥⃗𝑖 ; 𝜃⃗) + 𝛽 (𝑥⃗𝑖 ; 𝜃⃗) 𝜃⃗
̂
b. Решение задачи линейной регрессии и обновление оценки 𝜃⃗
𝐿 2
̂ ̂
𝑄(𝜃⃗) = ∑ [𝛽 (𝑥⃗𝑖 ; 𝜃⃗ ) 𝜃⃗ − (𝑦𝑖 − 𝛼 (𝑥⃗𝑖 ; 𝜃⃗))] → 𝑚𝑖𝑛
⃗𝜃⃗
𝑖=1
Минимизации функционала качества. Методы 1, 2 порядка
МЕТОДЫ 1 ПОРЯДКА
Метод градиентного спуска
𝐿
𝑄(𝜃⃗) = ∑ ℒ(𝑓(𝑥⃗𝑖 ; 𝜃⃗), 𝑥⃗𝑖 , 𝑦𝑖 ) → 𝑚𝑖𝑛

⃗𝜃⃗
𝑖=1
Идея: поиск минимума в направлении скорейшего спуска
1. Выбирается значение скорости обучения lr
3. Цикл, пока 𝜃⃗ и 𝑄(𝜃⃗) не сошлись к определенным значениям:
a. Вычисляется градиент ∇⃗⃗ 𝑄(𝜃⃗) = ∑𝐿𝑖=1 ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 )
𝜃
b. Обновляются значения параметров 𝜃⃗:= 𝜃⃗ − 𝑙𝑟 ∙ ∑𝐿𝑖=1 ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 )
Метод стохастического градиентного спуска (Stochastic Gradient Descent)
Идея: делать градиентный шаг на каждом объекте, а не на всех сразу
1. Выбирается значение скоростей обучения lr и забывания λ
3. Делается начальная оценка функционала 𝑄̂ ≔ 𝑄(𝜃⃗ )
4. Цикл, пока 𝜃⃗ и 𝑄̂ не сошлись к определенным значениям:
a. Выбирается произвольный объект 𝑥⃗𝑖
b. Вычисляется градиент 𝐺⃗𝑖 = ∇⃗⃗ ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 ) 𝜃
87
c. Обновляются значения параметров 𝜃⃗ ≔ 𝜃⃗ − 𝑙𝑟 ∙ 𝐺⃗𝑖

d. Обновляется значение функционала 𝑄̂ ≔ (1 − 𝜆)𝑄̂ + 𝜆ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 )
Используется оценка экспоненциального скользящего среднего:
𝑛
𝑄̂ = 𝜆ℒ (𝑛)
+ (1 − 𝜆)𝜆ℒ (𝑛−1)
+ (1 − 𝜆)2 𝜆ℒ (𝑛−2)
+ ⋯ = 𝜆 ∑(1 − 𝜆)𝑘 ℒ (𝑛−𝑘)
𝑘=0
Метод стохастического усредненного градиентного спуска (Stochastic Avegare
Gradient)
Идея: усреднить градиент по большому числу итераций
1. Выбирается значение скоростей обучения lr и забывания λ
3. Сохраняется оценка всех градиентов 𝐺⃗𝑖 = ∇𝜃⃗⃗ ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 )
4. Делается начальная оценка функционала 𝑄̂ ≔ 𝑄(𝜃⃗ )
b. Вычисляется и обновляется градиент 𝐺⃗𝑖 = ∇⃗⃗ ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 ) 𝜃
1
c. Обновляются значения параметров 𝜃⃗ ≔ 𝜃⃗ − 𝑙𝑟 ∙ 𝐿 ∑𝐿𝑖=1 𝐺⃗𝑖
Из суммы вычитывается старое значение 𝐺⃗𝑖 и добавляется новое
Метод импульса (Momentum)
Идея: применить к градиенту экспоненциальное скользящее среднее.
Аналогия – шарик, катящийся по поверхности с вязким трением.
1. Выбирается значение скоростей обучения lr и забывания λ; μ
3. Делается начальная оценка функционала 𝑄̂ ≔ 𝑄(𝜃⃗ ) и импульса 𝑃⃗⃗ = 0
b. Обновляется значение импульса 𝑃⃗⃗ ≔ (1 − 𝜇)𝑃⃗⃗ + 𝜇𝛻⃗⃗ ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 )
𝜃
c. Обновляются значения параметров 𝜃⃗ ≔ 𝜃⃗ − 𝑙𝑟 ∙ 𝑃⃗⃗
Метод Нестерова (Nesterov Accelerated Gradient)
Идея: вычислять градиент не в “текущей”, а в “следующей” точке
1. Выбирается значение скоростей обучения lr и забывания λ; μ
3. Делается начальная оценка функционала 𝑄̂ ≔ 𝑄(𝜃⃗ ) и импульса 𝑃⃗⃗ = 0
88
b. Обновляется значение импульса 𝑃⃗⃗ ≔ (1 − 𝜇)𝑃⃗⃗ + 𝜇𝛻⃗𝜃⃗ ℒ(𝜃⃗ − 𝑙𝑟 ∙

𝑃, 𝑥⃗𝑖 , 𝑦𝑖 )
c. Обновляются значения параметров 𝜃⃗ ≔ 𝜃⃗ − 𝑙𝑟 ∙ 𝑃⃗̂⃗
Выбор градиентного шага
• Если шаг слишком мал, сходимость будет долгой.
• Если шаг слишком велик, алгоритм может не сойтись.
• Адаптивный шаг, зависящий от номера итерации.
2
o В теории должно быть 𝑙𝑟 (𝑛) → 0; ∑∞
𝑛=1 𝑙𝑟
(𝑛)
= ∞; ∑∞
𝑛=1(𝑙𝑟
(𝑛)
) <∞
Например, ℎ(𝑛) = 𝑛−1 .
o Метод наискорейшего градиентного спуска:
ℒ (𝜃⃗ − 𝑙𝑟 ∙ ∇⃗⃗ ℒ(𝜃⃗)) → min
𝜃 𝑙𝑟
o Случайные шаги, чтобы не “застревать” в локальных минимумах.
• Использование методов второго порядка
Инициализация начальных значений параметров 𝜃⃗
• 𝜃⃗ = ⃗0⃗
• 𝜃⃗ – небольшие случайные значения
• Запуск алгоритма с разными начальными значениями 𝜃⃗ и выбор лучшего
• Предварительный быстрый поиск по малой подвыбоке объектов
• МНК в предположении, что признаки независимы:
o Матрица признаков 𝒳[𝐿×𝑛] = {𝑥⃗1 , 𝑥⃗2 , … , 𝑥⃗𝐿 } = {𝑓⃗1 , 𝑓⃗2 , … , 𝑓⃗𝑛 }𝑇
o Признаки считаем независимыми: 𝑖 ≠ 𝑗 ⇒ (𝑓⃗𝑖 ; 𝑓⃗𝑗 ) = 0
o Ищем решение вида 𝒳𝜃⃗0 = 𝑦⃗
o Тогда 𝑓⃗𝑗𝑇 𝒳𝜃⃗0 = 𝑓⃗𝑗𝑇 𝑦⃗ ⇒ 𝜃0,𝑗 = (𝑓⃗𝑗 ; 𝑦⃗)⁄(𝑓⃗𝑗 ; 𝑓⃗𝑗 )
Порядок обучения на объектах выборки
• При классификации – выбирать объекты попеременно из разных классов.
• С большей вероятностью выбираются объекты, на которых
o меньше отступ 𝑀𝑖 = 𝑎(𝑥⃗𝑖 )𝑦𝑖 , т.е. алгоритм сильно ошибается;
o меньше модуль отступа |𝑀𝑖 |, т.е. классификация неуверенная;
o больше ошибка алгоритма ℒ(𝑎(𝑥⃗𝑖 ), 𝑥⃗𝑖 , 𝑦𝑖 )
• Не выбираются объекты, у которых
o отступ больше порогового значения (хорошо классифицируются) ;
o отступ меньше порогового значения (это выбросы) ;
o ошибка алгоритма больше или меньше порогового значения.
Методы адаптивных градиентов
Adaptive Gradient (AdaGrad)
89
Идея: раздельно учитывать градиент для “редких” и “частых” признаков.

• Вычисляется градиент 𝐺⃗𝑖 ≔ ∇⃗⃗ ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 )
𝜃
• Накапливается вектор суммы квадратов ⃗Г⃗ ≔ ⃗Г⃗ + 𝐺⃗𝑖 ⨀𝐺⃗𝑖
• Обновляются значения параметров 𝜃⃗ ≔ 𝜃⃗ − 𝑙𝑟 ∙ 𝐺⃗𝑖 ⊘ √⃗Г⃗ + 𝜖⃗
Running Mean Square (RMSProp)
Идея: замена накопления экспоненциальным скользящим средним
𝜃
• Скользящее экспоненциальное среднее ⃗Г⃗ ≔ 𝛼Г
⃗⃗ + (1 − 𝛼)𝐺⃗𝑖 ⨀𝐺⃗𝑖
• Обновляются значения параметров 𝜃⃗ ≔ 𝜃⃗ − 𝑙𝑟 ∙ 𝐺⃗𝑖 ⊘ √⃗Г⃗ + 𝜖⃗
Adaptive Delta (AdaDelta)
Идея: двойная нормировка градиентов позволяет не подбирать lr.
𝜃
• Скользящее экспоненциальное среднее ⃗Г⃗ ≔ 𝛼Г
⃗⃗ + (1 − 𝛼)𝐺⃗𝑖 ⨀𝐺⃗𝑖
𝛿⃗ ≔ 𝐺⃗𝑖 ⨀√∆ ⃗⃗ + 𝜖⃗ ⊘ √⃗Г⃗ + 𝜖⃗;
• Вычисляются “дельты”: {
⃗⃗≔ 𝛼∆
∆ ⃗⃗ + (1 − 𝛼)𝛿⃗⨀𝛿⃗
• Обновляются значения параметров 𝜃⃗ ≔ 𝜃⃗ − 𝑙𝑟 ∙ 𝛿⃗
Adaptive Momentum (Adam)
Идея: объединение методов Momentum и RMSProp
𝜃
• Скользящее экспоненциальное среднее ⃗Г⃗ ≔ 𝛼Г ⃗⃗ + (1 − 𝛼)𝐺⃗𝑖 ⨀𝐺⃗𝑖
• Обновляется значение импульса 𝑃⃗⃗ ≔ (1 − 𝜇)𝑃⃗⃗ + 𝜇𝛻⃗⃗ ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 )
𝜃
• Корректировки: 𝑃⃗⃗̂ ≔ 𝑃⃗⃗⁄(1 − 𝜇 𝑛 ) и ⃗Г̂⃗ ≔ ⃗Г⃗⁄(1 − 𝛼 𝑛 ).
• Обновляются значения параметров 𝜃⃗ ≔ 𝜃⃗ − 𝑙𝑟 ∙ 𝑃⃗̂⃗ ⊘ √⃗Г̂⃗ + 𝜖⃗

• Можно использовать 𝜇 = 0.9; 𝛼 = 0.999; 𝜖 = 10−8 .
Nesterov Adaptive Momentum (Nadam)
Идея: объединение методов NAG и RMSProp
• Обновляются значения параметров
1−𝜇
𝜃⃗ ≔ 𝜃⃗ − 𝑙𝑟 ∙ (𝜇𝑃⃗̂⃗ + 𝛻 ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 )) ⊘ √⃗Г̂⃗ + 𝜖⃗
1 − 𝜇 𝑛 𝜃⃗⃗
Иллюстрация скорости обучения различными алгоритмами
Alec Radford’s animations for optimization algorithms:
http://www.denizyuret.com/2015/03/alec-radfords-animations-for.html
МЕТОДЫ 2 ПОРЯДКА
Метод касательных (Ньютона-Рафсона)
90
Задача: найти решение уравнения 𝑓(𝑥) = 0 на отрезке [𝑎; 𝑏], если оно
существует, единственно, и существует непрерывная на [𝑎; 𝑏] производная 𝑓′(𝑥), не
равная 0.
• Пусть 𝑓(𝑥̂) = 0, тогда 𝑓 (𝑥 (𝑘) + (𝑥̂ − 𝑥 (𝑘) )) = 0
• По формуле Лагранжа ∃𝑥̃ ≔ 𝑓(𝑥 (𝑘) ) + 𝑓′(𝑥)(𝑥̂ − 𝑥 (𝑘) ) = 0
• Если положить 𝑥̃ ≔ 𝑥 (𝑘) и 𝑥̂ = 𝑥 (𝑘+1) , получается формула итерационного
процесса: 𝑓(𝑥 (𝑘) ) + 𝑓′(𝑥 (𝑘) )(𝑥 (𝑘+1) − 𝑥 (𝑘) ) = 0
𝑓(𝑥 (𝑘) )
• 𝑥 (𝑘+1) = 𝑥 (𝑘) − 𝑓′(𝑥 (𝑘+1) )
Метод Ньютона-Рафсона
𝜕 2 ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 )
𝜃⃗ ≔ 𝜃⃗ − 𝑙𝑟 ∙ 𝐻 −1 ∙ 𝛻⃗𝜃⃗ ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 ), 𝐻𝑝𝑞 = – гессиан
𝜕𝜃𝑝 𝜕𝜃𝑞
Диагональный метод Левенберга-Марквардта
−1
𝜕 2 ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 ) 𝜕ℒ(𝜃⃗, 𝑥⃗𝑖 , 𝑦𝑖 )
𝜃𝑗 ≔ 𝜃𝑗 − 𝑙𝑟 ∙ (𝜇 + ) ∙
𝜕𝜃𝑗2 𝜕𝜃𝑗
• Можно положить lr = 1 и оптимизировать только µ
• Вдали от минимума скорость обучения будет lr/µ
91
Лекция №8. Критерии оценки качества моделей. Логические закономерности

Критерии качества в задачах бинарной классификации
Матрица платежей
Истина
Нет, p0 Да, p1
1
Альтернати
Ложная тревога Правильное обнаружение

ва
0
Правильное необнаружение Пропуск цели
Таблица 8.1 Матрица платежей
Риск = ЦЛТ ∙ 𝑝(ЛТ) + ЦПЦ ∙ 𝑝(ПЦ)

ЦЛТ – цена ложной тревоги, ЦПЦ – цена пропуска цели, ЛТ – ложная тревога, ПЦ
– пропуск цели
Рисунок 8.1 Table of confusion (Таблица беспорядка)

Accuracy
𝑇𝑃 + 𝑇𝑁
𝐴𝑐𝑐𝑢𝑟𝑎𝑐𝑦 = − доля верных ответов
𝑇𝑃 + 𝑇𝑁 + 𝐹𝑃 + 𝐹𝑁
Недостатки
• не учитывается баланс классов, они входят симметрично;
• не учитываются цены ошибок.
Примеры
• Отрицательная диагностика редкого заболевания.
• На “Титанике” выжили 19% мужчин и 75% женщин.
Классификатор “выжили все женщины, и погибли все мужчины” дает
𝑎𝑐𝑐𝑢𝑟𝑎𝑐𝑦 = 79%
92
Точность (precision)
Задача типа поиска:
TN – заведомо большое число
Доля релевантных ответов среди выбранных
𝑇𝑃
𝑃𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 =
𝑇𝑃 + 𝐹𝑃
Недостатки: отбирается только часть релевантных
объектов
Полнота (recall)
Задача типа поиска:
TN – заведомо большое число
Доля выбранных ответов среди релевантных
𝑇𝑃
𝑅𝑒𝑐𝑎𝑙𝑙 =
𝑇𝑃 + 𝐹𝑁
Недостатки: среди отобранных объектов может быть
много ошибок
2 ∙ 𝑃𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 ∙ 𝑅𝑒𝑐𝑎𝑙𝑙 Рисунок 8.2 Precision and recall
𝐹1 =
𝑃𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 + 𝑅𝑒𝑐𝑎𝑙𝑙
(1 + 𝛽 2 ) ∙ 𝑃𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 ∙ 𝑅𝑒𝑐𝑎𝑙𝑙
𝐹𝛽 =
𝛽 2 ∙ 𝑃𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 + 𝑅𝑒𝑐𝑎𝑙𝑙
Чувствительность и специфичность (sensitivity and
specificity)
Задача с несбалансированными классами
Доля верных положительных диагнозов
𝑇𝑃
𝑆𝑒𝑛𝑠𝑖𝑡𝑖𝑣𝑖𝑡𝑦 = 𝑅𝑒𝑐𝑎𝑙𝑙 =
𝑇𝑃 + 𝐹𝑁
Доля верных отрицательных диагнозов
𝑇𝑃
𝑆𝑝𝑒𝑐𝑖𝑓𝑖𝑐𝑖𝑡𝑦 =
𝑇𝑃 + 𝐹𝑃
Обобщение на мультиклассовый случай
Усреднение 1 типа (классы сбалансированы):
∑𝑠𝑗=1 𝑇𝑃𝑗
𝑃𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 = 𝑠
∑𝑗=1(𝑇𝑃𝑗 + 𝐹𝑃𝑗 )
Рисунок 8.3 Sensitivity and specificity
Усреднение 2 типа (классы не сбалансированы):
𝑠
1 𝑇𝑃𝑗
𝑃𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 = ∑
𝑠 𝑇𝑃𝑗 + 𝐹𝑃𝑗
𝑗=1
ROC-кривая (receiver operating characteristic)
• Пусть алгоритм 𝑎(𝑥⃗, 𝜃⃗) = 𝑠𝑔𝑛(𝑓(𝑥⃗, 𝜃⃗) − 𝜃0 )
• Порог 𝜃0 изменяется в широких пределах
• Для каждого 𝜃0 определяются
93
𝐹𝑃
o 𝐹𝑃𝑅 = 𝐹𝑃+𝑇𝑁 ≡ 1 − 𝑆𝑝𝑒𝑐𝑖𝑓𝑖𝑐𝑖𝑡𝑦 – доля ошибок на классе “–1”;
𝑇𝑃
o 𝑇𝑃𝑅 = 𝑇𝑃+𝐹𝑁 ≡ 𝑆𝑒𝑛𝑠𝑖𝑡𝑖𝑣𝑖𝑡𝑦 – доля ошибок на классе “+1”.
Рисунок 8.4 ROCкривая (receiver operating characteristic)
• Вычисляется AUC
• ROC-кривая не зависит от числа объектов
Log-loss
Модель классификации оценивает вероятность принадлежности к каждому
классу.
Критерий – логарифм правдоподобия:
𝐿
𝐿(𝜃⃗) = ∑ ([𝑦𝑖 = +1] ln 𝑓(𝑥⃗, 𝜃⃗) + [𝑦𝑖 = −1] ln (1 − 𝑓(𝑥⃗, 𝜃⃗))) → max
⃗𝜃⃗
𝑖=1
Генерация семейств правил. Синтез правил на основе выбранных семейств
Задачи линейной регрессии и классификации
Рисунок 8.5 Задачи линейной регрессии и классификации

Идея: на основе признаков создать набор правил для более эффективного решения
задачи; отобранные правила – новые признаки.
• Правила возвращают 1 (выделение) или 0 (отказ от классификации).
• Правила должны быть интерпретируемы.
• Правила должны быть информативны.
94
Генерация семейств правил. Простые правила

• Решающий пень (decision stump)
o односторонний: [𝑥𝑗 ≤ 𝑎]
o двусторонний: [𝑎 ≤ 𝑥𝑗 ≤ 𝑏]
• Решающий шар [𝜌(𝑥⃗; 𝑥⃗0 ) ≤ 𝜃0 ] с
применением различных функций расстояния.
• Решающая плоскость:
[∑ 𝑥𝑗 𝜃𝑗 ≥ 𝜃0 ]
𝑗∈𝕁
Сложные правила
• Объединение правил ⋂𝑗∈𝕁[𝑎𝑗 ≤ 𝑥𝑗 ≤ 𝑏𝑗 ]
• “Синдром” ∑𝑗∈𝕁[𝑎𝑗 ≤ 𝑥𝑗 ≤ 𝑏𝑗 ] ≥ 𝑐
o 𝑐 = 1 ⇒ ⋃𝑗∈𝕁[𝑎𝑗 ≤ 𝑥𝑗 ≤ 𝑏𝑗 ]
o 𝑐 = |𝐽| ⇒ ⋂𝑗∈𝕁[𝑎𝑗 ≤ 𝑥𝑗 ≤ 𝑏𝑗 ]
Часто полагают |J| равным 3 для простоты подбора.
Синтез правил на основе выбранных семейств
1. Генерируется исходный набор правил.
2. Правила немного модифицируются (параметры a, b, c, вектор 𝑥⃗0, наборы
признаков J).
3. Новый и исходный наборы правил объединяются, и при необходимости
удаляются повторы.
4. Выбор наиболее информативных правил для следующего шага.
Критерии информативности правил
• P(R) – число правильно отобранных правилом объектов
• N(R) – число неверно отобранных правилом объектов
Хотелось бы, чтобы 𝑃(𝑅) → 𝑚𝑎𝑥 ; 𝑁(𝑅) → 𝑚𝑖𝑛
Парето-расслоение
Парето-слой – набор неулучшаемых правил
Рисунок 8.6 Парето-расслоение

Проверка гипотез
95
Гипотеза 𝐻0 : правило 𝑅(𝑥⃗) и результат 𝑦(𝑥⃗) независимы.

Точный тест Фишера:
Информативность
1 𝐶𝑝𝐶𝑛
(𝑝, 𝑛) = − log 2 𝑃𝑝+𝑛𝑁 → max
𝐿 𝐶𝑃+𝑁
Рисунок 8.7 Проверка гипотез

Серая область – статистически незначимые результаты
Условие ϵ − δ
𝑛(𝑅)
• ≤ 𝜖 – правило делает мало ошибок;
𝑝(𝑅)+𝑛(𝑅)
𝑃(𝑅)
• ≥ 𝛿 – правило отбирает много правильных объектов.
𝐿
Рисунок 8.8 Условие ϵ − δ. ϵ=0.45; δ=0.05.

Серая область – значения, где условие ϵ − δ не выполнено.
Информационные критерии
• Правило упорядочивает элементы выборки, выделяя один класс.
• Мера беспорядка – энтропия 𝐻(𝑝⃗) = − ∑𝑠𝑗=1 𝑝𝑗 log 𝑠 𝑝𝑗 ,
𝑝𝑗 – вероятность j-го класса, s – число классов.
1
o 𝑝𝑗 = 𝑠 ⇒ 𝐻(𝑝⃗) = 1 – неупорядоченная выборка
o 𝑝𝑗 = 𝛿(𝑖, 𝑗) ⇒ 𝐻(𝑝⃗) = 0 – полностью упорядоченная выборка
• Неопределенность до применения правила должна быть больше
Преобразование энтропии при разделении выборки 𝒳 на части 𝒳𝑘
96
𝑠 𝑠 𝑠
1 1
𝐻(𝑝⃗) = − ∑ 𝑝𝑗 log 𝑠 𝑝𝑗 = − ∑ 𝑁𝑗 log 𝑠 𝑝𝑗 = − ∑[𝑦(𝑥⃗𝑗 ) = 𝑗] log 𝑠 𝑝𝑗
𝐿 𝐿
𝑗=1 𝑗=1 𝑗=1
1
= − ∑ ∑ [𝑦(𝑥⃗) = 𝑗] log 𝑠 𝑝𝑗
𝐿
𝑘 𝑥⃗∈𝒳𝑘
𝐿𝑘 1 𝐿𝑘
/ 𝑝𝑗 = 𝑝𝑗𝑘 /→ ∑ (− ∑ [𝑦(𝑥⃗) = 𝑗] log 𝑠 𝑝𝑗𝑘 ) = ∑ 𝐻(𝑝⃗𝑘 )
𝐿 𝐿𝑘 𝐿
𝑘 𝑥⃗∈𝒳𝑘 𝑘
𝐿𝑘
𝐺𝑎𝑖𝑛 = 𝐻(𝑝⃗) − ∑ 𝐻(𝑝⃗𝑘 )
𝐿
𝑘
Бинарная классификация
До разделения
• в выборке было 𝑝𝐿 объектов класса “+1” и (1 − 𝑝)𝐿 – класса “-1”;
• энтропия 𝐻0 (𝑝) = −𝑝 log 2 𝑝 − (1 − 𝑝) log 2 (1 − 𝑝)
После разделения
• выделено P объектов класса “+1” и N – класса “1”;
• не выделено 𝑝𝐿 − 𝑃 объектов класса “+1” и (1 − 𝑝)𝐿 − 𝑁 – класса “-1”.
𝑃 𝑃 𝐿−𝑃−𝑁 (1 − 𝑝)𝐿 − 𝑁
• энтропия 𝐻(𝑃, 𝑁) = 𝐿 log 2 𝑃+𝑁 + log 2
𝐿 𝐿−𝑃−𝑁
Выигрыш 𝐺𝑎𝑖𝑛 = 𝐻(𝑃, 𝑁) − 𝐻0 (𝑝)
Энтропия и неопределенность Джини
Энтропия: 𝐻(𝑝) = −𝑝 log 2 𝑝 − (1 − 𝑝) log 2 (1 − 𝑝)
Неопределенность Джини: 𝐺𝑖𝑛𝑖 = 4𝑝(1 − 𝑝)
Рисунок 8.9 Энтропия и неопределенность Джини

Сведение к однопараметрическому описанию
𝑝(𝑅)
• 𝑃𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 = 𝑝(𝑅)+𝑛(𝑅)
• 𝐴𝑐𝑐𝑢𝑟𝑎𝑐𝑦 = 𝑝(𝑅) − 𝑛(𝑅)
• 𝑅𝑒𝑙𝑎𝑡𝑖𝑣𝑒 𝐴𝑐𝑐𝑢𝑟𝑎𝑐𝑦 = 𝑝(𝑅)⁄𝑃 − 𝑛(𝑅)⁄𝑁
• Энтропийный критерий
97
• Критерий Джини
• 𝐵𝑜𝑜𝑠𝑡𝑖𝑛𝑔 = √𝑝(𝑅) − √𝑛(𝑅)
Решающие деревья
Рисунок 8.10 Решающие деревья

Внутренняя вершина – правило перехода в одну из дочерних вершин. Если их
всегда 2, то дерево бинарное.
Листовая вершина содержит значение целевого признака.
Дерево – покрывающий набор конъюнкций:
• 𝐼𝑟𝑖𝑠 − 𝑠𝑒𝑡𝑜𝑠𝑎: (𝑃𝐿 < 1)
• 𝐼𝑟𝑖𝑠 − 𝑣𝑒𝑟𝑠𝑖𝑐𝑜𝑙𝑜𝑟: (𝑃𝐿 ≥ 1) ∩ (𝑃𝑊 < 1.75)
• 𝐼𝑟𝑖𝑠 − 𝑣𝑖𝑟𝑔𝑖𝑛𝑖𝑐𝑎: (𝑃𝐿 ≥ 1) ∩ (𝑃𝑊 ≥ 1.75)
Алгоритм обучения дерева
1. Пусть имеется выборка объектов 𝒳
2. Задается порог ветвления 𝛼
3. Выбирается критерий 𝑓(𝑟, 𝒳𝜈 ) оценки правила 𝑟, показывающий,
насколько хорошо оно делит выборку 𝒳𝜈
4. Построение дерева ведется рекурсивно, начиная с корня:
Root, 𝑝⃗ = Tree(𝒳)
https://en.wikipedia.org/wiki/ID3_algorithm
Функция 𝜈, 𝑝⃗ = Tree(𝒳′)
1. Выбор из всех правил 𝑟 наилучшего: 𝑟𝜈 = arg max 𝑓(𝑟, 𝒳′)
𝑟
2. Если 𝑓(𝑟, 𝒳 ′ ) < 𝛼, то
a. создается листовая вершина 𝜈 с целевым признаком, равным моде 𝒳;
1
b. рассчитывается вектор вероятностей классов 𝑝𝑖 = ∑𝑥⃗∈𝒳 ′ [𝑦(𝑥⃗) = 𝑦𝑖 ].
𝐿′
3. Если 𝑓(𝑟, 𝒳 ′ ) ≥ 𝛼, то
a. 𝒳′ разбивается на подвыборки 𝒳𝑘′
b. для каждой из 𝒳𝑘′ вычисляются 𝜈𝑘 ,𝑞⃗𝑘 = Tree(𝒳𝑘′ );
c. создается внутренняя вершина 𝜈 с потомками 𝜈𝑘 ;
𝐿′
d. рассчитывается вектор вероятностей классов 𝑝⃗ = ∑𝑘 𝐿′𝑘 𝑞⃗𝑘
4. Возвращается вершина 𝜈 и вектор 𝑝⃗.
98
Пропущенные значения
При обучении объекты с пропущенным значением признака игнорируются
При классификации объектам с пропущенным значением признака в вершине v
приписывается наиболее вероятный класс:
𝑎(𝑥) = arg max 𝑝𝜈,𝑗
𝑗
Дерево классификации и регрессии (Classification And Regression Tree)
1
Критерий 𝑓(𝑟, 𝒳) = 𝐿 ∑(𝑦 − 𝑦𝑗 (𝑥⃗))2
1
Значения в листе усредняются: 𝑦 = 𝐿 ∑ 𝑦𝑖
Итог – кусочно-постоянная функция
Возможные проблемы
• Сильное переобучение из-за жадного алгоритма ветвления.
• Мало объектов в листьях, низкая статистическая значимость.
• Высокая неустойчивость решения.
Рисунок 8.11 Проблемы в алгоритме с использованием решающих деревьев
С выборкой 𝒳𝑣𝑎𝑙 (объемом не менее 𝐿/2)

для каждой внутренней вершины 𝜈:
• Если объекты “не дошли” до 𝜈, заменить ее на лист arg max 𝑝𝜈,𝑗
𝑗
Вычисляются ошибки на 𝒳𝑣𝑎𝑙 и выбирается наилучший вариант:
• Структуры вершины 𝜈 сохраняется.
• Вершина 𝜈 заменяется на лист с классом arg max 𝑝𝜈,𝑗 .
𝑗
• Вершина 𝜈 заменяется на одно из своих поддеревьев.
Существует множество способов перебора вершин, от которых существенно
зависит результат.
Рандомный лес. Плюсы и минусы
1
Для классификации: 𝑎rf (𝑥⃗) = sgn 𝑇 ∑𝑡 𝑎𝑡 (𝑥⃗)
1
Для регрессии: 𝑎rf (𝑥⃗) = 𝑇 ∑𝑡 𝑎𝑡 (𝑥⃗)
99
Плюсы:
• Высокая точность предсказаний (часто лучше, чем у линейных методов).
• Устойчивость к выбросам.
• Нет чувствительности к масштабированию параметров.
• Хорошо работает практически без подбора параметров.
• Хорошо работает на выборках с большим числом объектов и признаков,
легко распараллеливается.
• “Встроенная” валидация и оценка важности признаков.
Минусы:
• Результат сложно интерпретировать.
• Плохо работает с разреженными данными (хуже, чем линейные методы).
• Нет возможности экстраполяции.
• Склонность к переобучению на зашумленных данных.
Сравнение решающего дерева и KNN
Рисунок 8.12 Решение с помощью KNN (k = 10)
Рисунок 8.13 Решение с помощью решающего дерева
100
Ограничение на глубину дерева
Рисунок 8.14 Глубина = 2
Рисунок 8.15 Глубина = 4

Ограничение на число элементов в листе
Рисунок 8.16 Число элементов в листе ≥ 2
101

Сравнение рандомного леса и KNN
Рисунок 8.18 Решение с помощью KNN (k = 10)
Рисунок 8.19 Решение с помощью рандомного леса (100 деревьев)

Ограничение на глубину дерева
102
Рисунок 8.20 Глубина деревьев в лесе = 2
Рисунок 8.21 Глубина деревьев в лесе = 4

Ограничение на число элементов в листе

Регрессия с помощью деревьев принятия решений и рандомного леса
103
Рисунок 8.24 Дерево принятия решений
Рисунок 8.25 Рандомный лес

Jupyter notebook “Decision Tree и RF классификация и регрессия”:
https://colab.research.google.com/drive/1oqaczrdb4U0iCDHJezvZzs3pAGP7ZAKt
104
Лекция №9. Ансамбли алгоритмов. Беггинг и бустинг.

Ансамбль алгоритмов. Метод bootstrap. Метод рандомизации алгоритмов
Может ли несколько плохих алгоритмов дать вместе хороший результат?
• Решается задача бинарной классификации.
• Пусть имеется 5 независимых алгоритмов 𝑎𝑗 (𝑥⃗), каждый из которых дает
правильный ответ с вероятностью 𝑝0 = 0.6.
• Итоговое решение принимается большинством голосов.
• Тогда вероятность правильного решения равна
𝑝 = 𝑝05 + 𝐶54 𝑝04 (1 − 𝑝) + 𝐶53 𝑝03 (1 − 𝑝)2 ≈ 0.68
Задача: обучить много независимых алгоритмов
Простое голосование:
𝑇
1
𝑎(𝑥⃗) = ∑ 𝑎𝑡 (𝑥⃗)
𝑇
𝑡=1
Взвешенное голосование:
𝑇
𝑎(𝑥⃗) = ∑ 𝛼𝑡 𝑎𝑡 (𝑥⃗)
𝑡=1
• Значения 𝑎𝑡 (𝑥⃗) – это новое признаковое описание объекта.
• Можно подбирать 𝛼𝑡 линейными методами.
• Нужно учитывать ограничения: 𝛼𝑡 > 0; ∑ 𝛼𝑡 = 1
Смесь алгоритмов:
𝑇
𝑎(𝑥⃗) = ∑ 𝑔𝑡 (𝑥⃗)𝑎𝑡 (𝑥⃗, ⃗⃗⃗⃗

𝜃𝑡 )
𝑡=1
• 𝑔𝑡 (𝑥⃗) – функции компетентности (gated functions).
• 𝑔𝑡 (𝑥⃗) определяют области, где работает один или другой алгоритм.
Метод bootstrap
Требуется посчитать статистику Θ распределения 𝑤(𝑥)
(𝑘)
Генерируется набор объектов 𝑥𝑗 из
распределения 𝑤(𝑥)
Вычисляется выборочная статистика Θ𝑘 =
(𝑘)
Θ(𝑥 )
Вычисляем среднюю статистику по всем
наборам Θ̂ = ℳ{Θ𝑘 }
Рисунок 9.1 Метод bootstrap Объект может быть выбран многократно.
Методы рандомизации алгоритмов

• Обучение на разных подмножествах объектов.
105
• Обучение с разными подмножествами признаков.

• Использование разных параметрических моделей.
• Использование разных методов обучения.
• Зашумление данных.
Рисунок 9.2 Методы рандомизации алгоритмов

Беггинг. Рандомный лес - частный случай беггинга
Bagging = Bootstrap AGGregatING
формирование подвыборок с возвратом объектов
Рисунок 9.3 Bagging

https://en.wikipedia.org/wiki/Bootstrap_aggregating
OOB-валидация
• Пусть выборка содержит 𝐿 объектов.
106
1 1
• Вероятность выбора каждого объекта 𝑝0 = 𝐿, не выбора 1 − 𝐿 .
• Пусть процесс выбора повторяется 𝐿 раз.
• Тогда вероятность не выбора объекта ни разу равна
1 𝐿 1
(1 − ) → ≈ 37%
𝐿 𝐿→∞ 𝑒
• Не выбранные объекты образуют подвыборку Out-Of-Bag.
По ним можно осуществлять валидацию модели.
Дополнительные возможности OOB-валидации
Оценка OOB на каждом объекте выборки считается только по множеству
алгоритмов 𝑇(𝑥⃗) длиной 𝐿(𝑇(𝑥⃗)), которые на этом объекте не обучались:
1
OOB(𝑥⃗) = ∑ 𝑎𝑗 (𝑥⃗)
𝐿(𝑇(𝑥⃗))
𝑗∈𝑇(𝑥⃗)
Ошибка ансамбля на 𝒳𝑡𝑟𝑎𝑖𝑛 равна:
ℒOOB = ∑ ℒ(OOB(𝑥⃗𝑖 ), 𝑦𝑖 )
𝑥⃗𝑖 ∈𝒳𝑡𝑟𝑎𝑖𝑛
Важность признака:
(𝑗)
ℒ − ℒOOB
Imp𝑗 = OOB
ℒOOB
Рандомный лес – частный случай беггинга
• В качестве базовых алгоритмов используются решающие деревья.
• Такие алгоритмы неустойчивы без регуляризации – то, что нужно!
• Обычно используется 𝑛/3 признаков при классификации и √𝑛 признаков
при регрессии в каждой вершине.
• Могут вводиться ограничения на сложность дерева.
Бустинг. Градиентный бустинг.
Идея: использовать взвешенное голосование алгоритмов, добавляя новые
алгоритмы и подбирая их веса по одному.
Бинарная классификация: каждый алгоритм 𝑎𝑗 (𝑥⃗) возвращает класс ±1 или
отказывается от классификации (возвращает 0).
𝑇
𝑎(𝑥⃗) = ∑ 𝛼𝑡 𝑎𝑡 (𝑥⃗)
𝑡=1
𝐿 𝐿 𝑇
1 1
𝑄𝑇 = ∑[𝑎(𝑥⃗𝑖 )𝑦𝑖 < 0] = ∑ [𝑦𝑖 ∑ 𝛼𝑗 𝑎𝑗 (𝑥⃗𝑖 ) < 0] → min
𝐿 𝐿
𝑖=1 𝑖=1 𝑗=1
Алгоритм адаптивного бустинга (AdaBoost)
[𝑀 < 0] ≤ 𝑒𝑥𝑝(−𝑀)
107
𝐿 𝑇 𝐿 𝑇
1 1
𝑄𝑇 = ∑ [𝑦𝑖 ∑ 𝛼𝑗 𝑎𝑗 (𝑥⃗𝑖 ) < 0] ≤ ∑ 𝑒𝑥𝑝 [−𝑦𝑖 ∑ 𝛼𝑗 𝑎𝑗 (𝑥⃗𝑖 )] ≡ 𝑄̃𝑇
𝐿 𝐿
𝑖=1 𝑗=1 𝑖=1 𝑗=1
Пусть первые 𝑇 − 1 алгоритмов 𝑎𝑗 и их веса 𝛼𝑗 уже подобраны.
𝐿 𝑇−1 𝐿
1
𝑄̃𝑇 = ∑ 𝑒𝑥𝑝 [−𝑦𝑖 ∑ 𝛼𝑗 𝑎𝑗 (𝑥⃗𝑖 )] 𝑒 −𝛼𝑇 ∙𝑦𝑖𝑎𝑇 (𝑥⃗𝑖) = ∑ 𝑤𝑖 𝑒 −𝛼𝑇 ∙𝑦𝑖 𝑎𝑇 (𝑥⃗𝑖 )
𝐿
𝑖=1 ⏟ 𝑗=1 𝑖=1
𝑤𝑖
𝐿 𝐿
−𝛼𝑇 𝛼𝑇
=𝑒 ∑ 𝑤𝑖 [𝑦𝑖 𝑎 𝑇 (𝑥⃗) = 1] + 𝑒 ∑ 𝑤𝑖 [𝑦𝑖 𝑎 𝑇 (𝑥⃗) = −1]
⏟
𝑖=1 ⏟
𝑖=1
𝑃𝑤 𝑁𝑤
𝐿
+ ∑ 𝑤𝑖 [𝑦𝑖 𝑎 𝑇 (𝑥⃗) = 0]
⏟
𝑖=1
𝑍𝑤
𝐿 𝐿 𝑇−1
1
𝑃𝑤 + 𝑁𝑤 + 𝑍𝑤 = ∑ 𝑤𝑖 = ∑ 𝑒𝑥𝑝 [−𝑦𝑖 ∑ 𝛼𝑗 𝑎𝑗 (𝑥⃗𝑖 )] = 𝑄̃𝑇−1
𝐿
𝑖=1 𝑖=1 𝑗=1
𝑄̃𝑇 = 𝑃𝑤 𝑒 −𝛼𝑇 + 𝑁𝑤 𝑒 𝛼𝑇 + 𝑍𝑤 → min

𝛼𝑇 ;𝑎𝑇
𝜕𝑄̃𝑇 1 𝑃𝑤
= −𝑃𝑤 𝑒 −𝛼𝑇 + 𝑁𝑤 𝑒 𝛼𝑇 = 0 ⇒ 𝛼 𝑇 = ln
𝜕𝛼 𝑇 2 𝑁𝑤
𝑄̃𝑇 𝑃𝑤 𝑃𝑤 −1⁄2 𝑁𝑤 𝑃𝑤 −1⁄2 𝑍𝑤 𝑃𝑤 𝑁𝑤 𝑃𝑤 𝑁𝑤
= ( ) + ( ) + = 1− − + 2√
𝑄̃𝑇−1 𝑄̃𝑇−1 𝑁𝑤 𝑄̃𝑇−1 𝑁𝑤 𝑄̃𝑇−1 𝑄̃𝑇−1 𝑄̃𝑇−1 𝑄̃𝑇−1 𝑄̃𝑇−1
2
𝑃𝑤 𝑁𝑤
= 1 − (√ −√ ) → min
𝑄̃𝑇−1 𝑄̃𝑇−1 𝛼𝑇
𝑎 𝑇 = arg min(√𝑃𝑤 − √𝑁𝑤 )

𝑎𝑗
Если 𝑍𝑤 = 0, то 𝑎 𝑇 = arg min(𝑁𝑤 )
𝑎𝑗
𝐿 𝑇−1
1
𝑄̃𝑇 = ∑ 𝑒𝑥𝑝 [−𝑦𝑖 ∑ 𝛼𝑗 𝑎𝑗 (𝑥⃗𝑖 )] 𝑒 −𝛼𝑇 ∙𝑦𝑖 𝑎𝑇 (𝑥⃗𝑖 )
𝐿
𝑖=1 ⏟ 𝑗=1
𝑤𝑖
Вес объекта 𝑤𝑖 тем больше, чем меньше его отступ 𝑀𝑖 = 𝑦𝑖 𝑎(𝑥⃗𝑖 ), т.е. чем больше
ошибка всех предыдущих алгоритмов на этом объекте.
Нужно исключать объекты-выбросы, вес которых растет экспоненциально.
108
𝐴: [𝑀 < 0] – пороговая
𝐵: (1 − 𝑀)+ – SVM
𝐶: 𝑒 −𝑀 – экспоненциальная (AdaBoost)
𝐷: (1 − 𝑀)2 – квадратичная (GentleBoost)
𝐸: 𝑙𝑜𝑔2 (1 + 𝑒 −𝑀 ) – логарифмическая
(LogitBoost)
𝐹: exp(−𝑐𝑀(𝑀 + 𝑠)) – гауссовская
(BrownBoost)
Рисунок 9.4 Графики функций потерь
𝑇 𝐿
1
𝑎(𝑥⃗) = ∑ 𝛼𝑗 𝑎𝑗 (𝑥⃗) ; 𝑄𝑇 = ∑ ℒ(𝑎(𝑥⃗𝑖 ), 𝑥⃗𝑖 , 𝑦𝑖 )
𝐿
𝑗=1 𝑖=1
𝐿 𝑇−1
1
𝑄𝑇 = ∑ ℒ ∑ 𝛼𝑗 𝑎𝑗 (𝑥⃗𝑖 ) + 𝛼 𝑇 𝑎 𝑇 (𝑥⃗𝑖 ), 𝑥⃗𝑖 , 𝑦𝑖 → min
𝐿
𝑖=1 ⏟
𝑗=1
( 𝑠𝑇−1,𝑖 )
Вычисляется градиент
𝑔⃗𝑇 = ∇𝑎 ℒ(𝑎(𝑥⃗𝑖 ), 𝑥⃗𝑖 , 𝑦𝑖 )
Подбирается алгоритм
𝐿
Рисунок 9.5 Градиентный бустинг (Gradient 𝑎 𝑇 = arg min ∑(𝑎(𝑥⃗𝑖 ) + 𝑔𝑇,𝑖 )2

Boosting Machine) 𝑎
𝑖=1
Находится
𝐿
𝛼 𝑇 = arg min ∑ ℒ(𝑠𝑇−1,𝑖 + 𝛼 𝑇 𝑎 𝑇 (𝑥⃗𝑖 ), 𝑥⃗𝑖 , 𝑦𝑖 )

𝛼>0
𝑖=1
Стохастический градиентный бустинг (SGB)
Идея: шаги алгоритма выполняются не на всей выборке 𝒳𝑡𝑟𝑎𝑖𝑛 , а на ее случайной
′
подвыборке 𝑥⃗𝑖 ∈ 𝒳𝑡𝑟𝑎𝑖𝑛 ⊂ 𝒳𝑡𝑟𝑎𝑖𝑛 (60-80% выборки).
1. Вычисляется градиент 𝑔⃗𝑇 = ∇𝑎 ℒ(𝑎(𝑥⃗𝑖 ), 𝑥⃗𝑖 , 𝑦𝑖 )
2. Подбирается алгоритм 𝑎 𝑇 = arg min ∑𝐿𝑖=1(𝑎(𝑥⃗𝑖 ) + 𝑔𝑇,𝑖 )2
𝑎
𝐿
3. Находится 𝛼 𝑇 = arg min ∑𝑖=1 ℒ(𝑠𝑇−1,𝑖 + 𝛼 𝑇 𝑎 𝑇 (𝑥⃗𝑖 ), 𝑥⃗𝑖 , 𝑦𝑖 )
𝛼>0
Плюсы:
• уменьшается время обучения;
• возможность работать с выборками большего объема;
• появляются возможности оценок OOB;
• в целом улучшается сходимость и обобщающая способность.
109
Градиентный бустинг над деревьями (XGBoost, eXtreme Gradient Boosting)

Дерево решений представимо в виде
𝑉
𝑎(𝑥⃗, 𝜃⃗) = ∑ 𝜃𝑣 Θ𝑣 (𝑥⃗)

𝑣=1
где 𝑣 – листовая вершина; 𝜃𝑣 – значение в ней; Θ𝑣 Θ𝑣′ = 𝛿(𝑣, 𝑣 ′ ).
𝑉 2 𝑉
𝑎2𝑇 (𝑥⃗, 𝜃⃗ ) = (∑ 𝜃𝑣 Θ𝑣 (𝑥⃗)) = ∑ 𝜃𝑣2 Θ𝑣 (𝑥⃗)

𝑣=1 𝑣=1
Критерий качества выбирается как 𝑄(𝜃⃗) → min
𝐿 𝑉
𝑄(𝜃⃗) = ∑ ℒ(𝑠𝑇−1,𝑖 + 𝛼 𝑇 𝑎 𝑇 (𝑥⃗𝑖 ), 𝑥⃗𝑖 , 𝑦𝑖 ) + 𝜉𝑉

⏟ + 𝜆 ∑ 𝜃𝑣2
𝑖=1 𝐿0 −регуляризация ⏟𝑣=1
𝐿2 −регуляризация
𝑉
𝑎(𝑥⃗, 𝜃⃗) = ∑ 𝜃𝑣 Θ𝑣 (𝑥⃗)

𝑣=1
Разложение в ряд до 2 порядка включительно:
ℎ𝑖 2
ℒ(𝑠𝑇−1,𝑖 + 𝛼 𝑇 𝑎 𝑇 (𝑥⃗𝑖 ), 𝑥⃗𝑖 , 𝑦𝑖 ) = ℒ(𝑠𝑇−1,𝑖 , 𝑥⃗𝑖 , 𝑦𝑖 ) + 𝑔𝑖 𝑎 𝑇 (𝑥⃗, 𝜃⃗) + 𝑎 (𝑥⃗, 𝜃⃗)
2 𝑇
Тогда условие на минимум
𝐿 𝑉
ℎ𝑖 2
𝑄(𝜃⃗) = ∑ [ℒ(𝑠𝑇−1,𝑖 , 𝑥⃗𝑖 , 𝑦𝑖 ) + 𝑔𝑖 𝑎 𝑇 (𝑥⃗, 𝜃⃗) + 𝑎 (𝑥⃗, 𝜃⃗)] + 𝜉𝑉 + 𝜆 ∑ 𝜃𝑣2
2 𝑇
𝑖=1 𝑣=1
𝐿 𝑉 𝑉 𝑉
ℎ𝑖
= ∑ [𝑔𝑖 ∑ 𝜃𝑣 Θ𝑣 (𝑥⃗) + ∑ 𝜃𝑣2 Θ𝑣 (𝑥⃗)] + 𝜉𝑉 + 𝜆 ∑ 𝜃𝑣2
2
𝑖=1 𝑣=1 𝑣=1 𝑣=1
𝐿 𝑉 𝑉
ℎ𝑖 2
= ∑ [∑ ( 𝜃 + 𝑔𝑖 𝜃𝑣 ) Θ𝑣 (𝑥⃗)] + 𝜉𝑉 + 𝜆 ∑ 𝜃𝑣2 → min
2 𝑣
𝑖=1 𝑣=1 𝑣=1
Значения в листах:
∑𝑉𝑣=1 𝑔𝑖 Θ𝑣 (𝑥⃗𝑖 )
𝜃𝑣 = −
2𝜆 + ∑𝑉𝑣=1 ℎ𝑖 Θ𝑣 (𝑥⃗𝑖 )
Условия на Θ𝑣 (𝑥⃗𝑖 ):
𝑉
1 (𝑔𝑖 Θ𝑣 (𝑥⃗𝑖 ))2
− ∑ + 𝜉𝑉 → min
2 2𝜆 + ℎ𝑖 Θ𝑣 (𝑥⃗𝑖 )
𝑣=1
Это критерий для построения дерева.
Сравнение беггинга и бустинга. Нелинейные ансамбли алгоритмов
Беггинг
• Лучше подходит для относительно коротких выборок.
• Легко распараллеливается по отдельным алгоритмам.
110
• “Встроенные” оценки OOB.

• Итоговый алгоритм не интерпретируем.
Бустинг
• Больше подходит для задач со сложной границей классов.
• Алгоритмы подбираются последовательно, но можно распараллеливать
каждый алгоритм в отдельности.
• Итоговый алгоритм не интерпретируем.
Нелинейные ансамбли алгоритмов. Стекинг (stacking)
Идея: обучить ансамбль алгоритмов, и их ответы – метапризнаки подать на
вход метаалгоритму. Основная проблема – формирование подвыборок. Обучение
базовых алгоритмов и метаалгоритма на общих данных приводит к
переобучению.
Блендинг. Классический стекинг. Смесь алгоритмов
1. Обучающая выборка разделяется на 𝒳𝑡𝑟𝑎𝑖𝑛 и 𝒳𝑣𝑎𝑙 .
2. 𝒳𝑡𝑟𝑎𝑖𝑛 разделяется на 𝒳𝑏𝑎𝑠𝑒 и 𝒳𝑚𝑒𝑡𝑎 .
3. Базовые алгоритмы обучаются на 𝒳𝑏𝑎𝑠𝑒 .
4. Метаалгоритм обучается на метапризнаках – результатах работы базовых
алгоритмов на 𝒳𝑚𝑒𝑡𝑎 .
5. Валидация происходит на 𝒳𝑣𝑎𝑙 .
Минус: ни базовые алгоритмы, ни метаалгоритм не обучаются на всей выборке.
Идея: использовать несколько различных способов разделения 𝒳𝑡𝑟𝑎𝑖𝑛 на
𝒳𝑏𝑎𝑠𝑒 ⁄𝒳𝑚𝑒𝑡𝑎 и усреднить результаты. Однако этот способ не дает улучшения
качества на практике.
Классический стекинг
1. Обучающая выборка разделяется на 𝑘 групп объектов.
2. Последовательно выбирается каждая из 𝑘 групп.
3. Базовые алгоритмы обучаются на остальных 𝑘 − 1 группах объектов,
после чего их результаты на выбранной группе подаются на вход
метаалгоритма.
4. После обучения метаалгоритма базовые алгоритмы заново обучаются на
всей выборке.
Минус: метапризнаки на обучении и на тесте
оказываются разными.
Для компенсации этих эффектов добавляют
шум в данные или регуляризацию.
Смесь алгоритмов (Mixture of Experts)
𝑇
𝑎(𝑥⃗) = ∑ 𝑔𝑡 (𝑥⃗, 𝑣⃗𝑡 )𝑎𝑡 (𝑥⃗, 𝜃⃗𝑡 ) Рисунок 9.6 Смесь алгоритмов (Mixture
𝑡=1 of Experts)
111
• Функция компетентности 𝑔𝑡 (𝑥⃗, 𝑣⃗𝑡 ) (gated function).

• Это вероятность описания объекта 𝑥 алгоритмом 𝑎𝑡
• ∑𝑇𝑡=1 𝑔𝑡 (𝑥⃗) = 1; 0 ≤ 𝑔𝑡 (𝑥⃗) ≤ 1
• Требуется определить число моделей 𝑇 и оценить х параметры 𝑣⃗𝑡 , 𝜃⃗𝑡
• Expectation-Maximization итерационно уточняет оценки 𝑣⃗𝑡 и 𝜃⃗.
Jupyter notebook “Сравнение методов машинного обучения”:
https://colab.research.google.com/drive/1uYZV5Fsz0y4o-GSBfsj0rlQCQRsrISKw
112
Лекция №10. Искусcтвенные нейронные сети. Базовые архитектуры и методы

обучения
Модель нейрона Мак-Каллока-Питтса. Ограниченность единственного нейрона
Схема постановки и решения задач обучения с учителем
• Параметры модели 𝜃⃗ оптимизируются для достижения минимума ℒ
Как действовать, если параметрическая модель 𝑎(𝑥⃗, 𝜃⃗) не определена или
чрезвычайно сложна?
Модель нейрона Мак-Каллока-Питтса
Рисунок 10.1 Различные типы нейронов Рисунок 10.2 Модель нейрона Мак-Каллока-
Питтса
https://en.wikipedia.org/wiki/Neuron 𝑎(𝑥⃗) = 𝜑(∑ 𝑥𝑖 𝜃𝑖 )
Ограниченность единственного нейрона
Бинарный классификатор: 𝑎(𝑥⃗) = sgn(∑ 𝑥𝑖 𝜃𝑖 )
• Может описать дизъюнкцию: 𝑥 ∨ 𝑦 = [𝑥 + 𝑦 − 1/2 > 0].
• Может описать конъюнкцию: 𝑥 ∧ 𝑦 = [𝑥 + 𝑦 − 3/2 > 0].
• Может описать отрицание: ¬𝑥 = [−𝑥 + 1/2 > 0].
• Не может описать исключающее ИЛИ.
Можно ввести нелинейность: XOR(𝑥, 𝑦) = [𝑥 + 𝑦 − 2𝑥𝑦 − 1/2 > 0].
Можно ввести 2 слой: XOR(𝑥, 𝑦) = [𝑥 ∨ 𝑦 − 𝑥 ∧ 𝑦 − 1/2 > 0].
113
Любая булева функция – это дизъюнкция конъюнкций. Поэтому двуслойной

сети достаточно для описания всех возможностей.
Полносвязная нейронная сеть прямого распространения. Обучение сети. Метод
обратного распространения
Полносвязная нейронная сеть прямого распространения
• Каждый нейрон соединен со всеми нейронами предыдущего слоя.
• Связи не образуют циклов.
Рисунок 10.3 Полносвязная нейронная сеть прямого распространения

Теоретические возможности не глубоких сетей
Сеть из 2 слоев в пространстве {0; 1} описывает любую функцию.
Сеть из 1 слоя в пространстве ℛ 𝑛 описывает полупространство.
Сеть из 2 слоев в пространстве ℛ 𝑛 описывает выпуклый многогранник.
Сеть из 3 слоев в пространстве ℛ 𝑛 описывает многогранную область достаточно
произвольного вида.
Универсальная теорема аппроксимации: двуслойная нейронная сеть прямой связи
может аппроксимировать любую непрерывную функцию многих переменных с любой
точностью.
Нужны ли более глубокие нейронные сети?
Обучение сети. Метод обратного распространения
Прямой шаг: на основе 𝑥⃗ рассчитывается 𝑎⃗(𝑥⃗) и ℒ(𝑎⃗(𝑥⃗), 𝑥⃗, 𝑦⃗).
Обратный шаг: определить градиент по параметрам ∇𝜃 ℒ(𝑎⃗(𝑥⃗), 𝑥⃗, 𝑦⃗).
114
Рисунок 10.4 Последний слой

𝜕ℒ 𝜕ℒ 𝜕𝛼𝑗 𝜕ℒ 𝜕𝜑𝑙,𝑗 𝜕ℒ ′
= = = 𝜑 𝜑
𝜕𝜃𝑙,𝑖𝑗 𝜕𝛼𝑗 𝜕𝜃𝑙,𝑖𝑗 𝜕𝜑𝑙,𝑗 𝜕𝜃𝑙,𝑖𝑗 𝜕𝜑𝑙,𝑗 𝑙,𝑗 𝑙−1,𝑖
𝜕ℒ 𝜕ℒ ′
= 𝜑𝑙,𝑗 𝜑𝑙−1,𝑖
𝜕𝜃𝑙,𝑖𝑗 𝜕𝜑
⏟ 𝑙,𝑗
𝜖𝑙,𝑗
1 1
Пусть ℒ = 2 ∑𝑚 2 𝑚
𝑗=1(𝑎𝑗 − 𝑦𝑗 ) = 2 ∑𝑗=1(𝜑𝑙,𝑗 − 𝑦𝑗 )
2
Тогда 𝜖𝑙,𝑗 = 𝑎𝑗 − 𝑦𝑗 = 𝜖𝑙,𝑗 имеет смысл ошибки j-го нейрона ℓ-го слоя.
𝜑𝑙−1,𝑖 – значение, выданное предыдущим слой.
Произвольный слой
Рисунок 10.5 Произвольный слой

Ошибка слоя:
𝜕ℒ 𝜕ℒ 𝜕𝜑ℎ,𝑗 ′
𝜖ℎ−1,𝑖 = =∑ = ∑(𝜖ℎ,𝑗 ∙ 𝜑ℎ,𝑗 ) ∙ 𝜃ℎ,𝑖𝑗
𝜕𝜑ℎ−1,𝑖 𝜕𝜑 𝜕𝜑
⏟ ℎ,𝑗 ⏟ ℎ−1,𝑖
𝑗 𝑗
𝜖ℎ,𝑗 ′ ∙𝜃
𝜑ℎ,𝑗 ℎ,𝑖𝑗
Градиент:
𝜕ℒ 𝜕ℒ 𝜕𝜑ℎ,𝑗 ′
= = (𝜖ℎ,𝑗 ∙ 𝜑ℎ,𝑗 ) ∙ 𝜑ℎ−1,𝑖
𝜕𝜃ℎ,𝑖𝑗 𝜕𝜑ℎ,𝑗 𝜕𝜃ℎ,𝑖𝑗
115
Проблемы при обучении нейронных сетей. Выбор функции активации

Проблемы при обучении нейронных сетей
• Переобучение.
• Медленная сходимость.
• Локальные минимумы.
• Затухание и взрыв градиента (vanishing/exploding gradients).
o Пусть значения на h-м слое 𝑥ℎ = 𝜑ℎ (𝑥ℎ−1 𝜃ℎ ) (1 нейрон в слое).
𝜕ℒ 𝜕ℒ 𝜕𝜑𝑙 𝜕𝜑ℎ+1
o = 𝜕𝜑 … 𝜑ℎ′ ∙ 𝑥ℎ−1
𝜕𝜃ℎ 𝑙 𝜕𝜑𝑙−1 𝜕𝜑ℎ
𝜕𝜑𝑘+1 𝜕ℒ
o Если | | > 1, то 𝜕𝜃 → ∞ – взрыв градиента.
𝜕𝜑𝑘 ℎ
o Решение – клиппирование градиента (gradient clipping): если ‖𝑔⃗‖ >
𝑔0 , то 𝑔⃗ ≔ 𝑔⃗ ∙ 𝑔0 ⁄‖𝑔⃗‖.
𝜕𝜑𝑘+1 𝜕ℒ
o Если | | < 1, то 𝜕𝜃 → 0 – – затухание градиента (паралич сети).
𝜕𝜑𝑘 ℎ
o Решение – отказ от сигмоидных функций активации.
Выбор функции активации
• Пороговая функция: 𝜑(𝑥) = [𝑥 ≥ 0].
• Линейная функция: 𝜑(𝑥) = 𝑘𝑥.
1
• Сигмоидная функция: 𝜑(𝑥) = sigmoid(𝑥) ≡ 1+𝑒 −𝑥 .
• Гиперболический тангенс:
2
𝜑(𝑥) = tanh(𝑥) ≡ − 1 = 2sigmoid(2x) − 1.
1 + 𝑒 −2𝑥
• Rectified Linear Unit: 𝜑(𝑥) = ReLU(𝑥) ≡ max (0, 𝑥).
• Различные варианты ReLU
o Leaky ReLU: 𝜑(𝑥) = 𝑥; 𝑥 ≥ 0; 0.01𝑥; 𝑥 < 0.
o Parametric ReLU: 𝜑(𝑥) = 𝑥; 𝑥 ≥ 0; 𝑘𝑥; 𝑥 < 0.
o Gaussian Error Linear Unit (GELU): 𝜑(𝑥) = 𝑥Φ(𝑥)
o Sigmoid Linear Unit (SiLU): 𝜑(𝑥) = 𝑥 sigmoid(𝑥).
o Softplus: 𝜑(𝑥) = ln(1 + 𝑒 𝑥 ).
o Exponential Linear Unit (ELU): 𝜑(𝑥) = 𝑥; 𝑥 ≥ 0; 𝑎(𝑒 𝑥 − 1); 𝑥 < 0
Метод прореживания. Оптимальное прореживание
Проблема: нейроны могут настраиваться друг под друга, компенсируя свои
ошибки на обучающей выборке, что приводит к переобучению.
Идея: отключать часть нейронов с вероятностью p, обучая ансамбль нейронных
сетей и усредняя результат.
https://arxiv.org/abs/1207.0580
116
Рисунок 10.6 Метод прореживания

Прямой Dropout
• На этапе обучения j-й нейрон h-го слоя
o с вероятностью 𝑝 выдает 0.
o с вероятностью 1 − 𝑝 выдает результат 𝜑ℎ,𝑗 (∑ 𝜑ℎ−1,𝑖 𝜃ℎ,𝑖𝑗 )
• На этапе применения j-й нейрон h-го слоя
o выдает результат (1 − 𝑝)𝜑ℎ,𝑗 (∑ 𝜑ℎ−1,𝑖 𝜃ℎ,𝑖𝑗 )
Обратный Dropout
• На этапе обучения j-й нейрон h-го слоя
o с вероятностью 𝑝 выдает 0.
1
o с вероятностью 1 − 𝑝 выдает результат 1−𝑝 𝜑ℎ,𝑗 (∑ 𝜑ℎ−1,𝑖 𝜃ℎ,𝑖𝑗 )
• На этапе применения j-й нейрон h-го слоя
o выдает результат 𝜑ℎ,𝑗 (∑ 𝜑ℎ−1,𝑖 𝜃ℎ,𝑖𝑗 )
Оптимальное прореживание (optimal brain surgery)
Идея: отключать связи между нейронами, которые оказывают малое влияние на
ошибку аппроксимации ℒ(𝜃⃗).
1 𝜕 ℒ 2
В экстремуме: ℒ(𝜃⃗ + ∆𝜃⃗) − ℒ(𝜃⃗) = 2 ∆𝜃⃗ 𝑇 𝐻∆𝜃⃗; 𝐻𝑖𝑗 = 𝜕𝜃 𝜕𝜃
𝑖 𝑗
Обнуление i-го коэффициента модели означает

𝜃𝑖 → 0 ⇒ 𝜃𝑖 + 𝑒⃗𝑖𝑇 ∆𝜃⃗ = 0, где 𝑒𝑖𝑗 = 𝛿(𝑖, 𝑗).
1
Лагранжиан 𝐿𝑖 = ∆𝜃⃗ 𝑇 𝐻∆𝜃⃗ + 𝜆(𝜃𝑖 + 𝑒⃗𝑖𝑇 ∆𝜃⃗).
2
∇∆𝜃⃗⃗ 𝐿𝑖 = ∆𝜃⃗ 𝑇 𝐻 + 𝜆𝑒⃗𝑖 = 0 ⇒ ∆𝜃⃗ = −𝜆𝐻 −1 𝑒⃗𝑖𝑇
𝜃𝑖
𝜃𝑖 + 𝑒⃗𝑖𝑇 ∆𝜃⃗ = 0 ⇒ 𝜃𝑖 − 𝜆𝑒⃗𝑖𝑇 𝐻 −1 𝑒⃗𝑖 = 0 ⇒ 𝜆 =
{𝐻 −1 }𝑖𝑖
𝜃𝑖 𝜃𝑖2
∆𝜃⃗ = − 𝐻 −1 𝑇
𝑒
⃗𝑖 ; 𝑖 = .
{𝐻 −1 }𝑖𝑖 2{𝐻 −1 }𝑖𝑖
Идея: отключать связи между нейронами, которые оказывают малое влияние на
ошибку аппроксимации.
𝜃2𝑖
𝐿𝑖 = 2{𝐻 −1 }
- мера выпуклости функции L по параметру θi.
𝑖𝑖
117
Настраивается модель регрессии, и подбираются все веса 𝜃⃗.

Для каждого i находится минимальное 𝐿𝑖 .
Параметр θi, где 𝑖 = arg min 𝐿𝑖 , отсекается.
𝑖
𝜃
Вектор параметров модели корректируется: 𝜃⃗ ≔ 𝜃⃗ − {𝐻 −1𝑖 } 𝐻 −1 𝑒⃗𝑖𝑇 .
𝑖𝑖
Упрощенная модель не нуждается в обучении.
Можно повторить процедуру несколько раз, пока ошибка не превысит некоторого
порогового значения.
Пакетная нормализация. Начальная инициализация параметров
Стохастический градиентный спуск (stochastic gradient descent) – реализация, в
которой на каждой итерации алгоритма из обучающей выборки какимто (случайным)
образом выбирается только один объект.
Пакетный градиентный спуск (batch gradient descent) – реализация градиентного
спуска, когда на каждой итерации обучающая выборка просматривается целиком, и
только после этого изменяются веса модели.
“Золотая середина” – просматривается только некоторое подмножество
обучающей выборки – минипакет (minibatch) – фиксированного размера (batchsize).
Идея: пронормировать вектор признаков, поступающий на вход некоторого слоя
сети.
Пусть на вход подан mini-batch {𝑥⃗1 , 𝑥⃗2 , … , 𝑥⃗𝑏 } = {𝑥𝑖𝑗 }
𝜇𝑖 = ℳ{𝑥𝑖𝑗 } – математическое ожидание минипакета;
2
𝜎𝑗2 = ℳ {(𝑥𝑖𝑗 − 𝜇𝑖 ) } – дисперсия минипакета;
𝑥𝑖𝑗 − 𝜇𝑖
𝑥norm,𝑖𝑗 = – нормализованные объекты;
2
√𝜎𝑗 + 𝜖
{𝑦𝑖𝑗 = 𝛾𝑗 𝑥norm,𝑖𝑗 + 𝛽𝑗 – сжатие и сдвиг; 𝛽𝑗 и 𝛾𝑗 – обучаемые параметры.
Если положить 𝛽𝑗 = 𝜇𝑖 и 𝛾𝑗 = √𝜎𝑗2 + 𝜖, то это тождественное преобразование:

𝑦𝑖𝑗 = 𝑥𝑖𝑗 .
Начальная инициализация параметров
• 𝜃ℎ,𝑖𝑗 = 0
Все нейроны одинаковы, что плохо.
• 𝜃ℎ,𝑖𝑗 – небольшие случайные величины.
Дисперсия растет как корень из числа нейронов. Хорошо работает только
на небольших архитектурах.
• 𝜃ℎ,𝑖𝑗 = uniform (−1⁄√𝑛 ; 1⁄√𝑛)
Выравнивание дисперсий в разных слоях.
• Послойное обучение нейронов, как линейных моделей на случайной
подвыборке объектов или признаков.
118
• Случайный ортогональный базис.

Светоточные и остаточные нейронные сети
Распознавание рукописных цифр (база данных MNIST)
Классический подход – придумывание
признаков:
1. Центральная симметрия
2. Симметрия по горизонтали
3. Симметрия по вертикали
4. Число областей
5. “Жирность” символа
6. Каждый пиксель изображения
Современный подход – построение Рисунок 10.7 Распознавание рукописных цифр

признаков.
Детали изображения → Фрагменты → Объекты
Сверточные нейронные сети. Предыстория
Рисунок 10.8 Из истории сверточных нейронных сетей

Простые клетки реагируют на прямые линии под разными углами.
Реакция сложных клеток связана с активацией определённого набора простых
клеток.
Операция свертки: https://arxiv.org/abs/1603.07285
119
Рисунок 10.9 Пример свертки матриц 5×5 и 3×3

Фильтрующие матрицы: https://habr.com/ru/post/142818/
Рисунок 10.10 Фильтрующие матрицы

https://towardsdatascience.com/types-of-convolutions-in-deep-learning-
717013397f4d?gi=192ff10cc0ca
Можно сделать отступ (padding)
Рисунок 10.11 Stride=1; padding=1.
120
Можно задать шаг (stride)
Рисунок 10.12 Stride=2; padding=0.

Можно сделать прореживание (dilation rate)
Рисунок 10.13 Dilation rate=2

Объединяющие слои (pooling layer, ранее – subsampling layer)
𝑦𝑖𝑗 = 𝐹𝑎 (𝑥ℎ𝑖,ℎ𝑗 , … , 𝑥ℎ𝑖+ℎ−1,𝑗ℎ+ℎ−1 );
𝐹𝑎 = max(∙) – max pooling;
𝐹𝑎 = avg(∙)– average pooling.
https://en.wikipedia.org/wiki/Convolutional_neural_network
Рисунок 10.14 Pooling layer

Max pooling позволяет распознавать объект вне зависимости от его положения на
картинке.
121
Рисунок 10.15 Типичная архитектура сверточной сети

LeNet (LeCun, Yann; Léon Bottou; Yoshua Bengio; Patrick Haffner, 1998)
http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf
Рисунок 10.16 LeNet – сеть для классификации MNIST

AlexNet (Alex Krizhevsky; Ilya Sutskever; Geoffrey E. Hinton, 2012)
AlexNet– победитель соревнования ImageNet LSVRC2012.
Использование ReLU и dropout в сочетании с обучением на GPU позволило
обучить сеть с 62.3 млн параметрами.
https://papers.nips.cc/paper/2012/file/c399862d3b9d6b76c8436e924a68c45b-
Paper.pdf
Рисунок 10.17 AlexNet

VGG (Alex Krizhevsky; Ilya Sutskever; Geoffrey E. Hinton, 2012)
122
VGG – второе место на соревновании ImageNet LSVRC2014.

Идея: заменить большие свертки на многослойные свертки 3 × 3. Свертка 5 × 5
(25 параметров) → 2 свертки 3 × 3 (18 параметров).
Рисунок 10.18 https://arxiv.org/abs/1409.1556v6,

https://habr.com/ru/company/vk/blog/311706/
Остаточные нейронные сети (Residual Networks )
ResNet-152 – победитель на соревновании ImageNet LSVRC2015.
Идея: чтобы избавиться от затухания градиента в глубокой нейронной сети,
производится обучение “остаткам”: 𝑓(𝑥) + 𝑥 вместо 𝑓(𝑥).
https://arxiv.org/pdf/1512.03385.pdf
Рисунок 10.19 ResNet-152

Обзор нейронных сетей для обработки изображений
Точность растет, но число параметров падает – архитектура сетей изменяется по-
умному!
123
Рисунок 10.20 https://culurciello.github.io/tech/2016/06/04/nets.html

Возможности для улучшения процесса обучения
• Не только уменьшение, но и увеличение lr.
• Аугментация данных для повышения разнообразия при обучении.
• Аугментация данных для большей устойчивости на тесте.
• Transfer learning
Нейронные сети для распознавания цифр
Jupyter notebook “Нейронные сети для распознавания цифр”:
https://colab.research.google.com/drive/1wq-_4AZoAyPecesseJd7d1r0RsNW7dJi
Jupyter notebook “Нейронные сети для распознавания цифр: аугментация”:
https://colab.research.google.com/drive/1_6pQfteUW2uJAPuNts4nCkFj4iD-2Qxb
124
Лекция №11. Нейронные сети для распознавания цифр. Задачи обучения без
учителя. Часть 1
Нейронные сети для распознавания цифр
Jupyter notebook “Нейронные сети для распознавания цифр”:
https://colab.research.google.com/drive/1wq-_4AZoAyPecesseJd7d1r0RsNW7dJi
1. Загрузка и предварительная обработка данных
За основу берется набор данных SVHN - это фотографии номеров домов на
улицах. Требуется распознавать цифры на них.
import numpy as np
import scipy.io as io
import os
import warnings
from sklearn.metrics import accuracy_score, f1_score, precisio

n_score, recall_score
!mkdir data
!wget -
c http://ufldl.stanford.edu/housenumbers/train_32x32.mat http:
//ufldl.stanford.edu/housenumbers/test_32x32.mat -P data
Функции для чтения .mat файлов и загрузки содержимого в переменные

def load_data_mat(filename, max_samples, seed=42):
raw = io.loadmat(filename)
X = raw['X'] # Array of [32, 32, 3, n_samples]
125
y = raw['y'] # Array of [n_samples, 1]

X = np.moveaxis(X, [3], [0])
y = y.flatten()
# Fix up class 0 to be 0
y[y == 10] = 0
np.random.seed(seed)
samples = np.random.choice(np.arange(X.shape[0]),
max_samples,
replace=False)
return X[samples].astype(np.float32), y[samples]
def load_svhn(folder, max_train, max_test):

train_X, train_y = load_data_mat(os.path.join(folder, "tra
in_32x32.mat"), max_train)
test_X, test_y = load_data_mat(os.path.join(folder, "test_
32x32.mat"), max_test)
return train_X, train_y, test_X, test_y
Загружаем данные и отображаем несколько изображений каждого из классов
train_X, train_y, test_X, test_y = load_svhn("data", max_train
=1000, max_test=100)
images_in_column = 5
fig, axs = plt.subplots(nrows=images_in_column, ncols=10)

for c in range(10):
for r in range(images_in_column):
image = train_X[train_y == c][r]
axs[r,c].imshow(image.astype(np.uint8))
axs[r,c].axis('off')
2. Бинарная классификация. Классические алгоритмы

Будем использовать несколько разных классификаторов, чтобы решить задачу
определения каждой из цифр по отдельности
126
from sklearn.linear_model import LogisticRegression, RidgeClas

sifier#, LassoClassifier
from sklearn.neighbors import KNeighborsClassifier

from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientB

oostingClassifier, AdaBoostClassifier
from xgboost import XGBClassifier
# Подавляем ошибки, чтобы они не портили таблицу результатов

from sklearn.exceptions import ConvergenceWarning
from scipy.linalg import LinAlgWarning
warnings.filterwarnings('ignore', category=ConvergenceWarning)
warnings.filterwarnings('ignore', category=LinAlgWarning)
cl_train_X = train_X.reshape((train_X.shape[0],-1))
cl_test_X = test_X.reshape((test_X.shape[0],-1))
cl_train_X = (cl_train_X-
np.mean(cl_train_X))/np.std(cl_train_X)
cl_test_X = (cl_test_X -np.mean(cl_test_X))/np.std(cl_test_X)
def get_classifier_f1(classifier):
results = []
for selected_class in range(10):
# Обучение классификатора
classifier.fit(cl_train_X, train_y==selected_class)
# Вычисление предсказаний классов

predictions = classifier.predict(cl_test_X)
results.append(f1_score(predictions, test_y==selected_cl
ass))
return results
classifiers = {
"Linear" : LogisticRegression(),
"Ridge" : RidgeClassifier(),
"l1" : None,
"KNN(1)" : KNeighborsClassifier(n_neighbors=1),
127
"l2" : None,
"DT(default)" : DecisionTreeClassifier(random_state=0),
"DT(depth=4)" : DecisionTreeClassifier(random_state=0, max
_depth=4),
"DT(depth=6)" : DecisionTreeClassifier(random_state=0, max
_depth=6),
"DT(leaf=4)" : DecisionTreeClassifier(random_state=0, min
_samples_leaf=4),
"DT(leaf=10)" : DecisionTreeClassifier(random_state=0, min
_samples_leaf=10),
"l3" : None,
"SVC(linear)" : SVC(C=1.0, kernel='linear'),

"SVC(poly=3)" : SVC(C=1.0, kernel='poly', degree=3),
"SVC(sigmoid)": SVC(C=1.0, kernel='sigmoid'),
"SVC(rbf)" : SVC(C=1.0, kernel='rbf'),
"SVC(rbf, C=2)" : SVC(C=2.0, kernel='rbf'),
"SVC(rbf, C=0.5)" : SVC(C=0.5, kernel='rbf'),
"l4" : None,
"RF(default)" : RandomForestClassifier(random_state=0),
"RF(depth=4)" : RandomForestClassifier(random_state=0, max
_depth=4),
"RF(depth=6)" : RandomForestClassifier(random_state=0, max
_depth=6),
"RF(leaf=4)" : RandomForestClassifier(random_state=0, min
_samples_leaf=4),
"RF(leaf=10)" : RandomForestClassifier(random_state=0, min
_samples_leaf=10),
"l5" : None,
"AdaBoost" : AdaBoostClassifier(),
"GBG" : GradientBoostingClassifier(),
"XGB" : XGBClassifier(),
}
128
np.seterr(all="ignore")
print(" "*20 + "|".join([" #{:2d} ".format(selected_class)

for selected_class in range(10)]) + "| Mean")
for name, classifier in classifiers.items():
if(classifier is None):
print("-"*(20+16+16*10))
else:
f1 = get_classifier_f1(classifier)
print("{:20s}".format(name) + "|".join(["{:6.3f} ".forma
t(res) for res in f1]) + "| {:6.3f}".format(np.mean(f1)))
3. Применение нейронных сетей и PyTorch

3.1. Подготовка к обучению
Импорт библиотек PyTorch
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as dset
from torch.utils.data.sampler import SubsetRandomSampler, Samp
ler
from torchvision import transforms

Вначале будем считать на обычном процессоре
cpu = torch.device("cpu")
device = cpu
129
Загрузка данных: PyTorch поддерживает SVHN. К данным сразу же применяется

нормировка.
# Преобразование - нормировка
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(
mean=[0.43,0.44,0.47],
std=[0.20,0.20,0.20])
])
data_train = dset.SVHN('./data/', split='train', transform=tra

nsform)
data_test = dset.SVHN('./data/', split='test', transform=trans
form)
Данные разделяются на тренировочные и валидационные. Для каждой
подвыборки создается экземпляр DataLoader - класса, который отвечает за загрузку
данных и их разбитие по пакетам при обучении.
https://pytorch.org/tutorials/beginner/data_loading_tutorial.html
batch_size = 64 # Размер пакета
validation_split = .2 # Часть выборки, которая отводится н
а валидацию
# Создаются и перемешиваются индексы объектов

data_size = data_train.data.shape[0]
split = int(np.floor(validation_split * data_size))
indices = list(range(data_size))
np.random.shuffle(indices)
# Вычисляются индексы объектов для тренировки и для валидации

train_indices, val_indices = indices[split:], indices[:split]
# Создаются 'семплеры'
train_sampler = SubsetRandomSampler(train_indices)
val_sampler = SubsetRandomSampler(val_indices)
# Создаются загрузчики данных

train_loader = torch.utils.data.DataLoader(data_train, batch_
size=batch_size, sampler=train_sampler)
val_loader = torch.utils.data.DataLoader(data_train, batch_
size=batch_size, sampler=val_sampler)
Теперь создается функция, которая отвечает за тренировку модели
def train_model(model, train_loader, val_loader, loss, optimiz
er, num_epochs, device):
loss_history = []
130
train_history = []
val_history = []
# Модель обучается в несколько эпох, т.е. проходов по всей

выборке
for epoch in range(num_epochs):
# Переводим модель в режим обучения
model.train()
loss_accum = 0
correct_samples = 0
total_samples = 0
# По очереди выбираем пакеты объектов

for i_step, (x, y) in enumerate(train_loader):
x_gpu = x.to(device)
y_gpu = y.to(device)
# Прямой проход:
# 1. вычисляем предсказание для каждого объекта (н
а самом деле - это сразу целый пакет)
prediction = model(x_gpu)
# 2. Вычисляем функцию ошибки
loss_value = loss(prediction, y_gpu)
# Обратный проход:
# 1. Сбрасываем значение градиентов
optimizer.zero_grad()
# 2. Вычисляем новые значения градиентов
loss_value.backward()
# 3. Обновляем параметры
optimizer.step()
# Рассчитывается класс с максимальной вероятностью

_, indices = torch.max(prediction, 1)
# Суммируем число правильно определенных объектов

и общее число объектов
correct_samples += torch.sum(indices == y_gpu)
total_samples += y.shape[0]
loss_accum += loss_value
# Рассчитывается accuracy на тренировке и на валидации

average_loss = loss_accum / (i_step + 1)
131
train_accuracy = float(correct_samples) / total_sample

s
val_accuracy = compute_accuracy(model, val_loader, dev
ice)
loss_history.append(float(average_loss))
train_history.append(train_accuracy)
val_history.append(val_accuracy)
print("Average loss: %f, Train accuracy: %f, Val accur

acy: %f" % (average_loss, train_accuracy, val_accuracy))
return loss_history, train_history, val_history
def compute_accuracy(model, loader, device):

"""
Computes accuracy on the dataset wrapped in a loader
Returns: accuracy as a float value between 0 and 1

"""
model.eval()
correct_samples = 0
total_samples = 0
for i_step, (x, y) in enumerate(loader):
pred = torch.argmax(prediction, axis=1);
correct_samples += torch.sum(pred == y_gpu).item()
total_samples += pred.size(0)
return correct_samples/total_samples
И еще функция, которая выдает f1-метрику для каждого класса, плюс среднюю
f1-метрику по всем классам
test_loader = torch.utils.data.DataLoader(data_test, batch_siz
e=batch_size)
def get_nn_f1(model, device):

model.eval()
correct_results = np.array([])
model_results = np.array([])
correct_samples = 0
total_samples = 0
132
for i_step, (x, y) in enumerate(test_loader):

correct_results = np.append(correct_results, y)
model_results = np.append(model_results, pred.to(cpu))

results = [0]*10
for n in range(10):
results[n] = f1_score(correct_results==n, model_results=
=n)
print(" "*20 + "|".join([" #{:2d} ".format(selected_cl

ass) for selected_class in range(10)]) + "| Mean")
print("{:20s}".format("NN") + "|".join(["{:6.3f} ".forma
t(res) for res in results]) + "| {:6.3f}".format(np.mean(resul
ts)))
print("Test accuracy={:.2f}".format(correct_samples/total_
samples))
Каждый объект представлен тензором размера 3×32×32
sample, label = data_train[0]
print(sample.shape)
torch.Size([3, 32, 32])
Создается специальный простой класс Flattener для преобразования тензора в
вектор
class Flattener(nn.Module):
def forward(self, x):
batch_size, *_ = x.shape
return x.view(batch_size, -1)
3.2. Простая нейронная сеть
Создаем нейронную сеть, задаем оптимизатор (SGD) и функцию потерь
(перекрестная энтропия). Считать будем на обычном процессоре.
nn_model = nn.Sequential(
Flattener(),
nn.Linear(3*32*32, 100),
nn.ReLU(inplace=True),
nn.Linear(100, 10),
)
133
nn_model.type(torch.FloatTensor)
loss = nn.CrossEntropyLoss().type(torch.FloatTensor)
optimizer = optim.SGD(nn_model.parameters(), lr=1e-
2, weight_decay=1e-1)
loss_history, train_history, val_history = train_model(nn_mode

l, train_loader, val_loader, loss, optimizer, 3, cpu)
get_nn_f1(nn_model, cpu)
Теперь то же самое посчитаем на GPU

if torch.cuda.is_available():
cuda = torch.device("cuda:0")
model_type = torch.cuda.FloatTensor
else:
cuda=cpu
model_type = torch.FloatTensor
Flattener(),
nn.Linear(3*32*32, 100),
nn.Linear(100, 10),
)
nn_model.type(model_type)
nn_model.to(cuda)
loss = nn.CrossEntropyLoss().type(model_type)

l, train_loader, val_loader, loss, optimizer, 3, cuda)
get_nn_f1(nn_model, cuda)
Усложним модель, добавив скрытый слой
Flattener(),
nn.Linear(3*32*32, 100),
nn.Linear(100, 100),
nn.Linear(100, 10),
134
)
nn_model.to(cuda)

3.3. Сеть с batch normalization

Добавим пакетную нормализацию. Сеть обучается плохо. Почему?
Flattener(),
nn.Linear(3*32*32, 100),
nn.BatchNorm1d(100),
nn.Linear(100, 10),
)
nn_model.to(cuda)

135
Увеличим число нейронов в каждом слое до 200;

Введем еще несколько новых слоев
Обучать будем с помощью Adam
Flattener(),
nn.Linear(3*32*32, 200),
nn.Linear(200, 10),
)
nn_model.to(cuda)
optimizer = optim.Adam(nn_model.parameters(), lr=0.1, weight_d
ecay=0e-1, betas=(0.9, 0.999))

# Результаты
136
# Отображаем кривые обучения

plt.figure(figsize=(15, 7))
plt.subplot(211)
plt.title("Loss")
plt.plot(loss_history)
plt.subplot(212)
plt.title("Train/validation accuracy")
plt.plot(train_history)
plt.plot(val_history)
plt.show()
……
3.4. Сверточные сети

Используется двумерная свертка
Используется max-pooling
nn.Conv2d(3, 64, 3, padding=1),
nn.MaxPool2d(4),
nn.Conv2d(64, 64, 3, padding=1),

nn.MaxPool2d(4),
137
Flattener(),
nn.Linear(64*2*2, 10),
)
nn_model.to(cuda)
optimizer = optim.Adam(nn_model.parameters(), lr=1e-
3, weight_decay=1e-4, betas=(0.9, 0.999))


plt.subplot(211)
plt.title("Loss")
plt.subplot(212)
plt.show()
…..
138
3.5. Реализация LeNet

lenet_model = nn.Sequential(
nn.Conv2d(3, 6, kernel_size=5, stride=1, padding=0),
nn.MaxPool2d(kernel_size=2, stride=2, padding=0),

Flattener(),
nn.Linear(120, 84),
nn.Linear(84, 10),
)
lenet_model.type(model_type)
lenet_model.to(cuda)
#optimizer = optim.Adam(lenet_model.parameters(), lr=1e-
3, weight_decay=1e-4, betas=(0.9, 0.999))
optimizer = optim.SGD(lenet_model.parameters(), lr=1e-
139
loss_history, train_history, val_history = train_model(lenet_m

odel, train_loader, val_loader, loss, optimizer, 20, cuda)
get_nn_f1(lenet_model, cuda)

plt.subplot(211)
plt.title("Loss")
plt.subplot(212)
plt.show()
...
Нейронные сети для распознавания цифр: аугментация

1. Подключение библиотек и загрузка данных
За основу берется набор данных SVHN - это фотографии номеров домов на
улицах. Требуется распознавать цифры на них.
import numpy as np
import scipy.io as io
import os
import warnings
from sklearn.metrics import accuracy_score, f1_score, precisio

n_score, recall_score
import torch
140
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as dset
from torch.utils.data.sampler import SubsetRandomSampler, Samp
ler, SequentialSampler
from torchvision import transforms
!mkdir data
!wget -
c http://ufldl.stanford.edu/housenumbers/train_32x32.mat http:
//ufldl.stanford.edu/housenumbers/test_32x32.mat -P data
Если доступно GPU, будем считать на нем. Иначе - на обычном процессоре

cpu = torch.device("cpu")
if torch.cuda.is_available():
device = torch.device("cuda:0")
model_type = torch.cuda.FloatTensor
else:
device=cpu
model_type = torch.FloatTensor
Загрузка данных: PyTorch поддерживает SVHN. К данным сразу же применяется
нормировка.
# Преобразование - нормировка
transform = transforms.Compose([
transforms.Normalize(
141
mean=[0.43,0.44,0.47],
std=[0.20,0.20,0.20])
])
data_train = dset.SVHN('./data/', split='train', transform=tra

nsform)
data_test = dset.SVHN('./data/', split='test', transform=trans
form)
Данные разделяются на тренировочные и валидационные. Для каждой
подвыборки создается экземпляр DataLoader - класса, который отвечает за загрузку
данных и их разбитие по пакетам при обучении.
https://pytorch.org/tutorials/beginner/data_loading_tutorial.html
batch_size = 64 # Размер пакета
validation_split = .2 # Часть выборки, которая отводится н
а валидацию
# Создаются и перемешиваются индексы объектов

data_size = data_train.data.shape[0]
split = int(np.floor(validation_split * data_size))
indices = list(range(data_size))
np.random.shuffle(indices)
# Вычисляются индексы объектов для тренировки и для валидации

train_indices, val_indices = indices[split:], indices[:split]
# Создаются 'семплеры'
train_sampler = SubsetRandomSampler(train_indices)
val_sampler = SubsetRandomSampler(val_indices)
# Создаются загрузчики данных

train_loader = torch.utils.data.DataLoader(data_train, batch_
size=batch_size, sampler=train_sampler)
val_loader = torch.utils.data.DataLoader(data_train, batch_
size=batch_size, sampler=val_sampler)
Теперь создается функция, которая отвечает за тренировку модели
def train_model(model, train_loader, val_loader, loss, optimiz
er, num_epochs, device):
loss_history = []
train_history = []
val_history = []
# Модель обучается в несколько эпох, т.е. проходов по всей

выборке
for epoch in range(num_epochs):
142
# Переводим модель в режим обучения

model.train()
loss_accum = 0
correct_samples = 0
total_samples = 0
# По очереди выбираем пакеты объектов

for i_step, (x, y) in enumerate(train_loader):
# Прямой проход:
# 1. вычисляем предсказание для каждого объекта (н
а самом деле - это сразу целый пакет)
# 2. Вычисляем функцию ошибки
loss_value = loss(prediction, y_gpu)
# Обратный проход:
# 1. Сбрасываем значение градиентов
optimizer.zero_grad()
# 2. Вычисляем новые значения градиентов
loss_value.backward()
# 3. Обновляем параметры
optimizer.step()
# Рассчитывается класс с максимальной вероятностью

_, indices = torch.max(prediction, 1)
# Суммируем число правильно определенных объектов

и общее число объектов
correct_samples += torch.sum(indices == y_gpu)
total_samples += y.shape[0]
loss_accum += loss_value
# Рассчитывается accuracy на тренировке и на валидации

average_loss = loss_accum / (i_step + 1)
train_accuracy = float(correct_samples) / total_sample
s
val_accuracy = compute_accuracy(model, val_loader, dev
ice)
loss_history.append(float(average_loss))
train_history.append(train_accuracy)
143
val_history.append(val_accuracy)
print("Average loss: %f, Train accuracy: %f, Val accur

acy: %f" % (average_loss, train_accuracy, val_accuracy))
return loss_history, train_history, val_history
def compute_accuracy(model, loader, device):

"""
Computes accuracy on the dataset wrapped in a loader
Returns: accuracy as a float value between 0 and 1

"""
model.eval()
correct_samples = 0
total_samples = 0
return correct_samples/total_samples
И еще функция, которая выдает f1-метрику для каждого класса, плюс среднюю
f1-метрику по всем классам
test_loader = torch.utils.data.DataLoader(data_test, batch_siz
e=batch_size)
def get_nn_f1(model, device):

model.eval()
correct_results = np.array([])
model_results = np.array([])
correct_samples = 0
total_samples = 0
for i_step, (x, y) in enumerate(test_loader):

144
correct_results = np.append(correct_results, y)
model_results = np.append(model_results, pred.to(cpu))

results = [0]*10
for n in range(10):
results[n] = f1_score(correct_results==n, model_results=
=n)
print(" "*20 + "|".join([" #{:2d} ".format(selected_cl

ass) for selected_class in range(10)]) + "| Mean")
print("{:20s}".format("NN") + "|".join(["{:6.3f} ".forma
t(res) for res in results]) + "| {:6.3f}".format(np.mean(resul
ts)))
print("Test accuracy={:.2f}".format(correct_samples/total_
samples))
Создается специальный простой класс Flattener для преобразования тензора в
вектор
class Flattener(nn.Module):
def forward(self, x):
batch_size, *_ = x.shape
return x.view(batch_size, -1)
2. Реализация LeNet
lenet_model = nn.Sequential(

Flattener(),
nn.Linear(120, 84),
nn.Linear(84, 10),
)
145
lenet_model.type(model_type)
lenet_model.to(device)
loss_history, train_history, val_history = train_model(lenet_m
odel, train_loader, val_loader, loss, optimizer, 20, device)
get_nn_f1(lenet_model, device)

plt.subplot(211)
plt.title("Loss")
plt.subplot(212)
plt.show()
3. Аугментация данных
Применим различные трансформации данных и посмотрим на результат.
data_transform = transforms.Compose([
transforms.ColorJitter(hue=.50, saturation=.5
0),
transforms.RandomInvert(),
transforms.GaussianBlur(kernel_size=3),
146
transforms.RandomAdjustSharpness(sharpness_fa
ctor=2),
transforms.RandomRotation(20, interpolation=t
ransforms.InterpolationMode.BILINEAR),
transforms.Normalize(mean=[0.43,0.44,0.47],
std=[0.20,0.20,0.20])]
)
LeNet с аугментацией
4, weight_decay=5e-4);
for aug in range(25):
print("Aug=", aug)
data_aug_train = dset.SVHN('./data/', split='train', transfo
rm=data_transform)
train_aug_loader = torch.utils.data.DataLoader(data_aug_trai
n, batch_size=batch_size, sampler=train_sampler)
loss_history, train_history, val_history = train_model(lenet
_model, train_aug_loader, val_loader, loss, optimizer, 2, devi
ce);
get_nn_f1(lenet_model, device)
Получили +1% к accuracy!

Теперь попробуем применить аугментацию на тестовых данных
def augmentation_at_test(model, device, split, transform, augs
):
model.eval()
data = dset.SVHN('./data/', split=split)

results = torch.zeros((len(data), augs)).to(device)
correct = np.zeros((len(data)))
for aug in range(augs):

data = dset.SVHN('./data/', split=split, transform=transfo
rm)
loader = torch.utils.data.DataLoader(data, batch_size=batc
h_size)
147

results[i_step*batch_size:(i_step+1)*batch_size, aug] =
pred
correct[i_step*batch_size:(i_step+1)*batch_size] = y
result = torch.mode(results)[0].to(cpu)
return accuracy_score(result, correct)
augmentation_at_test(lenet_model, device=device, split='test',

transform=data_transform, augs=10)


За счет аугментации на тесте удается добиться accuracy 90%

Нейронные сети в задачах обучения без учителя
Задачи, которые решаются без привлечения учителя:
1. Кластеризация – разбиение выборки на непересекающиеся множества
(кластеры) похожих объектов так, что объекты разных кластеров сильно
отличаются.
2. Обнаружение аномалий – выделение данных, сильно отличающихся от
типичных.
3. Сокращение размерности – представление исходных данных с большим
количеством признаков в пространстве меньшей размерности с
минимальными потерями информации.
4. Визуализация – преобразование данных для наглядного изображения их на
плоскости.
Схема постановки задачи кластеризации
Имеется выборка 𝕏 из L объектов,
• каждый из которых задан вектором признаков 𝑥⃗,
• или определена функция расстояния между объектами 𝜌(𝑥⃗𝑖 , 𝑥⃗𝑗 ).
148
Требуется определить для каждого объекта его кластер 𝑦(𝑥⃗) так, чтобы объекты
в одном кластере оказались похожими, а объекты в разных кластерах – отличались.
Существует много разных постановок задачи для определения “сходства” и
“различия” объектов.
1. Имеется выборка 𝕏 из L объектов
2. Определена функция расстояния 𝜌(𝑥⃗𝑖 , 𝑥⃗𝑗 )
3. Задано число кластеров.
Требуется определить центры кластеров 𝜃⃗𝑦 и отнести каждый объект к кластеру
с ближайшим центром (принцип жесткой конкуренции):
𝑎(𝑥⃗) = arg min 𝜌(𝑥⃗, 𝜃⃗𝑦 )
𝑦
Средний квадрат внутрикластерного расстояния минимален:
𝐿
1
𝑄(𝜃⃗) = ∑ 𝜌2 (𝑥⃗𝑖 , 𝜃⃗𝑎(𝑥⃗𝑖 ) ) → min
𝐿
𝑖=1
Разделительная кластеризация (k-means)
Принцип жесткой конкуренции
Пусть векторы 𝑥⃗ и 𝜃⃗ – нормированные.
Минимум расстояния в евклидовой метрике: 𝜌(𝑥⃗, 𝜃⃗ ) = (𝑥⃗ − 𝜃⃗)2 .
Двуслойная нейронная сеть:
1 слой – вычисление расстояний 𝜌(𝑥⃗, 𝜃⃗);
2 слой – 𝑎(𝑥⃗) = arg max 𝜌(𝑥⃗, 𝜃⃗𝑦 )
𝑦
Обучение методом градиентного спуска: 𝜃⃗𝑦 ≔ 𝜃⃗𝑦 + 𝑙𝑟 ∙ (𝑥⃗𝑖 − 𝜃⃗𝑦 )[𝑎(𝑥⃗𝑖 ) = 𝑦]

На каждом шаге центр кластера сдвигается ближе к элементу 𝑥⃗𝑖 из этого кластера.
Недостатки: обучение может происходить медленно, а некоторые кластеры могут
не обновляться, т.к. в них не попали объекты.
Принцип мягкой конкуренции
Идея: ввести функцию ядра 𝐾(𝜌) и проводить обучение по центрам всех
кластеров, а не только одного ближайшего.
Пусть векторы 𝑥⃗ и 𝜃⃗ – нормированные.
Минимум расстояния в евклидовой метрике: 𝜌(𝑥⃗, 𝜃⃗ ) = (𝑥⃗ − 𝜃⃗)2 .
Двуслойная нейронная сеть:
1 слой – вычисление расстояний 𝜌(𝑥⃗, 𝜃⃗);
2 слой – степени близости объекта к каждому из кластеров 𝑎𝑦 (𝑥⃗) =
𝐾 (𝜌(𝑥⃗, 𝜃⃗𝑦 )).
Обучение методом градиентного спуска: 𝜃⃗𝑦 ≔ 𝜃⃗𝑦 + 𝑙𝑟 ∙ (𝑥⃗𝑖 − 𝜃⃗𝑦 )𝐾 (𝜌(𝑥⃗𝑖 , 𝜃⃗𝑦 ))
149
На каждом шаге центры всех кластеров сдвигаются ближе к элементу 𝑥⃗𝑖 в

зависимости от удаления до него.
G-means
Недостаток подхода k-means – Необходимость задать число кластеров.
Идея: предположим, что кластеризуемые данные подчиняются некоторому
унимодальному закону распределения, например гауссовскому.
1. Если исходные данные описываются унимодальным гауссовским
распределением с заданными средним, то можно предположить, что все они
относятся к одному кластеру.
2. Если распределение данных не гауссовское, то выполняется разделение на два
кластера. Если в этих кластерах распределения окажутся близки к
гауссовскому, то число кластеров считается оптимальным.
3. В противном случае число кластеров увеличивается, и процесс повторяется.
150
Лекция №12. Задачи обучения без учителя. Часть 2

Схема постановки задачи сокращения размерности. Автокодировщики
Имеется выборка 𝕏 из 𝐿 объектов.
Задается функционал качества 𝐿(𝑎⃗, 𝑥⃗), характеризующий, насколько хорошо
алгоритм 𝛼⃗ аппроксимирует исходный объект 𝑥⃗.
Выбирается параметрическая модель 𝑎⃗(𝑥⃗, 𝛼⃗, 𝛽⃗ ) = 𝑔(𝑓(𝑥⃗, 𝛼⃗), 𝛽⃗ )
Функция кодировщика 𝑓 : 𝕏 → 𝕐.
Функция декодировщика 𝑔 : 𝕐 → 𝕏.
Пространство 𝕐 обладает полезными свойствами, например, имеет меньшую
размерность по сравнению с 𝕏.
Параметры модели 𝛼⃗, 𝛽⃗ оптимизируются для достижения минимума
Параметры модели 𝜃⃗ оптимизируются для достижения минимума
𝐿
1
𝑄𝐴𝐸 (𝛼⃗, 𝛽⃗ ) = ∑ 𝐿(𝑔(𝑓(𝑥⃗, 𝛼⃗), 𝛽⃗ ), 𝑥⃗)
𝐿
𝑖=1
Линейный автокодировщик
Кодировщик 𝑓(𝑥⃗, 𝐀) = 𝐀 [𝑚×𝑛] 𝑥⃗; 𝑥⃗ ∈ ℛ 𝑛 .
Декодировщик 𝑔(𝑦⃗, 𝐁) = 𝐁[𝑛×𝑚] 𝑦⃗; 𝑦⃗ ∈ ℛ 𝑚 .
Квадратичная функция потерь: 𝐿(𝑎⃗, 𝑥⃗) = ‖𝑎⃗ − 𝑥⃗‖2 =.
Задача линейного автокодировщика:
𝐿
1
𝑄𝐴𝐸 (𝐀, 𝐁) = ∑‖𝐁𝐀𝑥⃗𝑖 − 𝑥⃗𝑖 ‖2 → min
𝐿
𝑖=1
Метод главных компонент
Для матрицы 𝒳[𝐿×𝑛] строится матрица (𝒳 𝑇 𝒳)[𝑛×𝑛]
У нее отбираются m наибольших собственных значений 𝜆1 , . . . , 𝜆𝑚
Соответствующие собственные векторы формируют матрицу 𝑈[𝑛×𝑚]
𝑈 – матрица перехода между n-мерным и m-мерным признаковыми
пространствами.
Новые признаки вычисляются как 𝐺[𝐿×𝑚] = 𝒳𝑈
Матрица 𝑈 ортонормирована: 𝑈 𝑇 𝑈 = 𝐼[𝑚×𝑚]
𝒳 ≈ 𝐺𝑈 𝑇
Линейный автокодировщик – обобщение метода главных компонент
Задача линейного автокодировщика:
𝐿
1
𝑄𝐴𝐸 (𝐀, 𝐁) = ∑‖𝐁𝐀𝑥⃗𝑖 − 𝑥⃗𝑖 ‖2 → min
𝐿 𝐀,𝐁
𝑖=1
Задача метода главных компонент:
151
𝐿
1 1
𝑄PCA (𝐔) = ‖𝐆𝐔𝑇 − 𝒳‖2 = ∑‖𝐔𝐔𝑇 𝑥⃗𝑖 − 𝑥⃗𝑖 ‖2 → min
𝐿 𝐿 𝐔
𝑖=1
Двуслойная нейросеть
Кодировщик 𝑓⃗(𝑥⃗, 𝐀) = 𝜎⃗𝑓 (𝐀𝑥⃗); 𝑥⃗ ∈ ℛ 𝑛 ;
Декодировщик 𝑔⃗(𝑦⃗, 𝐁) = 𝜎⃗𝑔 (𝐁𝑦⃗); 𝑦⃗ ∈ ℛ 𝑚 ;
𝜎⃗𝑓 , 𝜎⃗𝑔 – функции активации слоев нейросети.
1
𝑄𝐴𝐸 (𝐀, 𝐁) = (𝜎⃗𝑔 (𝐁𝜎⃗𝑓 (𝐀𝑥⃗𝑖 ))𝑥⃗𝑖 − 𝑥⃗𝑖 )2 → min
𝐿 𝐀,𝐁
Применение автокодировщиков
Рисунок 12.1 Кодировщик и декодировщик, на картинке справа декодировщик

отбрасывается, m<n
Сжатие данных при их хранении или передаче.
Генерация признаков.
Снижение размерности.
Векторизация объектов.
Подготовка для решения задач обучения с учителем.
Генерация новых объектов.
Рисунок 12.2 Решение задач обучения с учителем
Рисунок 12.3 Генерация новых объектов.
152
Рисунок 12.4 Применение автокодировщиков в задачах обучения с учителем

Данные “от учителя” дополняют автокодировщик.
“Обычная” нейросеть – это “скрытый автокодировщик”.
Transfer learning – обучение “скрытого автокодировщика”.
Многозадачное обучение (multitask learning) – обучение общей части модели на
широкой совокупности большого числа задач.
Архитектуры автокодировщиков. Самообучение
Рисунок 12.5 Автокодировщик со снижением размерности

𝐿
1
𝑄𝐴𝐸 (𝛼⃗, 𝛽⃗ ) = ∑ ℒ(𝑔(𝑓(𝑥⃗𝑖 , 𝛼⃗), 𝛽⃗ ), 𝑥⃗𝑖 ) → min
𝐿 ⃗⃗⃗
⃗⃗,𝛽
𝛼
𝑖=1
Рисунок 12.6 https://habr.com/ru/post/331382/
Рисунок 12.7 Разреживающий автокодировщик (Sparse autoencoder)
153
𝐿 𝑚
𝑄𝐴𝐸 (𝛼⃗, 𝛽⃗ ) + 𝜆 ∑ ∑|𝑓𝑖 (𝑥⃗𝑖 , 𝛼⃗)| → min

⃗⃗⃗
⃗⃗,𝛽
𝛼
⏟𝑖=1 𝑗=1
𝐿1 −регуляризация
𝑚 𝐿
1
𝑄𝐴𝐸 (𝛼⃗, 𝛽⃗ ) + ∑ 𝐷KL (𝜖|| ∑ 𝑓𝑖 (𝑥⃗𝑖 , 𝛼⃗)) → min
𝐿 ⃗⃗⃗
⃗⃗,𝛽
𝛼
𝑗=1 𝑖=1
𝑎 1−𝑎
𝐷KL (𝑎, 𝑏) = 𝑎 ln + (1 − 𝑎) ln − расхождение Кульбака − Лейблера.
𝑏 1−𝑏
Рисунок 12.8 Шумоподавляющий автокодировщик (Denoising autoencoder)

𝐿
1
𝑄DAE (𝛼⃗, 𝛽⃗ ) = ∑ ℳ𝜖⃗⃗ {ℒ(𝑔(𝑓(𝑥⃗𝑖 + 𝜖⃗, 𝛼⃗), 𝛽⃗ ), 𝑥⃗𝑖 )} → min
𝐿 ⃗⃗⃗
⃗⃗,𝛽
𝛼
𝑖=1
Рисунок 12.10 Сжимающий автокодировщик (Contractive autoencoder)

𝐿 𝑛 ℎ 2
𝜕𝑓𝑗 (𝑥⃗, 𝛼⃗)
𝑄CAE (𝛼⃗, 𝛽⃗ ) = 𝑄AE (𝛼⃗, 𝛽⃗ ) + 𝜆 ∑ ∑ ∑ ( | ) → min
𝜕𝑥𝑘 𝑥⃗ = 𝑥⃗𝑖 ⃗⃗⃗
⃗⃗,𝛽
𝛼
𝑖=1 ⏟
𝑗=1 𝑘=1
2
‖𝐽𝑓 (𝑥⃗𝑖 )‖
Когда норма матрицы Якоби 𝐽𝑓 (𝑥⃗) преобразования 𝑓 минимальна, шумы на входе
слабо влияют на результат кодировщика 𝑓(𝑥⃗).
154
Рисунок 12.11 Реляционный автокодировщик (Relational autoencoder)
𝑄RAE (𝛼⃗, 𝛽⃗ ) = 𝑄AE (𝛼⃗, 𝛽⃗ ) + 𝜆 ∑ ℒ(𝑟⃗{𝑎⃗(𝑥⃗𝑖 ′ ), 𝑎⃗(𝑥⃗𝑖 ′′ )}, 𝑟⃗{𝑥⃗𝑖 ′ , 𝑥⃗𝑖 ′′ }) → min
⃗⃗⃗
⃗⃗,𝛽
𝛼
𝑖 ′ <𝑖 ′′
Наряду с самими объектами 𝑥⃗𝑖 требуется сохранять отношения 𝑟⃗{𝑥⃗𝑖 ′ , 𝑥⃗𝑖 ′′ } между
ними.
Например, 𝑟⃗{𝑥⃗𝑖 ′ , 𝑥⃗𝑖 ′′ } = (𝑥⃗𝑖 ′ , 𝑥⃗𝑖 ′′ ) – скалярное произведение.
Рисунок 12.12 Многослойный автокодировщик (Stacked autoencoder)

Латентное пространство
Рисунок 12.13 Схема, описывающая суть латентного пространства

Изображения MNIST составляют малую часть 282 = 724-мерного пространства.
Автокодировщики ищут многообразия (manifolds) с высокой вероятностью
встретить на них объекты обучающей выборки.
Размерность найденного многообразия много меньше исходной.
155
Недостаток детерминированного кодировщика – только комбинация признаков

несет разумную информацию.
Рисунок 12.15 Детерминированный автокодировщик
Рисунок 12.16 Вариационный автокодировщик

Вариационный автокодировщик (Variational autoencoder). Репараметризация
Вариационный кодировщик 𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗) и декодировщик 𝑝⃗⃗⃗𝛽 (𝑥⃗ ′ |𝑦⃗)
𝑝⃗⃗⃗𝛽 (𝑥⃗|𝑦⃗)𝑝(𝑦⃗)
𝑝(𝑥⃗) = ∫ 𝑝⃗⃗⃗𝛽 (𝑥⃗|𝑦⃗)𝑝(𝑦⃗)𝑑𝑦⃗ = ∫ 𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗) 𝑑𝑦⃗
𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗)
Принцип максимума правдоподобия
156
𝐿 𝐿
𝑝⃗⃗⃗𝛽 (𝑥⃗𝑖 |𝑦⃗)𝑝(𝑦⃗)
ln 𝐿 = ∑ ln 𝑝(𝑥⃗𝑖 ) = ∑ ln ∫ 𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 ) 𝑑𝑦⃗ ≥
𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 )
𝑖=1 𝑖=1
𝐿
𝑝𝛽⃗⃗⃗ (𝑥⃗𝑖 |𝑦⃗)𝑝(𝑦⃗)
≥ ∑ ∫ 𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 ) ln 𝑑𝑦⃗
𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 )
𝑖=1
𝐿 𝐿
𝑝(𝑦⃗)
= ∑ ∫ 𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 ) ln 𝑑𝑦⃗ + ∑ ∫ 𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 ) ln 𝑝⃗⃗⃗𝛽 (𝑥⃗𝑖 |𝑦⃗) 𝑑𝑦⃗ → min
𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 ) ⃗⃗⃗
⃗⃗,𝛽
𝛼
𝑖=1 𝑖=1
𝐿
𝑝(𝑦⃗)
∑ ∫ 𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 ) ln 𝑑𝑦⃗ = −𝐷KL (𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 )||𝑝(𝑦⃗))
𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 )
𝑖=1
𝐿 𝐿
∑ ∫ 𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 ) ln 𝑝𝛽⃗⃗⃗ (𝑥⃗𝑖 |𝑦⃗) 𝑑𝑦⃗ = ∑ ℳ𝑦~𝑞𝛼⃗⃗⃗(𝑦⃗⃗;𝑥⃗𝑖 ) {ln 𝑝𝛽⃗⃗⃗ (𝑥⃗𝑖 |𝑦⃗)}
𝑖=1 𝑖=1
Идея: вместо распределения 𝑞𝛼⃗⃗ (𝑦⃗|𝑥⃗𝑖 ) рассматривается 𝑦⃗ = 𝑦⃗(𝑥⃗𝑖 , 𝛼⃗, 𝜖⃗), где
𝜖⃗~𝒩(0, 𝐈).
Рисунок 12.17 Перемещение в латентном пространстве

https://gaussian37.github.io/deep-learning-chollet-8-4/
Рисунок 12.18 Векторы в латентном пространстве (1)
157

https://arxiv.org/pdf/1609.04468.pdf

Самообучение (Self-Supervised Learning)
Рисунок 12.21 https://arxiv.org/abs/1505.05192
158
Генеративная состязательная сеть. Векторные представления текста
Рисунок 12.22 Генеративная состязательная сеть

https://www.researchgate.net/publication/331756737_Recent_Progress_on_Generative
_Adversarial_Networks_GANs_A_Survey
Генератор случайных лиц StyleGAN
Рисунок 12.23 https://this-person-does-not-exist.com/ru

Векторные представления текста
Задача: на основе последовательности слов 𝑤𝑖 (текста) сопоставить каждому
слову вектор 𝑣⃗𝑤 так, чтобы близким по смыслу словам соответствовали близкие векторы.
• Синтагматическая близость
компьютер – программа, тетрадь – ручка
• Парадигматическая близость
компьютер – ноутбук, тетрадь – блокнот.
Съешь
⏟ же ещё этих мягких французских булок
⏟ , да
⏟ выпей чаю.
Контекст 𝐶𝑖 =(𝑤𝑖−𝑘 ,…,𝑤𝑖−1 ,𝑤𝑖+1 ,…,𝑤𝑖+𝑘 ) Слово 𝑤𝑖 Контекст
Модель Continuous Bag-Of-Words
Задача: предсказать слово 𝑤𝑖 по его контексту 𝐶𝑖 .
Рисунок 12.24 Схема модели Continuous Bag-Of-Words
159
Вводятся векторы 𝑣⃗𝑤 для каждого предсказывающего слова.

Вводится вектор 𝑢
⃗⃗𝑤 для предсказываемого слова.
1
Средний вектор предсказывающих слов 𝑣⃗𝐶𝑖 = 2𝑘 ∑𝑤𝑗∈𝐶𝑖 𝑣⃗𝑤𝑗 .
Модель 𝑝(𝑤|𝐶𝑖 ) = softmax (𝑣⃗𝐶𝑖 ∙ 𝑢
⃗⃗𝑤 ).
Критерий максимального log-правдоподобия:
𝑛 𝑛
1
∑ ln 𝑝(𝑤𝑖 |𝐶𝑖 ) = ∑ ln softmax ( ⃗⃗𝑤 )) → min
∑ (𝑣⃗𝑤𝑗 ∙ 𝑢
2𝑘 𝐔,𝐕
𝑖=1 𝑖=1 𝑤𝑗 ∈𝐶𝑖
Модель Skip-gram
Задача: предсказать контекст 𝐶𝑖 по слову 𝑤𝑖 .
Рисунок 12.25 Схема модели Skip-gram
Вводятся векторы 𝑣⃗𝑤 для каждого предсказывающего слова.

Вводится вектор 𝑢
⃗⃗𝑤 для предсказываемого слова.
Модель 𝑝(𝑤|𝑤𝑖 ) = softmax (𝑣⃗𝑤𝑖 ∙ 𝑢
⃗⃗𝑤 ).
Критерий максимального log-правдоподобия:
𝑛 𝑛
∑ ∑ ln 𝑝(𝑤|𝑤𝑖 ) = ∑ ∑ ln softmax (𝑣⃗𝑤𝑗 ∙ 𝑢

⃗⃗𝑤 ) → min
𝐔,𝐕
𝑖=1 𝑤∈𝐶𝑖 𝑖=1 𝑤∈𝐶𝑖
One-hot кодировка для текста
Съешь → (1, 0, 0, 0, 0, 0, . . .)
же → (0, 1, 0, 0, 0, 0, . . .)
ещё → (0, 0, 1, 0, 0, 0, . . .)
этих → (0, 0, 0, 1, 0, 0, . . .)
мягких → (0, 0, 0, 0, 1, 0, . . .)
французских → (0, 0, 0, 0, 0, 1, . . .)
…
𝑣⃗𝑤 = 𝐕[𝑊×𝐷] 𝑤
⃗⃗⃗; 𝑢
⃗⃗𝑤 = 𝐔[𝑊×𝐷] 𝑤
⃗⃗⃗
Negative sampling
Критерий Skip-gram:
𝑛
∑ ∑ ln 𝑝(𝑤|𝑤𝑖 ) → min
𝐔,𝐕
𝑖=1 𝑤∈𝐶𝑖
Критерий Skip-gram Negative Sampling:
160
∑ ∑ (ln 𝑝(+1|𝑤, 𝑤𝑖 ) + ln 𝑝(−1|𝑤 − , 𝑤𝑖 )) → min

𝐔,𝐕
𝑖=1 𝑤∈𝐶𝑖
Модель 𝑝(𝑦|𝑤, 𝑤𝑖 ) = sigmoid (y (𝑢

⃗⃗𝑤 ∙ 𝑣⃗𝑤𝑗 ))
𝑦 = +1, если слова (𝑤|𝑤𝑖 ) находятся в контексте, и 𝑦 = −1, если нет.
Слово 𝑤 − ∉ 𝐶𝑖 семплируется с вероятностью 𝑝(𝑤)3⁄4 .
Рисунок 12.26 Проверка: задачи семантической близости

Модель FastText
Слово “хвалолюб”
Набор n-грамм: 𝔾 = {хв, хва, вал, ало, лол, олю, люб, юб}
𝑢
⃗⃗𝑤 = ∑ 𝑢
⃗⃗𝑔
𝑔∈𝔾
Решаются проблемы с опечатками и с редкими или новыми словами.
Число n-грамм гораздо меньше числа слов.
161
Лекция №13. Работа в временными рядами

Задача предсказания временных рядов. Стандартные процессы
Схема постановки и решения задачи прогнозирования
• Имеется временной ряд 𝑥0 , 𝑥1 , . . . , 𝑥𝑡
• Имеется целевой временной ряд 𝑦0 , 𝑦1 , . . . , 𝑦𝑡
• Задается функционал качества ℒ(𝑎⃗, 𝑦𝑡+1 , . . . , 𝑦𝑡+𝑑 ), характеризующий,
насколько хорошо алгоритм 𝑎⃗ аппроксимирует значение ряда в течение 𝑑
следующих шагов.
• Выбирается параметрическая модель 𝑎⃗(𝑥0 , 𝑥1 , . . . , 𝑥𝑡 ; 𝑦0 , 𝑦1 , . . . , 𝑦𝑡 ; 𝜃⃗)
• Модель должна учитывать рост объема данных с ростом 𝑡.
• Параметры модели 𝜃⃗ оптимизируются для достижения минимума ℒ.
Рисунок 13.1 Типы задач, решаемые с помощью предсказания
Рисунок 13.2 Решение задач с помощью предсказания

Стационарные процессы
Стационарный случайный процесс (в широком смысле) — такой процесс 𝜉𝑡 ,
что
∃ℳ{𝜉𝑡 } = 𝑐𝑜𝑛𝑠𝑡; ∃𝒟{𝜉𝑡 } > 0;
𝑐𝑜𝑣(𝜉𝑡 , 𝜉𝑡 ′ ) = 𝑐𝑜𝑣(𝜉𝑡+𝑠 , 𝜉𝑡 ′ +𝑠 )
Условия на стационарные процессы:
• Среднее значение постоянно.
• Дисперсия постоянна.
• Отсутствует сезонность.
Рисунок 13.3 Белый шум – типичный
пример стационарного процесса
162
Рисунок 13.4 АНТИ-примеры к условиям стационарного процесса

Разложение сигнала по базисным функциям. Линейные инвариантные по времени
системы
Разложение сигнала по базисным функциям
𝑓(𝑡) = ∫ 𝑓̃ (𝑠)Ψ(𝑠, 𝑡)𝑑𝑠 𝑓(𝑡) = ∑ 𝑓̃𝑛 Ψ𝑛 (𝑡)

𝑠 𝑛
Выбор «удобных» базисных функций определяется задачей
𝐴̂ — линейный оператор; 𝐴̂Ψ𝑛 (𝑡) = α𝑛 Ψ𝑛 (𝑡)

𝐴̂𝑓(𝑡) = 𝐴̂ ∑ 𝑓̃𝑛 Ψ𝑛 (𝑡) = ∑ 𝑓̃𝑛 𝐴̂Ψ𝑛 (𝑡) = ∑ 𝑓̃𝑛 α𝑛 Ψ𝑛 (𝑡) = ∑ 𝑔̃𝑛 Ψ𝑛 (𝑡) = 𝑔(𝑡)
𝑛 𝑛 𝑛 𝑛
𝑔̃𝑛 = α𝑛 ∙ 𝑓̃𝑛
Линейные инвариантные по времени системы
Линейная система — система, сигнал на выходе которой 𝑔 связан с сигналом на
ее входе 𝑓 с помощью линейного оператора 𝐴̂:
𝑔(𝑡) = 𝐴̂(𝜉1 𝑓1 (𝑡) + 𝜉2 𝑓2 (𝑡)) = 𝜉1 𝐴⏟
̂ 𝑓1 (𝑡) + 𝜉2 𝐴⏟
̂ 𝑓2 (𝑡)
𝑔1 (𝑡) 𝑔2 (𝑡)
̂ 𝑓1 [𝑛] + 𝜉2 𝐴⏟
𝑔[𝑛] = 𝜉1 𝐴⏟ ̂ 𝑓2 [𝑛]
𝑔1 [𝑛] 𝑔2 [𝑛]
Инвариантная по времени система — система, сигнал на выходе которой 𝑔
связан с сигналом на ее входе 𝑓 с помощью оператора 𝐴̂, который не зависит от времени.
∞ ∞
𝑔(𝑡) = 𝐴̂𝑓(𝑡) = 𝐴̂ ∫ 𝑓(𝜏)𝛿(𝑡 − 𝜏)𝑑𝜏 = ∫ 𝑓(𝜏)𝐴̂𝛿(𝑡 − 𝜏)𝑑𝜏
𝜏=−∞ 𝜏=−∞
∞ ∞
=∫ 𝑓(𝜏)ℎ(𝑡 − 𝜏)𝑑𝜏 = ∫ ℎ(𝜏)𝑓(𝑡 − 𝜏)𝑑𝜏
𝜏=−∞ 𝜏=−∞
163
Сигнал g на выходе ЛИВС связан с сигналом f на ее входе с помощью

импульсной функции отклика
∞
ℎ(𝜏) (для непрерывных сигналов): 𝑔(𝑡) = ∫𝜏=−∞ ℎ(𝜏)𝑓(𝑡 − 𝜏)𝑑𝜏
ℎ[𝑚] (для дискретных сигналов): 𝑔[𝑛] = ∑∞ 𝑚=−∞ ℎ[𝑚]𝑓[𝑛 − 𝑚]
Реакция системы на импульсное воздействие
∞
𝑔(𝑡) = ∫ ℎ(𝜏)𝛿(𝑡 − 𝜏)𝑑𝜏 = ℎ(𝑡)
𝜏=−∞
∞
𝑔[𝑛] = ∑ ℎ[𝑚]𝛿[𝑛 − 𝑚] = ℎ[𝑛]

𝑚=−∞
Собственные функции и собственные значения:
∞
𝑔(𝑡) = 𝐴̂𝑓(𝑡) = ∫ ℎ(𝜏)𝑓(𝑡 − 𝜏)𝑑𝜏
𝜏=−∞
Пусть 𝑓(𝑡) = 𝑧 𝑡 . Тогда
𝐻(𝑧)
∞ ∞ ⏞∞
𝑔(𝑡) = ∫ ℎ(𝜏)𝑧 𝑡−𝜏 𝑑𝜏 = 𝑧 𝑡 ∫ ℎ(𝜏)𝑧 −𝜏 𝑑𝜏 = 𝑓(𝑡) ∫ ℎ(𝜏)𝑧 −𝜏 𝑑𝜏
𝜏=−∞ 𝜏=−∞ 𝜏=−∞
∞
𝐻(𝑧) = ∫ ℎ(𝜏)𝑧 −𝜏 𝑑𝜏 — непрерывная системная функция
𝜏=−∞
𝑓(𝑡) = 𝑧 𝑡 — собственные функции оператора 𝐴̂
𝐻(𝑧)— собственные значения оператора 𝐴̂
∞
𝑔[𝑛] = 𝐴̂𝑓[𝑛] = ∑ ℎ[𝑚]𝑓[𝑛 − 𝑚]

𝑚=−∞
Пусть 𝑓[𝑛] = 𝑧 𝑛 . Тогда
𝐻(𝑧)
∞ ∞
⏞∞
𝑔[𝑛] = ∑ ℎ[𝑚]𝑧 𝑛−𝑚 = 𝑧 𝑛 ∑ ℎ[𝑚]𝑧 −𝑚 = 𝑓[𝑛] ∫ ℎ(𝜏)𝑧 −𝜏 𝑑𝜏
𝑚=−∞ 𝑚=−∞ 𝜏=−∞
∞
𝐻(𝑧) = ∫ ℎ(𝜏)𝑧 −𝜏 𝑑𝜏 — непрерывная системная функция
𝜏=−∞
𝑓(𝑡) = 𝑧 𝑡 — собственные функции оператора 𝐴̂
𝐻(𝑧)— собственные значения оператора 𝐴̂
Z-преобразование
Прямое преобразование: ℤ{ℎ[𝑛]} ≡ ∑∞
𝑛=−∞ ℎ[𝑛]𝑧
−𝑛
164
1
Обратное преобразование: ℤ−1 {𝐻(𝑧)} ≡ 2𝜋𝑖 ∮𝐶 𝐻(𝑧)𝑧 𝑛−1 𝑑𝑧. Контур 𝐶 охватывает
область сходимости 𝐻(𝑧) и содержит все полюсы 𝐻(𝑧).
• Если положить 𝑧 = 𝑒 𝑖𝜔𝑡 , то получается преобразование Фурье.
• Свойства Z-преобразования те же, что и у преобразования Фурье.
• 𝑧 −1 – операция сдвига на 1 отсчет.
Модель APCC (ARMA). Модель AR(1). Единичные корни
Рисунок 13.5 Модель APCC (ARMA)

Модель АРСС (ARMA)
ARMA(p, q):
𝑞 𝑝
∑ 𝑏[𝑘]𝑥[𝑛 − 𝑘] − ∑ 𝑎[𝑘]𝑦[𝑛 − 𝑘] = 𝑦[𝑛]

𝑘=0 𝑘=0
𝑎[0] = 1
𝑞 𝑝
{
∑ 𝑏[𝑘]𝑥[𝑛 − 𝑘] = ∑ 𝑎[𝑘]𝑦[𝑛 − 𝑘]
𝑘=0 𝑘=0
𝑞 ∞ 𝑞 𝑞 ∞
−𝑛 −𝑘
ℤ {∑ 𝑏[𝑘]𝑥[𝑛 − 𝑘]} = ∑ 𝑧 ∑ 𝑏[𝑘]𝑥[𝑛 − 𝑘] = ∑ 𝑏[𝑘]𝑧 ∑ 𝑧 −(𝑛−𝑘) 𝑥[𝑛 − 𝑘]
𝑘=0 𝑛=−∞ 𝑘=0 𝑘=0 𝑛=−∞
𝑞
= 𝑋(𝑧) ∑ 𝑏[𝑘]𝑧 −𝑘
𝑘=0
𝑝 𝑝
ℤ {∑ 𝑎[𝑘]𝑦[𝑛 − 𝑘]} = 𝑌(𝑧) ∑ 𝑎[𝑘]𝑧 −𝑘

𝑘=0 𝑘=0
ARMA(p, q):
165
𝑞 𝑝
∑ 𝑏[𝑘]𝑥[𝑛 − 𝑘] − ∑ 𝑎[𝑘]𝑦[𝑛 − 𝑘] = 𝑦[𝑛]

𝑘=0 𝑘=0
𝑞 𝑝
−𝑘
𝑋(𝑧) ∑ 𝑏[𝑘]𝑧 = 𝑌(𝑧) ∑ 𝑎[𝑘]𝑧 −𝑘
𝑘=0 𝑘=0
𝑞 −𝑘 𝑝
𝑌(𝑥) ∑𝑘=0 𝑏[𝑘]𝑧 ∏𝑘=0(1 − 𝑧𝑘 ⁄𝑧)
𝐻(𝑧) = = 𝑝 = 𝑏[0] 𝑝
𝑋(𝑧) 1 + ∑𝑘=1 𝑎[𝑘]𝑧 −𝑘 ∏ (1 − 𝑝𝑘 ⁄𝑧) 𝑘=1
𝑏[0] – масштаб усиления; 𝑧𝑘 – нули; 𝑝𝑘 – полюсы функции 𝐻(𝑧)
𝐴𝑅(𝑝) = 𝑀𝐴(∞); 𝑀𝐴(𝑞) = 𝐴𝑅(∞)
Модель ARMA(p, q) позволяет получить прогноз:
𝑞 𝑝
𝑦̂[𝑛] = 𝑐 + ∑ 𝑏[𝑘]𝜖[𝑛 − 𝑘] − ∑ 𝑎[𝑘]𝑦[𝑛 − 𝑘] ; 𝜖[𝑛] = 𝑦[𝑛] − 𝑦̂[𝑛]

𝑘=0 𝑘=1
Влияние временных отсчетов на прогноз
• Непосредственное влияние (зелёные стрелки).
• Влияние через другие отсчеты (синяя стрелка).
Рисунок 13.6 Влияние предыдущих значений на последующие

Автокорреляционная функция (ACF)
Корреляционная функция
• Если 𝑦1,2 [𝑛] имеют в момент 𝑛 среднее 𝜇1,2 [𝑛] и дисперсию 𝜎1,2 2
[𝑛],
ℳ{(𝑦1 [𝑛] − 𝜇1 [𝑛])(𝑦2 [𝑚] − 𝜇2 [𝑚])}
𝐶𝑜𝑟𝑟(𝑦1 [𝑛], 𝑦2 [𝑚]) =
𝜎1 [𝑛]𝜎2 [𝑚]
Автокорреляционная функция
• Если 𝑦[𝑛] имеет в момент 𝑛 среднее 𝜇[𝑛] и дисперсию 𝜎 2 [𝑛],
ℳ{(𝑦[𝑛] − 𝜇[𝑛])(𝑦[𝑚] − 𝜇[𝑚])}
𝐴𝐶𝐹(𝑛, 𝑚) = 𝐶𝑜𝑟𝑟(𝑦[𝑛], 𝑦[𝑚]) =
𝜎[𝑛]𝜎[𝑚]
• Если процесс стационарный, то
ℳ{(𝑦[𝑛 + 𝑡] − 𝜇)(𝑦[𝑛] − 𝜇)}
𝐴𝐶𝐹(𝑡) = 𝐶𝑜𝑟𝑟(𝑦[𝑛 + 𝑡], 𝑦[𝑛]) =
𝜎2
Частичная автокорреляционная функция (PACF)
𝐶𝑜𝑟𝑟(𝑦[𝑛 + 𝑡], 𝑦[𝑛]) t = 1;
𝑃𝐴𝐶𝐹(𝑡) = {
𝐶𝑜𝑟𝑟(𝑦[𝑛 + 𝑡] − 𝑦 (𝑡−1) [𝑛 + 𝑡], 𝑦[𝑛] − 𝑦 (𝑡−1) [𝑛]), 𝑡 > 1.
Корректировки в виде линейной регрессии на
𝑦[𝑛 + 1], 𝑦[𝑛 + 2], … , 𝑦[𝑛 + 𝑡 − 1]:
166
𝑦 (𝑛−1) [𝑛] = 𝛽1 [𝑛 + 1] + 𝛽2 𝑦[𝑛 + 2] + ⋯ + 𝛽𝑡−1 𝑦[𝑛 + 𝑡 − 1];

{
𝑦 (𝑛−1) [𝑛] = 𝛽1 [𝑛 + 𝑡 − 1] + 𝛽2 𝑦[𝑛 + 𝑡 − 2] + ⋯ + 𝛽𝑡−1 𝑦[𝑛 + 1].
Сравнение ACF и PACF. Модель AR(1)
𝑦[𝑛] = 𝑎𝑦[𝑛 − 1] + 𝜖[𝑛]; 𝜖[𝑛]~𝒩(0, 𝜎 2 )
𝑦[𝑛] = 𝑎𝑦[𝑛 − 1] + 𝜖[𝑛] = 𝑦[𝑛] = 𝑎2 𝑦[𝑛 − 2] + 𝑎𝜖[𝑛 − 1]𝜖[𝑛] = ⋯
Рисунок 13.7 Сравнение ACF и PACF. Модель AR(1)
Для моделей 𝐴𝑅(𝑝) характерно плавное спадание 𝐴𝐶𝐹 и отсечка 𝑃𝐴𝐶𝐹 на лаге 𝑝.
Сравнение ACF и PACF. Модель MA(1)
𝑦[𝑛] = 𝑎𝜖[𝑛 − 1] + 𝜖[𝑛]; 𝜖[𝑛]~𝒩(0, 𝜎 2 )
Рисунок 13.8 Сравнение ACF и PACF. Модель MA(1)
Для моделей 𝑀𝐴(1) характерно плавное спадание 𝑃𝐴𝐶𝐹 и отсечка 𝐴𝐶𝐹 на лаге 𝑞.
Модель AR(1) и стационарность процесса
𝐴𝑅(1): 𝑦[𝑛] = 𝑎𝑦[𝑛 − 1] + 𝜖[𝑛]; 𝜖[𝑛]~𝒩(0, 𝜎 2 )
𝑛−1
𝑦[𝑛] = 𝑎𝑦[𝑛 − 1] + 𝜖[𝑛] = 𝑎𝑛 𝑦[0] + ∑ 𝑎𝑘 𝜖[𝑛 − 𝑘]

𝑘=0
ℳ{𝑦[𝑛]} = 𝑎ℳ{𝑦[𝑛 − 1]} = ⋯ = 𝑎𝑛 𝑦[0]
𝑛−1
{ 1 − 𝑎2(𝑛−1)
𝒟{𝑦[𝑛]} = 𝜎 ∑ 𝑎2𝑘 = 𝜎 2
2
1−𝑎
𝑘=0
Если |𝑎| > 1, то
ℳ{|𝑦[𝑛]|} = |𝑎𝑛 𝑦[0]| → ∞
{ 1 − 𝑎2(𝑛−1)
𝒟{𝑦[𝑛]} = 𝜎 2 →∞
1−𝑎
⇒ процесс нестационарен.
Рисунок 13.9 Процесс нестационарен
167
Если |𝑎| < 1, то

ℳ{|𝑦[𝑛]|} = |𝑎𝑛 𝑦[0]| → 0
{ 2
1 − 𝑎2(𝑛−1) 𝜎2
𝒟{𝑦[𝑛]} = 𝜎 →
1−𝑎 1−𝑎
⇒ процесс стационарен.
Рисунок 13.10 Процесс стационарен
Если |𝑎| = 1, то
ℳ{|𝑦[𝑛]|} = |𝑎𝑛 𝑦[0]| → |𝑎𝑛 𝑦[0]|
𝑛−1
{
𝒟{𝑦[𝑛]} = 𝜎 ∑ 𝑎2𝑘 → 𝜎 2 ∙ 𝑛 → ∞
2
𝑘=0
⇒ процесс нестационарен, существует единичный
корень. Рисунок 13.11 Процесс
нестационарен, существует
Единичные корни единичный корень.
𝑞 𝑝
𝑌(𝑥) ∑𝑘=0 𝑏[𝑘]𝑧 −𝑘 ∏𝑘=0(1 − 𝑧𝑘 ⁄𝑧)
𝐻(𝑧) = = = 𝑏[0] 𝑝
𝑋(𝑧) 1 + ∑𝑝𝑘=1 𝑎[𝑘]𝑧 −𝑘 ∏𝑘=1(1 − 𝑝𝑘 ⁄𝑧)
• При 𝑧 = 𝑝𝑘 получается 𝑋(𝑧) = 0; 𝐻(𝑧) = ∞
• Если |𝑝𝑘 | = 1 – единичный корень, то ∃𝜔: 𝑧 = 𝑝𝑘 = 𝑒 𝑖𝜔𝑡 .
• Процесс нестационарный, т.к. спектральная компонента 𝜔 растет.
• Пусть имеется 𝑑 единичных корней, тогда
𝑝 𝑝−𝑑 𝑑
−𝑘 ′ [𝑘]𝑧 −𝑘 −1 𝑑 ′ (𝑧) −1
1 + ∑ 𝑎[𝑘]𝑧 = (1 + ∑ 𝑎 ) (1 − 𝑧 ) =𝑋 (1
⏟− 𝑧 )
𝑘=1 𝑘=1 ∆
• ∆= 1 − 𝑧 – разностный оператор
−1
• Дифференцирование позволяет избавиться от единичных корней.

Модель APПCC (ARIMA) и СAPПCC (SARIMA)
Модель ARIMA(p, d, q) позволяет получить прогноз:
𝑞 𝑝
∆𝑑 𝑦̂[𝑛] = 𝑐 + ∑ 𝑏[𝑘]𝜖[𝑛 − 𝑘] − ∑ 𝑎[𝑘]∆𝑑 𝑦[𝑛 − 𝑘] ; 𝜖[𝑛] = 𝑦[𝑛] − 𝑦̂[𝑛]

𝑘=1 𝑘=1
Модель ARFIMA – обобщение на случай дробного дифференцирования
∞ 𝑘−1
𝑑 −1 𝑑
(−1)𝑘 −𝑘
∆ = (1 − 𝑧 ) = ∑ ∏(𝑑 − 𝑗) 𝑧
𝑘!
𝑘=0 𝑗=0
Модель САРПСС (SARIMA) для построения прогноза
168
Рисунок 13.12 Процесс может состоять из «сезонов»

Модель ARIMA(p, d, q)1 с параметром разрежения m = 1:
𝑞 𝑝
∆𝑑 𝑦̂[𝑛] = 𝑐 + ∑ 𝑏[𝑘]𝜖[𝑛 − 𝑘] − ∑ 𝑎[𝑘]∆𝑑 𝑦[𝑛 − 𝑘]

𝑘=1 𝑘=1
Учитываются лаги 1, 2, . . . , 𝑝 и 1, 2, . . . , 𝑞.
Модель ARIMA(p, d, q)m с параметром разрежения m:
𝑞 𝑝
∆ 𝑦̂[𝑛] = 𝑐 + ∑ 𝑏[𝑘]𝜖[𝑛 − 𝑘𝑚] − ∑ 𝑎[𝑘]∆𝑑 𝑦[𝑛 − 𝑘𝑚]

𝑑
𝑘=1 𝑘=1
Учитываются лаги 𝑚, 2𝑚, . . . , 𝑝𝑚 и 1, 2, . . . , 𝑞𝑚.
Модель 𝑆𝐴𝑅𝐼𝑀𝐴(𝑝, 𝑑, 𝑞) ⏟
(𝑃, 𝐷, 𝑄)𝑚
Сезонность
Учитываются лаги 1, 2, . . . , 𝑝 и 1, 2, . . . , 𝑞.
Учитываются лаги 𝑚, 2𝑚, . . . , 𝑃𝑚 и 1, 2, . . . , 𝑄𝑚.
Модель ARCH, GARCH. Нейросетевые методы прогнозирования
Рисунок 13.13 Волатильность актива меняется с течением времени
ARCH(q): 𝑢[𝑛] = 𝜖[𝑛]√𝛼[0] + ∑𝑞𝑘=1 𝛼[𝑘]𝑢2 [𝑛 − 𝑘] ; 𝜖[𝑛]~𝒩(0, 𝜎 2 )
GARCH(p, q): 𝑢[𝑛] = 𝜖[𝑛]√𝛼[0] + ∑𝑞𝑘=1 𝛼[𝑘]𝑢2 [𝑛 − 𝑘] + ∑𝑝𝑘=1 𝛽[𝑘]𝜎 2 [𝑛 − 𝑘]

Нейросетевые методы прогнозирования. Рекуррентные нейронные сети (RNN)
169
Идея: сохранить некоторое состояние с предыдущего шага и передать его на

следующий шаг.
• 𝑥⃗[𝑛] – входные данные;
• 𝑦⃗[𝑛] – выходные данные;
• ℎ⃗⃗[𝑛] – внутреннее состояние.
⃗⃗[𝑛] = 𝜎⃗ℎ (𝐔𝑥⃗[𝑛] + 𝐖ℎ

ℎ ⃗⃗[𝑛 − 1])
{
⃗⃗[𝑛])
𝑦⃗[𝑛] = 𝜎⃗𝑦 (𝐕ℎ
Нейронная сеть двуслойная, но она
“разворачивается” в многослойную цепочку
Рисунок 13.14 Схема нейронной сети
Архитектуры для разных задач
Рисунок 13.15 seq-to-seq seq-to-seq seq-to-one

one-to-seq
• Методы типа SGD не работают изза упорядоченности данных.

• Метод обратного распространения ошибки во времени (BPTT)
𝑛 𝑛
𝜕ℒ[𝑛] 𝜕ℒ[𝑛] 𝜕𝑦[𝑛] 𝜕ℎ[𝑚] 𝜕ℎ[𝑘]
= ∑( ∏ )
𝜕𝑊 𝜕𝑦[𝑛] 𝜕ℎ[𝑛] 𝜕ℎ[𝑚 − 1] 𝜕𝑊
𝑘=0 𝑚=𝑘+1
• Необходимо ввести ограничение на глубину истории.
𝜕ℎ[𝑚]
• Необходимо, чтобы → 1, иначе возникает взрыв или затухание
𝜕ℎ[𝑚−1]
градиента.
170
Сеть долгой краткосрочной памяти (LSTM)

Идея: сеть должна достаточно долго помнить контекст. С этой целью функция
активации внутри реккурентных блоков не используется.
https://neerc.ifmo.ru/wiki/index.php?title=Долгая_краткосрочная_память
Рисунок 13.16 Схема слоев долго-краткосрочной памяти

Состояние ячейки изменяется с помощью фильтров.
Значение сигмоиды лежит в диапазоне [0; 1] и определяет долю “сигнала” на
выходе фильтра.
Рисунок 13.17 Фильтры в слоях долго-краткосрочной памяти
Рисунок 13.18 Фильтр забывания (forget gate)
171
Рисунок 13.19 Входной фильтр (input gate)
Рисунок 13.20 Выходной фильтр (output gate)
Сеть долгой краткосрочной памяти (LSTM) со смотровыми глазками (peephole

conections)
Рисунок 13.21 Смотровые глазки

С их помощью слои фильтров могут видеть состояние ячейки.
Рисунок 13.22 Управляемые рекуррентные нейроны
172
ФИЗИЧЕСКИЙ
ФАКУЛЬТЕТ
МГУ ИМЕНИ
М.В. ЛОМОНОСОВА

Machine Learning Methods in Image and Time Series Analysis M1

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Machine Learning Methods in Image and Time Series Analysis M1

Загружено:

Авторское право:

Доступные форматы

КОНСПЕКТ ПОДГОТОВЛЕН СТУДЕНТАМИ, НЕ ПРОХОДИЛ

ПРОФ. РЕДАКТУРУ И МОЖЕТ СОДЕРЖАТЬ ОШИБКИ.

МЕТОДЫ МАШИННОГО ОБУЧЕНИЯ

Метод парзеновского окна. Сравнение с линейным классификатором ......................... 70

Полносвязная нейронная сеть прямого распространения. Обучение сети. Метод

Лекция 1. Введение. Задачи, подходы и возможности

Задачи можно условно разделить на «формальные», решаемые с помощью

• порядковый: 𝔻𝑓 – конечное упорядоченное множество, «ранжирование

Модель нейрона Мак-Каллока-Питтса. Линейная регрессия и классификация

Рисунок 1.1 Модель нейрона Мак-Каллока-Питтса

Рисунок 1.2 Задачи, выполняемые нейроном, а) линейная регрессия б) линейная

Линейная классификация: в зависимости от данной на вход выборки, происходит

3) Задается функционал качества ℒ(𝑎, 𝑥⃗, 𝑦), характеризующий, насколько

Лекция 2. Библиотеки Python, используемые для машинного обучения.

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

Таблица с единственной колонкой - объект Series

Можно прочитать CSV файл, расположенный локально или на внешнем сайте

Теперь можно сохранить файл локально

2. Индексирование, выборка и присваивание значений

Можно сделать выборку по индексу в колонке

Можно переименовать колонки или индекс

2.2. Выборка по номеру с помощью iloc

print(iris_data.iloc[0,1]) # Напечатать вторую колонку первой

print(iris_data.iloc[0:10, 0:4:2])# Можно использовать слайсы

2.3. Выборка по имени с помощью loc

print(iris_data.loc[0, 'Ширина чашелистика']) # Напечатать

print(iris_data.loc[0:10, ['Длина чашелистика', 'Длина лепестк

Отличие в индексировании iloc и loc связано с тем, что loc работает с

В таблице можно задать одну колонку как индексную

А можно задать и несколько колонок

Работать с таким индексом сложнее

2.4. Условные выборки

print( iris_data[(iris_data['Длина чашелистика']>6.0) & (iris

print( iris_data[(iris_data['Длина чашелистика']>6.0) & (iris

Или можно сделать выборку и присвоить значение элементам выборки

Можно присвоить выборке список с разными значениями

classes = ['class1', 'class2', 'class2']

iris_data2.loc[0:2, 'class'] = classes

2.6. map и apply

Функция map позволяет преобразовать одно значение в другое путем применения

Функция apply позволяет преобразовать одну строку в таблице в другую путем

Можно использовать apply, обрабатывая столбцы

3. Агрегатные функции. Группировка, сортировка, комбинирование

unique - выдает уникальные значения value_counts - считает число

print("mean=%f; median=%f; max=%f" % (iris_data['Длина чашелис

print("mean=%f; median=%f; max=%f" % tuple(iris_data['Длина ча

Можно группировать по нескольким колонкам

iris_data.sort_values(by='Ширина чашелистика', ascending=False

3.4. Комбинирование таблиц

print(iris_data1, "\n", '-'*80, "\n", iris_data2)

Объединим 2 таблицы "вертикально"

Можно объединить таблицы "горизонтально", с учетом индексов.

Сбросим индекс, чтобы соответствующие по порядку строки слились.

Можно поставить (join='inner'), тогда выбирается пересечение множеств индексов

Другой вариант - заполнить дополнительные колонки только для индексов из

4. Типы данных и работа с пропущенными значениями

При необходимости тип данных можно преобразовать к другому типу

Теперь посмотрим, как отображаются пропущенные значения - это особый тип

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

Можно заполнить пропущенное значение каким-то образом

iris_data21['Длина чашелистика_data1']=iris_data21['Длина чаше

Бывает полезно осуществить замену одного значения другим

Seaborn и matplotlib - библиотеки для визуализации данных

color = list('r'(N//3) + 'b'(N-

color = list('r'(N//3) + 'b'(N-

Рисунок 4.7 Ridgeрегрессия (P = 2), отбор признаков не происходит

Рисунок 4.8 Отбор признаков при lassoрегрессии (P = 1)