Погружение в глубокое обучение

Эта книга — русскоязычное издание учебника по глубокому обучению, основанного на китайской версии «Dive into Deep Learning». Оригинал сочетает объяснения, математику и исполняемый код на Python: идея в том, чтобы сначала показать, как работает метод, а затем сразу применить его на реальных данных.

Учебник начинается с основ: данных и предварительных знаний (линейная алгебра, математический анализ, теория вероятностей), затем рассматриваются линейные модели, многослойные перцептроны, вычислительные аспекты обучения, свёрточные и рекуррентные сети, механизмы внимания, методы оптимизации, вычислительную производительность, компьютерное зрение и обработку естественного языка. Код приведён для нескольких фреймворков глубокого обучения.

Книга распространяется по лицензии CC BY-SA 4.0. Авторство оригинала, лицензия и происхождение материалов описаны на страницах «Авторство и лицензия» и «Происхождение материалов».

Перевод выполнен полностью: предисловие, установка, обозначения, главы 1–15, приложение «Инструменты для глубокого обучения» и список литературы. Рисунки и таблицы пронумерованы по разделам, как в оригинале. Сведения о том, что изменено относительно оригинала, см. страницу «Происхождение материалов».

Предисловие

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

Всего за последние пять лет глубокое обучение застало мир врасплох и ускорило прогресс в самых разных областях: компьютерном зрении, обработке естественного языка, автоматическом распознавании речи, обучении с подкреплением и статистическом моделировании. Благодаря этим достижениям мы можем создавать автомобили с более высокой степенью автономности, чем когда-либо (хотя и не такой высокой, как пытаются убедить нас некоторые компании), системы умных ответов, которые сами составляют черновики обычных писем и освобождают людей от угнетающе огромных почтовых ящиков, и программы, которые в го и других играх обыгрывают лучших игроков мира — а это ещё недавно считалось делом далёкого будущего. Эти инструменты уже оказывают всё более широкое влияние на промышленность и общество: они меняют способы создания фильмов и диагностики заболеваний и играют растущую роль в фундаментальных науках — от астрофизики до биологии.

О книге

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

Среда, объединяющая код, математику и HTML

Чтобы любая вычислительная технология раскрыла весь свой потенциал, она должна быть хорошо понята, хорошо документирована и опираться на зрелые, хорошо поддерживаемые инструменты. Ключевые идеи должны быть чётко изложены, чтобы новым специалистам требовалось как можно меньше времени на то, чтобы войти в курс дела. Зрелые библиотеки должны автоматизировать типовые задачи, а примеры кода должны позволять практикам легко изменять, применять и расширять типовые приложения под свои нужды. Возьмём для примера динамические веб-приложения. Хотя многие компании, например Amazon, разработали успешные веб-приложения на основе баз данных ещё в 1990-х годах, потенциал этой технологии для поддержки творческих предпринимателей был реализован в гораздо большей степени за последние десять лет — отчасти благодаря появлению мощных, хорошо документированных фреймворков.

Проверить потенциал глубокого обучения непросто, потому что любое отдельное приложение объединяет разные дисциплины. Применение глубокого обучения требует одновременно понимать: (1) мотивацию постановки задачи определённым образом; (2) математику данного подхода к моделированию; (3) алгоритмы оптимизации, подгоняющие модели под данные; (4) инженерные приёмы, позволяющие эффективно обучать модели, справляться с вычислительными ловушками и максимально использовать имеющееся оборудование. Учить одновременно критическому мышлению, необходимому для формулировки задач, математике, необходимой для их решения, и программным инструментам, необходимым для реализации этих решений, — серьёзная задача.

Когда мы начинали работу над этой книгой, не существовало ресурсов, которые одновременно: (1) были бы актуальными; (2) охватывали все области современного машинного обучения с достаточной технической глубиной; (3) сочетали качественное изложение, характерное для хорошего учебника, с чистым исполняемым кодом, какой ожидаешь найти в практических руководствах. Мы нашли множество примеров кода о том, как пользоваться тем или иным фреймворком глубокого обучения (например, как выполнять базовые численные вычисления с матрицами в TensorFlow) или как реализовать конкретные приёмы (например, фрагменты кода для LeNet, AlexNet, ResNet), разбросанные по блогам и репозиториям GitHub. Однако такие примеры обычно сосредоточены на том, как реализовать тот или иной подход, и оставляют за кадром обсуждение того, почему принимаются те или иные алгоритмические решения. Интерактивные ресурсы по отдельным темам появлялись лишь время от времени — например, увлекательные записи в блоге Distill или личные блоги, — но они охватывали лишь избранные темы глубокого обучения и часто не содержали кода. С другой стороны, появилось несколько учебников, из которых самый известный — «Deep Learning» (Goodfellow et al., 2016), — дающих всестороннее обзорное изложение концепций глубокого обучения, но они не связывают описание этих концепций с их реализацией в коде, и порой читатель остаётся в полном неведении относительно того, как их реализовать. Кроме того, слишком много ресурсов спрятано за платными стенами коммерческих поставщиков курсов.

Мы поставили себе целью создать ресурс, который: (1) был бы свободно доступен всем; (2) обладал бы достаточной технической глубиной, чтобы стать отправной точкой на пути к тому, чтобы стать настоящим специалистом по прикладному машинному обучению; (3) включал бы исполняемый код, показывающий читателям, как решать задачи на практике; (4) позволял быстро обновляться как нам, так и сообществу в целом; (5) дополнялся форумом для интерактивного обсуждения технических деталей и ответов на вопросы.

Эти цели нередко противоречили друг другу. Формулы, теоремы и ссылки лучше всего оформлять и вёрстывать в LaTeX. Код лучше всего описывать на Python. Веб-страницы изначально строятся на HTML и JavaScript. Кроме того, мы хотим, чтобы содержимое было доступно и как исполняемый код, и как печатная книга, и как загружаемый PDF, и как сайт в интернете. Подходящих под эти требования инструментов и рабочих процессов не существует, поэтому нам пришлось собрать их самим. Наш подход подробно описан в разделе 16.5. Мы выбрали GitHub для хранения исходников и приёма правок, блокноты Jupyter — для сочетания кода, формул и текста, Sphinx — как движок вёрстки, создающий разные выходные форматы, и Discourse — для форума. Хотя наша система ещё несовершенна, эти решения дают хороший компромисс между противоречивыми требованиями. Мы полагаем, что это, возможно, первая книга, изданная с использованием такого интегрированного рабочего процесса.

Обучение на практике

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

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

Помимо нескольких вводных разделов, дающих ускоренный курс базовой математики, каждая последующая глава вводит разумное число новых концепций и содержит несколько самодостаточных рабочих примеров на реальных наборах данных. Это создаёт организационные трудности. Некоторые модели логично было бы сгруппировать в одном разделе. А некоторые идеи лучше всего преподавать, последовательно запуская несколько моделей. С другой стороны, у подхода «один рабочий пример — один раздел» есть большое преимущество: он позволяет как можно проще начать собственный исследовательский проект, воспользовавшись нашим кодом. Достаточно скопировать содержимое раздела и приступить к изменениям.

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

Эта книга будет учить концепциям глубокого обучения с нуля. Иногда нам хочется углубиться в детали моделей, которые обычно скрыты высокоуровневыми абстракциями фреймворков глубокого обучения. Особенно это касается базовых учебных разделов, где мы хотим, чтобы вы понимали всё, что происходит в данном слое или оптимизаторе. В таких случаях мы обычно приводим два варианта примера: в одном мы реализуем всё с нуля, опираясь только на операции с тензорами и автоматическое дифференцирование; в другом, более практичном, пишем лаконичный код с помощью высокоуровневых API фреймворков глубокого обучения. Как только мы объясним, как работает какой-то компонент, в последующих разделах мы будем пользоваться высокоуровневыми API.

Содержание и структура

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

Рис. 1. Структура книги

• Первая часть охватывает основы и предварительные знания. Глава 1 — введение в глубокое обучение. В главе 2 мы быстро знакомим вас с необходимыми для практики глубокого обучения предварительными сведениями: как хранить и обрабатывать данные и как применять различные численные операции, основанные на базовых понятиях линейной алгебры, математического анализа и теории вероятностей. Главы 3 и 4 охватывают самые базовые концепции и приёмы глубокого обучения, такие как линейная регрессия, многослойные перцептроны и регуляризация.

• Следующие шесть глав посвящены современным приёмам глубокого обучения. Глава 5 описывает ключевые компоненты вычислений в глубоком обучении и закладывает основу для реализации более сложных моделей в дальнейшем. Затем в главах 6 и 7 мы представляем свёрточные нейронные сети (convolutional neural network, CNN) — мощный инструмент, составляющий основу большинства современных систем компьютерного зрения. Далее, в главах 8 и 9, мы вводим рекуррентные нейронные сети (recurrent neural network, RNN) — модели, использующие временную или последовательную структуру данных и обычно применяемые для обработки естественного языка и прогнозирования временных рядов. В главе 10 мы представляем новый класс моделей, использующих приём под названием механизмы внимания; в последнее время они начали вытеснять рекуррентные нейронные сети в обработке естественного языка. Эта часть поможет вам быстро освоить основные инструменты, лежащие в основе большинства современных приложений глубокого обучения.

• Третья часть посвящена масштабируемости, эффективности и приложениям. Сначала в главе 11 мы обсуждаем несколько распространённых алгоритмов оптимизации, используемых для обучения моделей глубокого обучения. В следующей главе 12 рассматриваются несколько ключевых факторов, влияющих на вычислительную производительность кода глубокого обучения. В главе 13 мы показываем основные применения глубокого обучения в компьютерном зрении. В главах 14 и 15 мы показываем, как предобучать модели языковых представлений и применять их к задачам обработки естественного языка.

Код

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

Иногда, чтобы избежать лишних повторений, мы выносим в пакет d2l функции, классы и прочее, которые часто импортируются и используются в книге. Любой блок кода — функцию, класс или набор импортов, — который нужно сохранить в пакете, мы помечаем #@save. Подробное описание этих функций и классов приведено в разделе 16.6. Пакет d2l лёгкий и требует в качестве зависимостей только следующие пакеты и модули:

#@save
import collections
from collections import defaultdict
from IPython import display
import math
from matplotlib import pyplot as plt
from matplotlib_inline import backend_inline
import os
import pandas as pd
import random
import re
import shutil
import sys
import tarfile
import time
import requests
import zipfile
import hashlib
d2l = sys.modules[__name__]

MXNet: большая часть кода в этой книге основана на Apache MXNet. MXNet — фреймворк глубокого обучения с открытым исходным кодом, который выбирают Amazon, а также многие университеты и компании. Весь код этой книги прошёл проверку на последней версии MXNet. Однако из-за быстрого развития глубокого обучения часть кода в печатной версии оригинала может перестать работать в будущих версиях MXNet. Мы планируем поддерживать онлайн-версию в актуальном состоянии. Если вы столкнётесь с такой проблемой, обратитесь к разделу «Установка», чтобы обновить код и среду выполнения.

Вот как мы импортируем модули из MXNet:

MXNet:

#@save
from mxnet import autograd, context, gluon, image, init, np, npx
from mxnet.gluon import nn, rnn

PyTorch: большая часть кода в этой книге основана на PyTorch — фреймворке глубокого обучения с открытым исходным кодом, очень популярном в исследовательском сообществе. Весь код этой книги прошёл проверку на последней версии PyTorch. Однако из-за быстрого развития глубокого обучения часть кода в печатной версии оригинала может перестать работать в будущих версиях PyTorch. Мы планируем поддерживать онлайн-версию в актуальном состоянии. Если вы столкнётесь с такой проблемой, обратитесь к разделу «Установка», чтобы обновить код и среду выполнения.

Вот как мы импортируем модули из PyTorch:

PyTorch:

#@save
import numpy as np
import torch
import torchvision
from torch import nn
from torch.nn import functional as F
from torch.utils import data
from torchvision import transforms
from PIL import Image

TensorFlow: большая часть кода в этой книге основана на TensorFlow — фреймворке глубокого обучения с открытым исходным кодом, очень популярном и в исследовательском сообществе, и в промышленности. Весь код этой книги прошёл проверку на последней версии TensorFlow. Однако из-за быстрого развития глубокого обучения часть кода в печатной версии оригинала может перестать работать в будущих версиях TensorFlow. Мы планируем поддерживать онлайн-версию в актуальном состоянии. Если вы столкнётесь с такой проблемой, обратитесь к разделу «Установка», чтобы обновить код и среду выполнения.

Вот как мы импортируем модули из TensorFlow:

#@save
import numpy as np
import tensorflow as tf

#@save
import numpy as np
import warnings
warnings.filterwarnings("ignore")
import paddle
from paddle import nn
from paddle.nn import functional as F
from paddle.vision import transforms
import paddle.vision as paddlevision
from PIL import Image
paddle.disable_signal_handler()

Целевая аудитория

Книга рассчитана на студентов (бакалавриата и магистратуры), инженеров и исследователей, которые хотят уверенно овладеть практическими приёмами глубокого обучения. Поскольку мы объясняем каждую концепцию с нуля, предварительный опыт глубокого или машинного обучения не требуется. Полноценное изложение методов глубокого обучения требует некоторой математики и программирования, но мы предполагаем лишь базовые знания: линейная алгебра, математический анализ, вероятность и самые основы программирования на Python. Кроме того, в приложениях к онлайн-версии оригинала мы даём обзор большей части математики, которая используется в книге. В большинстве случаев мы отдаём предпочтение интуиции и идеям перед математической строгостью. Есть много замечательных книг, которые могут увести заинтересованного читателя гораздо дальше. «Линейный анализ» Белы Боллобаша (Bollobas, 1999) глубоко рассматривает линейную алгебру и функциональный анализ. «All of Statistics» (Wasserman, 2013) — отличное руководство по статистике. Если вы раньше не пользовались языком Python, можно внимательно изучить этот учебник по Python.

Форум

В связи с этой книгой мы запустили форум discuss.d2l.ai. Если у вас возникнут вопросы по какому-либо разделу книги, ссылку на соответствующую страницу обсуждения вы найдёте в конце каждого раздела.

Благодарности

Мы благодарим сотни авторов англоязычных и китайских черновиков. Они помогли улучшить содержание и дали ценные отзывы. Мы благодарим Анируддха Дагара (Anirudh Dagar) и Тана Юаня (Tang Yuan), которые адаптировали часть ранних версий реализаций на MXNet к PyTorch и TensorFlow соответственно. Мы благодарим команду Baidu, которая адаптировала более новые реализации на PyTorch к PaddlePaddle. Мы благодарим Чжан Шуая (Zhang Shuai) за интеграцию обновлённого стиля LaTeX в сборку PDF-файла.

Особо мы хотим поблагодарить каждого, кто участвовал в работе над китайской версией, — их самоотверженный труд сделал эту книгу лучше. Их идентификаторы на GitHub или имена (в произвольном порядке): alxnorden, avinashingit, bowen0701, brettkoonce, Chaitanya Prakash Bapat, cryptonaut, Davide Fiocco, edgarroman, gkutiel, John Mitro, Liang Pu, Rahul Agarwal, Mohamed Ali Jamaoui, Michael (Stu) Stewart, Mike Müller, NRauschmayr, Prakhar Srivastav, sad-, sfermigier, Sheng Zha, sundeepteki, topecongiro, tpdi, vermicelli, Vishaal Kapoor, Vishwesh Ravi Shrimali, YaYaB, Yuhong Chen, Evgeniy Smirnov, lgov, Simon Corston-Oliver, Igor Dzreyev, Ha Nguyen, pmuens, Andrei Lukovenko, senorcinco, vfdev-5, dsweet, Mohammad Mahdi Rahimi, Abhishek Gupta, uwsd, DomKM, Lisa Oakley, Bowen Li, Aarush Ahuja, Prasanth Buddareddygari, brianhendee, mani2106, mtn, lkevinzc, caojilin, Lakshya, Fiete Lüer, Surbhi Vijayvargeeya, Muhyun Kim, dennismalmgren, adursun, Anirudh Dagar, liqingnz, Pedro Larroy, lgov, ati-ozgur, Jun Wu, Matthias Blume, Lin Yuan, geogunow, Josh Gardner, Maximilian Böther, Rakib Islam, Leonard Lausen, Abhinav Upadhyay, rongruosong, Steve Sedlmeyer, Ruslan Baratov, Rafael Schlatter, liusy182, Giannis Pappas, ati-ozgur, qbaza, dchoi77, Adam Gerson, Phuc Le, Mark Atwood, christabella, vn09, Haibin Lin, jjangga0214, RichyChen, noelo, hansent, Giel Dops, dvincent1337, WhiteD3vil, Peter Kulits, codypenta, joseppinilla, ahmaurya, karolszk, heytitle, Peter Goetz, rigtorp, Tiep Vu, sfilip, mlxd, Kale-ab Tessera, Sanjar Adilov, MatteoFerrara, hsneto, Katarzyna Biesialska, Gregory Bruss, Duy–Thanh Doan, paulaurel, graytowne, Duc Pham, sl7423, Jaedong Hwang, Yida Wang, cys4, clhm, Jean Kaddour, austinmw, trebeljahr, tbaums, Cuong V. Nguyen, pavelkomarov, vzlamal, NotAnotherSystem, J-Arun-Mani, jancio, eldarkurtic, the-great-shazbot, doctorcolossus, gducharme, cclauss, Daniel-Mietchen, hoonose, biagiom, abhinavsp0730, jonathanhrandall, ysraell, Nodar Okroshiashvili, UgurKap, Jiyang Kang, StevenJokes, Tomer Kaftan, liweiwp, netyster, ypandya, NishantTharani, heiligerl, SportsTHU, Hoa Nguyen, manuel-arno-korfmann-webentwicklung, aterzis-personal, nxby, Xiaoting He, Josiah Yoder, mathresearch, mzz2017, jroberayalas, iluu, ghejc, BSharmi, vkramdev, simonwardjones, LakshKD, TalNeoran, djliden, Nikhil95, Oren Barkan, guoweis, haozhu233, pratikhack, 315930399, tayfununal, steinsag, charleybeller, Andrew Lumsdaine, Jiekui Zhang, Deepak Pathak, Florian Donhauser, Tim Gates, Adriaan Tijsseling, Ron Medina, Gaurav Saha, Murat Semerci, Lei Mao, Zhu Yuanxiang, thebesttv, Quanshangze Du, Yanbo Chen.

Мы благодарим Amazon Web Services, и в особенности Свами Сивасубраманиана (Swami Sivasubramanian), Питера ДеСантиса (Peter DeSantis), Адама Селипски (Adam Selipsky) и Эндрю Джесси (Andrew Jassy), за щедрую поддержку работы над этой книгой. Без доступного времени, ресурсов, обсуждений с коллегами и постоянного ободрения эта книга не была бы написана.

Резюме

• Глубокое обучение произвело переворот в распознавании образов, предложив набор технологий, которые применяются в компьютерном зрении, обработке естественного языка и автоматическом распознавании речи.
• Чтобы успешно применять глубокое обучение, необходимо понимать, как сформулировать задачу, математику моделирования, алгоритмы подгонки моделей к данным и инженерные приёмы, с помощью которых всё это реализуется.
• Эта книга — всесторонний ресурс, в котором текст, рисунки, математика и код собраны в одном месте.
• Чтобы получить ответы на вопросы, связанные с этой книгой, зайдите на наш форум discuss.d2l.ai.
• Все блокноты Jupyter можно скачать на GitHub.

Упражнения

1. Зарегистрируйте учётную запись на форуме этой книги discuss.d2l.ai.
2. Установите Python на свой компьютер.
3. Перейдите по ссылкам в конце раздела на форум: там вы можете попросить о помощи, обсудить книгу и найти ответы на вопросы, общаясь с авторами и сообществом.

MXNet: Обсуждение

PyTorch: Обсуждение

TensorFlow: Обсуждение

PaddlePaddle: Обсуждение

Литература

• Bishop, C. M. (2006). Pattern recognition and machine learning. Springer.

• Bollobás, B. (1999). Linear analysis. Cambridge University Press.

• Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep learning. MIT Press. http://www.deeplearningbook.org

• Wasserman, L. (2013). All of statistics: A concise course in statistical inference. Springer Science & Business Media.

• Bollobás, B. (1999). Linear analysis. Cambridge University Press.

Установка

Чтобы быстро начать работу и получить практический опыт, нам нужно настроить среду для запуска Python, Jupyter Notebook, необходимых библиотек и кода этой книги.

Установка Miniconda

Проще всего установить Miniconda, которая работает на Python 3.x. Если conda уже установлена, следующие шаги можно пропустить. Зайдите на сайт Miniconda и выберите подходящую версию в соответствии с вашей версией Python 3.x.

Если вы используете macOS и версия Python — 3.9 (на ней мы тестировали код), скачайте bash-скрипт, в имени которого есть строка «MacOSX», и выполните следующее:

# Пример для процессора Intel; имя файла может отличаться
sh Miniconda3-py39_4.12.0-MacOSX-x86_64.sh -b

Если вы используете Linux и версия Python — 3.9 (на ней мы тестировали код), скачайте bash-скрипт, в имени которого есть строка «Linux», и выполните следующее:

# Имя файла может отличаться
sh Miniconda3-py39_4.12.0-Linux-x86_64.sh -b

Затем инициализируйте оболочку терминала, чтобы можно было запускать conda напрямую.

~/miniconda3/bin/conda init

Теперь закройте и заново откройте текущую оболочку. Создайте новое окружение командой:

conda create --name d2l python=3.9 -y

Теперь активируйте окружение d2l:

conda activate d2l

Установка фреймворка глубокого обучения и пакета d2l

Перед установкой фреймворка глубокого обучения проверьте, есть ли на компьютере доступный GPU. Например, посмотрите, установлен ли на компьютере GPU NVIDIA и CUDA. Если на машине нет GPU, беспокоиться не стоит: для первых глав вполне достаточно CPU. Но если вы хотите комфортно пройти все главы, заранее обзаведитесь GPU и установите GPU-версию фреймворка глубокого обучения.

MXNet: чтобы установить GPU-версию MXNet, сначала нужно узнать установленную версию CUDA (это можно проверить командой nvcc --version или cat /usr/local/cuda/version.txt). Предположим, что установлена CUDA 10.1; выполните следующие команды:

# Для пользователей Linux и macOS
pip install mxnet-cu101==1.7.0

# Для пользователей Windows
pip install mxnet-cu101==1.7.0 -f https://dist.mxnet.io/python

Число в конце mxnet-cu101 можно менять в соответствии с версией CUDA, например: для CUDA 10.0 — cu100, для CUDA 9.0 — cu90.

Если на машине нет GPU NVIDIA или CUDA, CPU-версию MXNet можно установить так:

pip install mxnet==1.7.0.post1

PyTorch: CPU- или GPU-версию PyTorch можно установить так:

pip install torch==1.12.0
pip install torchvision==0.13.0

TensorFlow: CPU- или GPU-версию TensorFlow можно установить так:

pip install tensorflow==2.8.0
pip install tensorflow-probability==0.16.0

PaddlePaddle: чтобы установить GPU-версию PaddlePaddle, сначала нужно узнать установленную версию CUDA (это можно проверить командой nvcc --version или cat /usr/local/cuda/version.txt). Предположим, что установлена CUDA 11.2; выполните следующую команду:

python -m pip install paddlepaddle-gpu==2.3.2.post112 -f https://www.paddlepaddle.org.cn/whl/linux/mkl/avx/stable.html

Если на машине нет GPU NVIDIA или CUDA, CPU-версию PaddlePaddle можно установить так:

# Параметр -i задаёт зеркало PyPI университета Цинхуа; его можно опустить
python -m pip install paddlepaddle==2.3.2 -i https://pypi.tuna.tsinghua.edu.cn/simple

Следующий шаг — установить пакет d2l, чтобы было удобно вызывать функции и классы, которые часто используются в книге:

pip install d2l==0.17.6

Скачивание блокнотов D2L

Далее нужно скачать код книги. Можно скачать и распаковать его, выбрав пункт с блокнотами Jupyter вверху HTML-страницы книги на сайте оригинала zh.d2l.ai, либо загрузить следующим образом:

mkdir d2l-zh && cd d2l-zh
curl https://zh-v2.d2l.ai/d2l-zh-2.0.0.zip -o d2l-zh.zip
unzip d2l-zh.zip && rm d2l-zh.zip
cd mxnet

mkdir d2l-zh && cd d2l-zh
curl https://zh-v2.d2l.ai/d2l-zh-2.0.0.zip -o d2l-zh.zip
unzip d2l-zh.zip && rm d2l-zh.zip
cd pytorch

mkdir d2l-zh && cd d2l-zh
curl https://zh-v2.d2l.ai/d2l-zh-2.0.0.zip -o d2l-zh.zip
unzip d2l-zh.zip && rm d2l-zh.zip
cd tensorflow

mkdir d2l-zh && cd d2l-zh
curl https://zh-v2.d2l.ai/d2l-zh-2.0.0.zip -o d2l-zh.zip
unzip d2l-zh.zip && rm d2l-zh.zip
cd paddle

Примечание: если unzip не установлен, его можно установить командой sudo apt install unzip.

После установки откройте Jupyter Notebook командой (в командной строке Windows перед запуском этой команды сначала перейдите в каталог с только что распакованным кодом книги):

jupyter notebook

Теперь откройте в браузере http://localhost:8888 (обычно он открывается автоматически). После этого можно запускать код каждого раздела книги. Перед запуском кода книги, обновлением фреймворка глубокого обучения или пакета d2l всегда выполняйте conda activate d2l, чтобы активировать среду выполнения. Чтобы выйти из окружения, выполните conda deactivate.

MXNet: Обсуждение

PyTorch: Обсуждение

TensorFlow: Обсуждение

PaddlePaddle: Обсуждение

Обозначения

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

Числа

• $x$ — скаляр
• $\mathbf{x}$ — вектор
• $\mathbf{X}$ — матрица
• $\mathsf{X}$ — тензор
• $\mathbf{I}$ — единичная матрица
• $x_i$, $[\mathbf{x}{]}_i$ — $i$-й элемент вектора $\mathbf{x}$
• $x_{ij}$, $[\mathbf{X}{]}_{ij}$ — элемент матрицы $\mathbf{X}$ в $i$-й строке и $j$-м столбце

Теория множеств

• $\mathcal{X}$ — множество
• $\mathbb{Z}$ — множество целых чисел
• $\mathbb{R}$ — множество действительных чисел
• ${\mathbb{R}}^n$ — множество $n$-мерных действительных векторов
• ${\mathbb{R}}^{a\times b}$ — множество действительных матриц с $a$ строками и $b$ столбцами
• $\mathcal{A}\cup \mathcal{B}$ — объединение множеств $\mathcal{A}$ и $\mathcal{B}$
• $\mathcal{A}\cap \mathcal{B}$ — пересечение множеств $\mathcal{A}$ и $\mathcal{B}$
• $\mathcal{A}\setminus \mathcal{B}$ — разность множеств $\mathcal{A}$ и $\mathcal{B}$ (относительное дополнение $\mathcal{B}$ до $\mathcal{A}$)

Функции и операторы

• $f(\cdot )$ — функция
• $\log (\cdot )$ — натуральный логарифм
• $\exp (\cdot )$ — показательная функция
• $1_{\mathcal{X}}$ — индикаторная функция
• ${(\cdot )}^{\top }$ — транспонирование вектора или матрицы
• ${\mathbf{X}}^{-1}$ — обратная матрица
• $\odot$ — поэлементное умножение
• $[\cdot ,\cdot ]$ — конкатенация
• $|\mathcal{X}|$ — мощность множества
• $\Vert \cdot {\Vert }_p$ — норма $L_p$
• $\Vert \cdot \Vert$ — норма $L_2$
• $⟨\mathbf{x},\mathbf{y}⟩$ — скалярное произведение векторов $\mathbf{x}$ и $\mathbf{y}$
• $\sum$ — сумма
• $\prod$ — произведение
• $\stackrel{\mathrm{def}}{=}$ — определение

Математический анализ

• $\frac{dy}{dx}$ — производная $y$ по $x$
• $\frac{\partial y}{\partial x}$ — частная производная $y$ по $x$
• ${\nabla }_{\mathbf{x}}y$ — градиент $y$ по $\mathbf{x}$
• ${\int }_a^{b}f(x)dx$ — определённый интеграл $f$ по $x$ на отрезке от $a$ до $b$
• $\int f(x)dx$ — неопределённый интеграл $f$ по $x$

Теория вероятностей и теория информации

• $P(\cdot )$ — распределение вероятностей
• $z\sim P$ — случайная величина $z$ имеет распределение вероятностей $P$
• $P(X\mid Y)$ — условная вероятность $X$ при условии $Y$
• $p(x)$ — функция плотности вероятности
• $E_x[f(x)]$ — математическое ожидание функции $f$ по $x$
• $X\perp Y$ — случайные величины $X$ и $Y$ независимы
• $X\perp Y\mid Z$ — случайные величины $X$ и $Y$ условно независимы при заданной случайной величине $Z$
• $\mathrm{Var}(X)$ — дисперсия случайной величины $X$
• ${\sigma }_X$ — стандартное отклонение случайной величины $X$
• $\mathrm{Cov}(X,Y)$ — ковариация случайных величин $X$ и $Y$
• $\rho (X,Y)$ — корреляция случайных величин $X$ и $Y$
• $H(X)$ — энтропия случайной величины $X$
• $D_{\mathrm{KL}}(P\Vert Q)$ — дивергенция Кульбака — Лейблера между $P$ и $Q$

Сложность

• $\mathcal{O}$ — обозначение «O-большое»

Обсуждение

1. Введение

Ещё совсем недавно почти каждая компьютерная программа, с которой мы ежедневно сталкиваемся, создавалась разработчиками «с нуля». Допустим, нам нужно написать приложение для управления интернет-магазином. Несколько часов поломав голову у доски, мы, вероятно, набросали бы общие контуры решения примерно такого вида: сначала пользователь работает с приложением через интерфейс в веб-браузере или мобильном приложении; затем приложение обращается к движку базы данных, чтобы сохранять историю транзакций и отслеживать действия каждого пользователя. Главная часть такого приложения — «бизнес-логика», которая подробно описывает, что программа должна делать в каждой из возможных ситуаций.

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

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

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

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

Машинное обучение (machine learning, ML) — класс мощных методов, которые умеют учиться на опыте. Обычно алгоритм машинного обучения использует наблюдаемые данные или взаимодействие со средой, и по мере накопления опыта его качество растёт. Напротив, интернет-магазин из нашего примера, выполняющий одну и ту же бизнес-логику, не станет лучше, сколько бы опыта ни накопил, — если только разработчики не заметят проблему и не обновят программу. Эта книга проведёт читателя в мир машинного обучения и уделит особое внимание основам глубокого обучения (deep learning, DL). Глубокое обучение — мощный набор методов, который стимулирует прогресс в таких областях, как компьютерное зрение, обработка естественного языка, здравоохранение и геномика.

1.1 Машинное обучение в повседневной жизни

Машинное обучение окружает нас повсюду. Представим, что авторы этой книги вместе едут в кофейню. Астон достаёт iPhone и говорит: «Hey Siri!» — и система распознавания речи в телефоне просыпается. Затем Му Ли говорит Siri: «Поехали в кофейню Starbucks». Система распознавания речи автоматически переводит речь в текст и запускает приложение карт. Приложение, запустившись, отбирает несколько маршрутов и для каждого показывает расчётное время в пути…

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

Теперь предположим, что нам нужно написать программу, которая реагирует на «ключевое слово пробуждения» — например, «Alexa», «Сяо Ай Тунсюэ» (小爱同学) или «Hey Siri». Попробуем написать её на компьютере обычным редактором кода, как показано на рис. 1.1. Задача кажется трудноразрешимой: микрофон собирает около 44 000 отсчётов в секунду, и каждый из них — измерение амплитуды звуковой волны. Но это измерение нельзя напрямую связать с ключевым словом. Как написать программу, которая по сырому аудиофрагменту с микрофона надёжно выдаёт предсказание из множества $\{\text{да},\text{нет}\}$ — содержит ли фрагмент ключевое слово? Мы не знаем, как написать такую программу. Именно поэтому нужно машинное обучение.

Рис. 1.1. Распознавание ключевого слова

Как правило, даже если мы не знаем, как явно объяснить компьютеру, как по входу получить выход, наш мозг всё равно способен выполнять такие когнитивные функции. Иначе говоря, даже не зная, как написать программу, которая распознаёт слово «Alexa», наш мозг сам умеет его распознавать. Благодаря этой способности мы можем собрать набор данных (dataset) — большое количество аудиофрагментов, в которых помечено, есть ли в них ключевое слово. При использовании алгоритма машинного обучения нам не нужно «явно» конструировать систему, которая распознаёт ключевое слово. Вместо этого достаточно определить гибкую программную схему, поведение которой задаётся множеством параметров (parameter). Затем с помощью набора данных подбираются «наилучшие текущие значения параметров» — такие, при которых выбранная мера качества показывает наилучший результат выполнения задачи.

Что же такое параметры? Их можно представить как ручки настройки: поворачивая их, мы меняем поведение программы. Программа с конкретным набором настроенных параметров называется моделью (model). Совокупность всех различных программ (отображений «вход — выход», которые можно получить, меняя параметры) называется семейством моделей. Метапрограмма, которая использует набор данных, чтобы выбрать параметры, называется алгоритмом обучения (learning algorithm).

Прежде чем решать задачу с помощью алгоритма машинного обучения, мы должны точно её определить: установить, каковы вход (input) и выход (output), и выбрать подходящее семейство моделей. В нашем примере модель получает аудио в качестве входа и выдаёт выбор «да» или «нет». Если всё пойдёт хорошо, то после обучения модель обычно правильно предсказывает, содержит ли фрагмент ключевое слово.

Теперь модель каждый раз, когда слышит «Alexa», отвечает «да». Поскольку ключевое слово выбрано произвольно, нам может понадобиться достаточно богатое семейство моделей, чтобы в нём нашлись разные модели. Например, другая модель того же семейства будет отвечать «да» только на «Hey Siri». В идеале одно и то же семейство моделей должно подходить и для распознавания «Alexa», и для распознавания «Hey Siri», ведь интуитивно это похожие задачи. Однако если нам нужно работать с совершенно другими входами или выходами, например, преобразовывать изображение в подпись или текст с английского на китайский, может понадобиться совсем другое семейство моделей.

Но если все «кнопки» модели (её параметры) выставлены случайно, она вряд ли распознает «Alexa», «Hey Siri» или любое другое слово. В машинном обучении обучение (learning) — процесс тренировки модели. В ходе него мы находим правильный набор параметров, благодаря которому модель ведёт себя нужным образом. Иначе говоря, мы обучаем (train) модель на данных. Как показано на рис. 1.2, процесс обучения обычно включает следующие шаги:

1. Начинаем с модели со случайно заданными параметрами; такая модель пока ничего «не умеет».
2. Получаем примеры данных (например, аудиофрагменты и соответствующие метки «да» или «нет»).
3. Подстраиваем параметры так, чтобы модель лучше работала на этих примерах.
4. Повторяем шаги 2 и 3, пока работа модели над задачей не станет удовлетворительной.

Рис. 1.2. Типичный процесс обучения

Итак, вместо программы распознавания ключевого слова мы написали программу, которая учится. Если взять огромный размеченный набор данных, она, скорее всего, научится распознавать ключевое слово. Такой подход — «определять поведение программы с помощью набора данных» — можно назвать программированием с данными (programming with data). Например, можно сконструировать «детектор кошек», показав системе машинного обучения множество фотографий кошек и собак. Детектор в итоге научится выдавать очень большое положительное число для изображения кошки и очень маленькое отрицательное — для изображения собаки. Если же детектор не уверен, кошка или собака на снимке, он выдаст число, близкое к нулю…

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

1.2 Ключевые компоненты машинного обучения

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

1. данные (data), которые можно использовать для обучения;
2. модель (model), которая преобразует данные;
3. целевая функция (objective function), которая количественно выражает эффективность модели;
4. алгоритм (algorithm), который подстраивает параметры модели для оптимизации целевой функции.

1.2.1 Данные

Без данных нет и науки о данных. Каждый набор данных состоит из отдельных примеров (example, sample), которые, как правило, подчиняются условию независимости и одинаковой распределённости (independently and identically distributed, i.i.d.). Примеры иногда называют точками данных (data point) или экземплярами данных (data instance). Обычно каждый пример описывается набором признаков (features, или ковариат (covariates)), на основе которых модель машинного обучения делает предсказания. В задачах обучения с учителем особый атрибут, который нужно предсказать, называется меткой (label, или целевым значением (target)).

При работе с изображениями каждая фотография — это пример, а её признаки задаются упорядоченным списком значений для каждого пикселя. Например, цветная фотография размером $200\times 200$ состоит из $200\times 200\times 3=120000$ чисел, где «3» соответствует интенсивности красного, зелёного и синего каналов в каждой точке. Или возьмём медицинские данные: при заданном наборе стандартных признаков (возраста, жизненных показателей, диагнозов) по ним можно пытаться предсказать, выживет ли пациент.

Если у всех примеров одно и то же число признаков, то вектор признаков имеет фиксированную длину; эта длина называется размерностью (dimensionality) данных. Фиксированная длина вектора признаков — удобное свойство: она избавляет от лишних забот и позволяет единообразно обрабатывать большое количество примеров.

Однако не все данные можно представить векторами фиксированной длины. Например, если изображения получены со стандартного микроскопа, фиксированный размер разумен, но изображения из интернета вряд ли будут иметь одинаковое разрешение или форму. Можно обрезать их до стандартного размера, но этот приём ограничен и грозит потерей информации. Текстовые данные ещё меньше подходят под требование фиксированной длины: например, в отзывах покупателей на таких сайтах, как Amazon, одни тексты очень короткие («Отлично!»), а другие — длинные. По сравнению с традиционными методами машинного обучения одно из главных преимуществ глубокого обучения — способность работать с данными разной длины.

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

Однако одних огромных объёмов данных недостаточно — нужны правильные данные. Если данные полны ошибок или их признаки не позволяют предсказать целевое значение, модель, скорее всего, окажется бесполезной. Эту мысль выражает известная поговорка: «Мусор на входе — мусор на выходе» («Garbage in, garbage out.»). Более того, плохие предсказания могут в разы усугубить последствия. В чувствительных приложениях — например, предиктивной полиции (predictive policing), отборе резюме и моделях кредитного риска — особенно важно помнить о последствиях «мусорных» данных.

Распространённая проблема — несбалансированные наборы данных: например, в медицинском обучающем наборе какие-то группы людей совсем не представлены. Представим, что мы хотим обучить модель распознавать рак кожи, но эта модель (на обучающем наборе) никогда не «видела» людей с тёмной кожей. Тогда она окажется беспомощной.

Другой пример: если обучить модель отбора резюме на «прошлых решениях о найме», модель может незаметно перенять исторические несправедливости и автоматизировать их. И всё это может происходить без чьего-либо ведома. Поэтому, когда данные недостаточно репрезентативны или содержат социальные предубеждения, модель с высокой вероятностью будет предвзятой.

1.2.2 Модель

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

1.2.3 Целевая функция

Выше машинное обучение определялось как «обучение на опыте». Под «обучением» здесь понимается способность модели самостоятельно улучшать выполнение задачи. Но что считать настоящим улучшением?

В машинном обучении нужно определить меру того, насколько хороша или плоха модель. В большинстве случаев такую меру можно оптимизировать. Её называют целевой функцией (objective function).

Обычно целевую функцию задают так, чтобы её минимизировали, — ведь чем меньше, тем лучше. Поэтому такие функции иногда называют функциями потерь (loss function, или cost function). Но это лишь соглашение: можно взять и другую функцию и максимизировать её. Эти два подхода по сути эквивалентны и отличаются только знаком.

Когда задача состоит в предсказании числовых значений, самая распространённая функция потерь — квадратичная ошибка (squared error): квадрат разности между предсказанным и фактическим значениями. Для задач классификации чаще всего минимизируют долю ошибок — долю примеров, для которых предсказание не совпало с действительностью. Одни целевые функции (например, квадратичную ошибку) легко оптимизировать, а другие (например, долю ошибок) трудно оптимизировать напрямую из-за недифференцируемости или других сложностей. В таких случаях обычно оптимизируют суррогатную цель (surrogate objective).

Обычно функция потерь определяется через параметры модели и зависит от набора данных. На одном наборе данных мы можем найти наилучшие значения параметров, минимизируя суммарные потери. Набор данных, собранный для обучения, называется обучающим набором данных (training dataset, или обучающим набором (training set)). Однако модель, которая хорошо работает на обучающих данных, не обязательно покажет такой же результат на «новых данных». Эти новые данные обычно называют тестовым набором данных (test dataset, или тестовым набором (test set)).

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

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

1.2.4 Алгоритм оптимизации

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

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

1.3 Виды задач машинного обучения

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

1.3.1 Обучение с учителем

Обучение с учителем (supervised learning) хорошо справляется с предсказанием меток по заданным входным признакам. Каждая пара «признаки — метка» называется примером (example). Иногда, даже когда метка неизвестна, примером называют и просто входные признаки. Наша цель — построить модель, которая отображает любой вектор входных признаков в метку, то есть делает предсказание.

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

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

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

• по снимку компьютерной томографии (КТ) опухоли определить, является ли она раковой;
• по английскому предложению предсказать правильный перевод на французский;
• по финансовым отчётам за текущий месяц спрогнозировать цену акций на следующий месяц.

Процесс обучения с учителем обычно делится на три большие части:

1. Случайным образом выбрать подмножество из большого набора известных примеров и получить для каждого из них истинную метку. Иногда метки уже есть (например, выздоровел ли пациент в течение года?), иногда их нужно разметить вручную (например, при классификации изображений). Входы вместе с соответствующими метками образуют обучающий набор данных.
2. Выбрать алгоритм обучения с учителем, который получает на вход обучающий набор данных и возвращает «обученную модель».
3. Подать на вход обученной модели признаки ранее не встречавшихся примеров и использовать её выход как предсказание соответствующей метки.

Весь процесс обучения с учителем показан на рис. 1.3.

Рис. 1.3. Обучение с учителем

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

1.3.1.1 Регрессия

Регрессия (regression) — одна из простейших задач обучения с учителем.

Допустим, есть таблица данных о продаже домов: каждая строка соответствует дому, каждый столбец — связанному с ним атрибуту, например площади, количеству спален, количеству ванных комнат, расстоянию пешком до центра города и т. д. Атрибуты каждой строки образуют вектор признаков одного дома. Если человек живёт в Нью-Йорке или в Сан-Франциско и он не является генеральным директором Amazon, Google, Microsoft или Facebook, то вектор признаков его дома (площадь, количество спален, количество ванных комнат, расстояние пешком) может выглядеть примерно так: $[600,1,1,60]$. Если же человек живёт в Питтсбурге, вектор, скорее всего, будет ближе к $[3000,4,3,10]$…

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

Многие задачи из жизни относятся к регрессии. Например, предсказание оценки, которую пользователь поставит фильму, — задача регрессии. Любопытный факт: в 2009 году тот, кто придумал отличный алгоритм предсказания оценок фильмов, мог бы выиграть премию Netflix Prize в 1 миллион долларов. Ещё один пример — предсказание того, сколько дней пациент пробудет в больнице.

В целом хорошее эмпирическое правило таково: если вопрос касается «сколько», скорее всего, перед нами задача регрессии. Например:

• сколько часов займёт эта операция;
• сколько миллиметров осадков выпадет в городе за следующие 6 часов.

Даже если вы никогда не использовали машинное обучение, вы, возможно, уже неявно решали задачи регрессии. Например, вы вызвали сантехника, он три часа чистил канализационную трубу и выставил счёт на 350 долларов. Ваш друг нанял того же мастера на 2 часа и получил счёт на 250 долларов. Если кто-то попросит вас оценить стоимость очистки от засора, вы можете предположить, что мастер берёт фиксированную плату за выезд и затем почасовую оплату. Если эти допущения верны, то, имея два примера, вы уже можете определить структуру его тарифов: 50 долларов за выезд и ещё 100 долларов в час. Таким образом, сами того не заметив, вы поняли и применили алгоритм линейной регрессии.

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

1.3.1.2 Классификация

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

Вопросы вида «какой именно» относятся к задачам классификации (classification). В задаче классификации модель предсказывает, к какой категории (category, формально — классу (class)) относится пример. Например, рукописные цифры могут относиться к 10 классам: метками будут числа от 0 до 9.

Простейший случай — когда классов всего два; это называется бинарной классификацией (binomial classification). Например, набор данных может состоять из изображений животных, а метки — из двух классов: {кошка, собака}. Регрессия обучает функцию, которая выдаёт число; классификация обучает классификатор, который выдаёт предсказанный класс.

Но как модель приходит к жёсткому предсказанию «да» или «нет»? Понять это можно через язык вероятностей: по признакам примера модель назначает каждому возможному классу вероятность. Например, в уже знакомом примере с кошками и собаками классификатор может выдать вероятность 0,9 того, что на изображении кошка. Что означает это число? Его можно понимать так: классификатор на 90% уверен, что изображена кошка. Величина вероятностей классов передаёт меру неопределённости модели; в последующих главах книги мы обсудим и другие алгоритмы, которые используют понятие неопределённости.

Когда классов больше двух, задача называется многоклассовой классификацией (multiclass classification). Распространённый пример — распознавание рукописных символов $\{0,1,2,\dots 9,\mathrm{a},\mathrm{b},\mathrm{c},\dots \}$. В отличие от регрессии, стандартная функция потерь для задач классификации — кросс-энтропия (cross-entropy), которая подробно разбирается в разделе 3.4 «Softmax-регрессия».

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

Рис. 1.4. Бледная поганка — есть нельзя!!

Теперь мы хотим обучить детектор ядовитых грибов, который по фотографии предсказывает, ядовит ли гриб. Предположим, классификатор выдаёт для гриба с рис. 1.4 вероятность 0,2 того, что это бледная поганка. Иначе говоря, классификатор на 80% уверен, что гриб не бледная поганка. Тем не менее мы его есть не станем: не стоит рисковать 20% вероятностью смерти. Неопределённость риска весит для нас гораздо больше, чем выгода. Поэтому в качестве функции потерь нужно использовать ожидаемый риск: вероятность каждого исхода умножить на связанный с ним выигрыш (или ущерб). В этом случае потери от употребления гриба равны $0.2\times \infty +0.8\times 0=\infty$, а потери от того, что мы его выбросим, равны $0.2\times 0+0.8\times 1=0.8$. Осторожность, как выясняется, была оправдана: гриб с рис. 1.4 действительно является бледной поганкой.

Классификация может быть гораздо сложнее двоичной или многоклассовой. Например, существуют варианты задач классификации, которые используют иерархию и предполагают наличие определённых связей между классами. Поэтому не все ошибки равноценны: люди предпочли бы ошибиться, отнеся объект к близкому классу, а не к далёкому. Это обычно называют иерархической классификацией (hierarchical classification). Ранний пример — Карл Линней, который построил иерархическую классификацию животных.

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

1.3.1.3 Задачи разметки

Некоторые задачи классификации хорошо подходят для двоичной или многоклассовой классификации. Например, можно обучить обычный двоичный классификатор, который отличает кошек от собак. С помощью современных алгоритмов компьютерного зрения такую модель обучить несложно. Однако, как бы точна она ни была, при встрече с новым животным она может растеряться. Например, на рис. 1.5 показана иллюстрация к популярной немецкой сказке «Бременские музыканты»: на фоне деревьев изображены кот, петух, собака и осёл. В зависимости от того, что именно мы хотим делать с моделью, считать эту задачу двоичной классификацией может не иметь смысла. Вместо этого мы, возможно, захотим, чтобы модель описывала содержимое входного изображения: кот, петух, собака и осёл.

Рис. 1.5. Кот, петух, собака и осёл

Задачи предсказания нескольких не исключающих друг друга классов называются многометочной классификацией (multi-label classification). Например, метки, которые авторы технических блогов ставят своим постам: «машинное обучение», «технологии», «гаджеты», «языки программирования», «Linux», «облачные вычисления», «AWS». Типичная статья получает 5–10 меток, потому что эти понятия связаны между собой: пост об облачных вычислениях может упоминать AWS, а пост о машинном обучении — языки программирования.

Подобные задачи встречаются и при обработке биомедицинской литературы. Правильная разметка публикаций важна: она помогает исследователям эффективно просматривать литературу. В Национальной медицинской библиотеке США (The United States National Library of Medicine) специалисты-аннотаторы просматривают каждую статью, индексируемую в PubMed, и связывают её с соответствующими терминами из MeSH (MeSH — набор примерно из 28 000 меток). Это очень трудоёмкий процесс: между архивированием статьи и её разметкой обычно проходит год. Здесь алгоритмы машинного обучения могут выставлять предварительные метки, пока каждая статья не получит строгой ручной проверки. Кстати, в последние годы организация BioASQ проводит соревнования именно по этой задаче.

1.3.1.4 Поиск

Иногда нам нужно не просто вывести класс или вещественное значение, а упорядочить набор объектов. В информационном поиске именно это и требуется. Например, в веб-поиске цель — не просто классифицировать пару «запрос — страница», а из огромного множества результатов найти те, которые нужнее всего пользователю. Порядок результатов тоже очень важен: алгоритм обучения должен выдавать упорядоченное подмножество элементов. Иначе говоря, если нужно вернуть первые 5 букв алфавита, ответы «A, B, C, D, E» и «C, A, B, E, D» различаются. Даже если набор результатов одинаков, порядок внутри него иногда оказывается важным.

Одно из возможных решений: сначала присвоить каждому элементу набора оценку релевантности, а затем выбрать элементы с наивысшими оценками. PageRank — ранний пример такой системы оценок, с которой начинался поисковик Google; но её особенность в том, что она не зависит от конкретного запроса. В этом подходе поисковая система сначала применяет простой фильтр релевантности, чтобы выделить набор подходящих записей, а затем ранжирует результаты, содержащие условия запроса, по PageRank. Сегодня поисковые системы используют машинное обучение и модели поведения пользователей, чтобы получать оценки релевантности веб-страниц, и многие научные конференции посвящены этой теме.

1.3.1.5 Рекомендательные системы

Другой класс задач, связанных с поиском и ранжированием, — рекомендательные системы (recommender systems). Их цель — персонализированные рекомендации конкретному пользователю. Например, для фильмов страницы рекомендаций у любителей научной фантастики и у любителей комедий могут сильно различаться. Похожие приложения встречаются в розничной торговле, музыке и новостях.

В некоторых приложениях клиенты дают явную обратную связь, выражая свою симпатию к товарам, например через оценки и отзывы на Amazon. В других случаях обратная связь неявная: например, если пользователь пропускает некоторые песни в плейлисте, это может говорить о том, что эти песни ему не подходят. В целом рекомендательная система оценивает соответствие пары «пользователь — объект»; эта оценка может быть предсказанным рейтингом или вероятностью покупки. Затем для каждого пользователя система выбирает объекты с наивысшими оценками и рекомендует их. Описанные алгоритмы просты; промышленные рекомендательные системы устроены гораздо сложнее и учитывают подробную активность пользователя и характеристики товаров. Алгоритмы таких систем настраиваются так, чтобы улавливать предпочтения человека.

Например, на рис. 1.6 показаны книги по глубокому обучению, которые Amazon рекомендует на основе персонализированного алгоритма; рекомендации точно уловили интересы автора.

Рис. 1.6. Книги по глубокому обучению, рекомендованные Amazon на основе персонализированного алгоритма. Скриншот страницы стороннего сайта не включён в перевод

Несмотря на большую практическую ценность, использовать рекомендательные системы только как модели предсказания не всегда достаточно. Во-первых, наши данные содержат лишь цензурированную обратную связь (censored feedback): пользователи склонны оценивать то, что вызвало у них сильные эмоции. Например, в пятибалльной системе оценок фильмов будет много пятёрок и единиц, а троек — заметно меньше. Во-вторых, рекомендательные системы могут образовывать петли обратной связи (feedback loop). Система сначала продвигает товар с большими продажами (который, возможно, считается лучшим); пользователи затем покупают то, что им рекомендуют, и алгоритм обучения, не учитывая этого эффекта, будет рекомендовать такой товар ещё чаще. Итак, вопросы о том, как учитывать цензуру, стимулы и петли обратной связи, — важные открытые исследовательские проблемы.

1.3.1.6 Обучение последовательностям

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

Если примеры на входе не связаны между собой, такие модели могут работать идеально. Но если вход непрерывен, модели может понадобиться «память». Например, как обрабатывать видеоклип? Каждый клип может состоять из разного числа кадров. Зная предыдущий кадр, мы можем лучше предсказать происходящее в следующем. То же касается языка: входы и выходы машинного перевода — тоже последовательности слов.

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

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

Разметка и синтаксический разбор. Это аннотирование текстовой последовательности атрибутами. Иначе говоря, число входов и выходов в основном одинаково. Например, мы можем захотеть узнать, где находятся глагол и подлежащее, или какие слова являются именованными сущностями. Обычно цель — разобрать и аннотировать текст на основе структурных и грамматических предположений, чтобы получить какие-то аннотации. Это звучит гораздо сложнее, чем есть на самом деле. Ниже приведён очень простой пример: предложение аннотировано «метками», которые показывают, какие слова обозначают именованные сущности. Метка «Ent» — сокращение от сущность (entity).

Том  ужинает  в  Вашингтоне  с  Салли
Ent  -        -  Ent         -  Ent

Автоматическое распознавание речи. В распознавании речи входная последовательность — запись речи говорящего (см. рис. 1.7), а выходная — текстовая расшифровка сказанного. Трудность в том, что аудиокадров значительно больше, чем слов в тексте: звук обычно оцифровывается с частотой 8 или 16 кГц. То есть соответствия 1:1 между аудио и текстом нет: тысячи отсчётов могут соответствовать одному слову. Это тоже задача «последовательность в последовательность», в которой выход гораздо короче входа.

Рис. 1.7. «-D-e-e-p- L-ea-r-ni-ng-» в записи

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

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

Немецкий:              Haben Sie sich schon dieses grossartige Lehrwerk angeschaut?
Английский:            Did you already check out this excellent tutorial?
Неверное выравнивание: Did you yourself already this excellent tutorial looked-at?

Другие задачи тоже используют обучение последовательностям. Например, определение порядка, в котором пользователь читает веб-страницу, — задача двумерного анализа макета. Диалоговые задачи сложнее: чтобы определить следующую реплику в диалоге, нужно учитывать историю беседы и знания о реальном мире… Все эти направления — горячие темы в исследованиях обучения последовательностям.

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

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

Если же работа не имеет чёткой цели, приходится учиться «самостоятельно». Например, начальник может выдать большой массив данных и попросить провести по нему какое-то исследование в области науки о данных, не уточняя, каким должен быть результат. Задачи машинного обучения, в данных которых нет «целевого значения», обычно называют обучением без учителя (unsupervised learning); в последующих главах книги мы обсудим методы обучения без учителя. Итак, на какие вопросы может отвечать обучение без учителя? Рассмотрим несколько примеров.

• Кластеризация (clustering): можно ли разделить данные на группы без меток? Например, по набору фотографий разбить их на пейзажи, собак, младенцев, кошек и горные вершины. Или по истории просмотров веб-страниц пользователей выделить тех, чьё поведение похоже.
• Метод главных компонент (principal component analysis): можно ли найти небольшое число параметров, которые точно описывают линейно связанные свойства данных? Например, траекторию мяча можно описать его скоростью, диаметром и массой. Портные уже разработали небольшой набор параметров, довольно точно описывающих форму человеческого тела, чтобы подгонять одежду. Ещё один пример: существует ли в евклидовом пространстве представление объектов произвольной структуры, в котором символические свойства хорошо согласуются с отношениями между объектами? Такое представление может описывать сущности и их связи, например «Рим» $-$ «Италия» $+$ «Франция» $=$ «Париж».
• Причинность (causality) и вероятностные графические модели (probabilistic graphical models): можно ли описать первопричины многих наблюдаемых данных? Например, если у нас есть демографические данные о стоимости жилья, загрязнении, преступности, географии, образовании и зарплатах, можно ли выявить связи между ними, опираясь только на эмпирические данные?
• Генеративно-состязательные сети (generative adversarial networks): дают способ синтезировать данные, в том числе такие сложные неструктурированные данные, как изображения и аудио. Лежащий в основе статистический механизм — проверка, неотличимы ли настоящие данные от поддельных. Это ещё одна важная и захватывающая область обучения без учителя.

1.3.3 Взаимодействие со средой

Некоторые задаются вопросом: откуда берутся входные данные машинного обучения и куда направляются его выходы? До сих пор, будь то обучение с учителем или без, мы заранее получали большой объём данных, затем запускали модель и больше не взаимодействовали со средой. Всё обучение происходило отдельно от среды; такое обучение называют офлайн-обучением (offline learning).

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

Рис. 1.8. Сбор данных из среды для обучения с учителем

У простого офлайн-обучения есть своя привлекательность: можно изолированно заниматься распознаванием образов, не отвлекаясь на другие задачи. Но недостаток в том, что круг решаемых задач довольно ограничен. Поэтому от искусственного интеллекта мы ожидаем не только предсказаний, но и взаимодействия с реальной средой. В отличие от предсказания, «взаимодействие со средой» действительно влияет на неё. Здесь ИИ — это «интеллектуальный агент», а не просто «модель предсказания». Значит, нужно учитывать, что его действия могут влиять на будущие наблюдения.

Рассмотрение взаимодействия со средой открывает целый ряд новых задач моделирования. Вот несколько примеров:

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

Последний вопрос ведёт к проблеме сдвига распределения (distribution shift): обучающие и тестовые данные различаются. Далее кратко описана задача обучения с подкреплением — класс задач, которые явно учитывают взаимодействие со средой.

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

Если вас интересует разработка систем, которые взаимодействуют со средой и выполняют действия, машинное обучение, скорее всего, приведёт вас к обучению с подкреплением (reinforcement learning). Оно может применяться в робототехнике, диалоговых системах и даже при создании ИИ для видеоигр. Глубокое обучение с подкреплением (deep reinforcement learning), в котором глубокое обучение применяется к задачам обучения с подкреплением, — очень популярная область исследований. Прорывными примерами стали глубокая Q-сеть (Q-network), которая победила людей в играх Atari, используя только визуальный вход, и программа AlphaGo, которая обыграла чемпиона мира по го.

В задаче обучения с подкреплением агент (agent) взаимодействует со средой в последовательности временных шагов. В каждый момент времени агент получает от среды наблюдение (observation) и должен выбрать действие (action), которое передаётся обратно в среду через некоторый механизм (его иногда называют исполнительным устройством). После этого агент получает от среды награду (reward). Затем начинается новый цикл: агент получает последующее наблюдение, выбирает следующее действие и т. д. Процесс обучения с подкреплением показан на рис. 1.9. Обратите внимание: цель обучения с подкреплением — получить хорошую стратегию (policy). Действие, которое выбирает агент, определяется стратегией — функцией, которая отображает наблюдения среды в действия.

Рис. 1.9. Взаимодействие обучения с подкреплением и среды

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

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

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

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

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

Общая задача обучения с подкреплением очень широка. Действия агента влияют на последующие наблюдения, а награда связана только с выбранными действиями. Среда может быть полностью или частично наблюдаемой; разобрать все эти сложности было бы слишком трудно даже исследователям. Кроме того, не каждая практическая задача обладает всеми этими сложностями. Поэтому учёные изучают частные случаи задач обучения с подкреплением.

Если среда полностью наблюдаема, задача обучения с подкреплением называется марковским процессом принятия решений (Markov decision process). Если состояние не зависит от предыдущих действий, задача называется контекстуальным бандитом (contextual bandit problem). Если состояний нет и есть лишь набор изначально неизвестных действий с неизвестными наградами, это классическая задача многорукого бандита (multi-armed bandit problem).

1.4 Истоки

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

Например, распределение Бернулли названо в честь Якоба Бернулли (1654–1705). А нормальное распределение открыл Карл Фридрих Гаусс (1777–1855): он изобрёл алгоритм наименьших квадратов, который до сих пор используется для решения множества задач — от страховых расчётов до медицинской диагностики. Эти инструменты породили экспериментальный подход в естественных науках: например, закон Ома для тока и напряжения на резисторе прекрасно описывается линейной моделью.

Даже в Средние века математики обладали тонким чутьём в вопросах оценивания (estimation). Например, Якоб Кёбель (1460–1533) в своей книге по геометрии показывает, как через среднюю длину стоп 16 взрослых мужчин можно получить длину одного фута.

Рис. 1.10. Оценка длины одного фута

На рис. 1.10 показано, как работает эта оценка. Шестнадцать взрослых мужчин выстраиваются в ряд, ступня к ступне. Затем их общую длину делят на 16, получая оценку, которая и считается одним футом. Позднее алгоритм усовершенствовали, чтобы учесть стопы с необычными размерами: двух человек с самыми короткими и самыми длинными стопами исключают, а для остальных берут среднее. Это один из первых примеров усечённого среднего (trimmed mean estimate).

С накоплением и доступностью данных статистика по-настоящему расцвела. Рональд Фишер (1890–1962) внёс большой вклад в теорию статистики и её применение в генетике. Многие его алгоритмы (например, линейный дискриминантный анализ) и формулы (например, информационная матрица Фишера) до сих пор широко используются. Более того, набор данных об ирисах, который Фишер опубликовал в 1936 году, до сих пор иногда используется для проверки алгоритмов машинного обучения. Фишер также был сторонником евгеники, и это напоминает нам: этически сомнительное использование данных имеет такую же долгую историю, как и его продуктивное применение в промышленности и естественных науках.

Вторым источником влияния на машинное обучение стали информационная теория Клода Шеннона (1916–2001) и теория вычислений Алана Тьюринга (1912–1954). В своей знаменитой статье «Вычислительные машины и разум» (Turing, 1950) Тьюринг поставил вопрос: «Могут ли машины мыслить?» В описанном им тесте машину можно считать «разумной», если человеку-оценщику трудно отличить её ответы в текстовом диалоге от ответов человека.

Другое влияние пришло из нейробиологии и психологии. Один из самых ранних алгоритмов появился в пионерской книге Дональда Хебба (1904–1985) «Организация поведения» (Hebb, 1949). Хебб предположил, что нейроны обучаются через активное усиление связей. Этот принцип стал прототипом алгоритма обучения перцептрона Розенблатта и получил название «хеббовского обучения». Он также заложил основу многих алгоритмов стохастического градиентного спуска, которые используются в современном глубоком обучении: усиление желаемого поведения и ослабление нежелательного помогают получить в нейронной сети хорошие значения параметров.

Нейронные сети (neural networks) получили название по биологической аналогии. Более века назад (начиная с моделей Александра Бейна 1873 года и Джеймса Шеррингтона 1890 года) исследователи пытались собирать вычислительные схемы, похожие на сети взаимодействующих нейронов. Со временем биологические трактовки стали менее буквальными, но название сохранилось. В основе большинства современных сетей лежат несколько ключевых принципов:

• чередование линейных и нелинейных элементов обработки, которые обычно называют слоями (layers);
• использование правила цепочки (также называемого обратным распространением ошибки (backpropagation)) для одновременной настройки всех параметров сети.

После первого быстрого развития исследования нейронных сетей примерно с 1995 года застопорились и лишь в 2005 году начали понемногу оживать. Главных причин две. Во-первых, обучение сетей очень дорого в вычислительном отношении: в конце прошлого века оперативная память уже была достаточно вместительной, а вычислительной мощности не хватало. Во-вторых, наборы данных были относительно небольшими. Набор данных об ирисах Фишера был популярным инструментом проверки алгоритмов, а набор MNIST из 60 000 рукописных цифр считался огромным. С учётом нехватки данных и вычислительных ресурсов мощные статистические инструменты, такие как ядерные методы (kernel methods), решающие деревья (decision trees) и графовые модели (graph models), на практике показывали себя лучше. В отличие от нейронных сетей, эти алгоритмы не требуют недель обучения и обладают сильным теоретическим обоснованием, которое позволяет получать предсказуемые результаты.

1.5 Развитие глубокого обучения

Примерно с 2010 года нейросетевые алгоритмы, которые раньше казались вычислительно неосуществимыми, стали популярными. Причин две. Во-первых, появление интернет-компаний, обслуживающих сотни миллионов пользователей, сделало крупные наборы данных доступными. Во-вторых, распространение дешёвых и качественных датчиков, дешёвого хранения данных (закон Крайдера, Kryder’s law) и дешёвых вычислений (закон Мура), особенно благодаря распространению GPU, сделало огромную вычислительную мощность доступной.

Это показано в таблице 1.1.

Таблица 1.1. Объём данных, памяти и вычислительной мощности по десятилетиям

Очевидно, что оперативная память не поспевает за ростом данных. В то же время вычислительная мощность растёт быстрее, чем объём доступных данных. Это означает, что статистические модели должны становиться эффективнее по памяти (обычно этого добиваются добавлением нелинейности), а благодаря росту вычислительного бюджета могут тратить больше времени на оптимизацию параметров. Поэтому машинное обучение и статистика переместили внимание с (обобщённых) линейных моделей и ядерных методов на глубокие нейронные сети. Так появились многие «рабочие лошадки» глубокого обучения: многослойный перцептрон (McCulloch and Pitts, 1943), свёрточные нейронные сети (LeCun et al., 1998), долгая краткосрочная память (LSTM, Graves and Schmidhuber, 2005) и Q-обучение (Watkins and Dayan, 1992). После долгого периода забвения они были «открыты заново» в последнее десятилетие.

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

• Новые методы управления ёмкостью модели, например исключение (dropout) (Srivastava et al., 2014), помогают снизить риск переобучения. Это достигается внедрением шума во всю нейронную сеть (Bishop, 1995): на этапе обучения веса заменяются случайными величинами.
• Механизм внимания решает задачу, которая мучила статистику более века: как увеличить память и сложность системы, не увеличивая число обучаемых параметров. Исследователи нашли элегантное решение, используя обучаемые структуры-указатели (Bahdanau et al., 2014). Не нужно запоминать всю текстовую последовательность (например, для машинного перевода с представлением фиксированной размерности) — достаточно хранить указатели на промежуточные состояния процесса перевода. Это существенно повышает точность на длинных последовательностях, потому что модели больше не нужно помнить всю последовательность, прежде чем начать генерировать новую.
• Многоэтапные конструкции. Например, сети памяти (memory networks) (Sukhbaatar et al., 2015) и нейронные программисты-интерпретаторы (Reed and De Freitas, 2015). Они позволяют статистикам описывать итеративные методы вывода. Эти инструменты дают возможность многократно изменять внутреннее состояние глубокой нейронной сети и выполнять последующие шаги цепочки рассуждений — по аналогии с тем, как процессор меняет память в ходе вычислений.
• Ещё одно ключевое открытие — изобретение генеративно-состязательных сетей (generative adversarial networks) (Goodfellow et al., 2014). В традиционных моделях статистические методы оценки плотности и порождающих моделей были сосредоточены на поиске подходящего (обычно приближённого) вероятностного распределения и алгоритмов семплирования, поэтому их возможности сильно ограничивались гибкостью статистических моделей. Ключевое новшество GAN — замена семплера произвольным алгоритмом с дифференцируемыми параметрами. Эти параметры затем подстраиваются так, чтобы дискриминатор (по сути, двухвыборочный тест) не мог отличить поддельные данные от настоящих. Благодаря возможности генерировать данные произвольным алгоритмом эта идея открыла дорогу к оценке плотности для самых разных методов. Примеры — скачущие зебры (Zhu et al., 2017) и фальшивые лица знаменитостей (Karras et al., 2017). Даже любители-рисовальщики могут создавать фотореалистичные изображения по эскизам, описывающим расположение элементов сцены (Park et al., 2019).
• Во многих случаях одного GPU недостаточно для обработки огромных объёмов данных, доступных для обучения. За последнее десятилетие заметно выросли возможности построения параллельных и распределённых алгоритмов обучения. Одна из ключевых сложностей при разработке масштабируемых алгоритмов — рабочий инструмент оптимизации в глубоком обучении, стохастический градиентный спуск, опирается на относительно небольшие минибатчи данных. Однако минибатч ограничивает эффективность GPU. Например, обучение на 1024 GPU, если на каждом из них минибатч состоит из 32 изображений, эквивалентно минибатчу примерно из 32 000 изображений. Последние работы — сначала (Li, 2017), затем (You et al., 2017) и (Jia et al., 2018) — увеличили размер батча до 64 000 и сократили время обучения ResNet-50 на наборе ImageNet до менее чем 7 минут. Для сравнения: первоначально такое обучение занимало дни.
• Параллельные вычисления также внесли весомый вклад в прогресс обучения с подкреплением. Это привело к значительным успехам: компьютеры показывают сверхчеловеческие результаты в го, играх Atari, StarCraft и физических симуляциях (например, с MuJoCo). Описание того, как это было достигнуто в AlphaGo, см., например, в работе (Silver et al., 2016). Кратко: обучение с подкреплением работает лучше всего, когда доступно огромное количество троек «состояние, действие, награда», то есть когда можно пробовать очень многое, чтобы понять связи между ними. Симуляции дают такую возможность.
• Фреймворки глубокого обучения сыграли решающую роль в распространении идей. Инструменты первого поколения, которые позволяли легко строить модели, включали Caffe, Torch и Theano. Многие новаторские статьи были написаны с их помощью. Сейчас их вытеснили TensorFlow (часто используемый через высокоуровневый API Keras), CNTK, Caffe 2 и Apache MXNet. Инструменты третьего поколения — императивные фреймворки глубокого обучения — впервые появились, по-видимому, в Chainer, который описывает модели с помощью синтаксиса, похожего на NumPy в Python. Эту идею переняли PyTorch, Gluon API из MXNet и JAX.

Разделение труда между «системными исследователями, которые создают лучшие инструменты» и «исследователями статистического моделирования, которые создают лучшие нейронные сети» значительно упростило работу. Например, ещё в 2014 году обучение модели линейной регрессии было непростым домашним заданием для аспирантов по машинному обучению в Университете Карнеги — Меллона. Сейчас эта задача решается меньше чем в 10 строках кода, так что её может выполнить любой программист.

1.6 Успехи глубокого обучения

Искусственный интеллект давно умеет получать результаты, которых трудно добиться другими методами. Например, системы сортировки почты с оптическим распознаванием символов работают с 1990-х годов — ведь именно из этой задачи родился знаменитый набор рукописных цифр MNIST. То же относится к чтению банковских чеков и оценке кредитоспособности заявителей. Системы автоматически проверяют финансовые операции на мошенничество. Это стало опорой многих платёжных систем электронной коммерции, таких как PayPal, Stripe, Alipay, WeChat, Apple, Visa и Mastercard. Компьютерные программы для шахмат соревнуются уже десятилетия. Машинное обучение обеспечивает поиск, рекомендации, персонализацию и ранжирование в интернете. Иначе говоря, машинное обучение вездесуще, хотя часто остаётся незаметным.

Совсем недавно ИИ привлёк всеобщее внимание прежде всего благодаря решению задач, которые раньше считались неразрешимыми и напрямую связаны с потребителями. Многие такие прорывы обязаны глубокому обучению.

• Интеллектуальные ассистенты, такие как Siri от Apple, Alexa от Amazon и Google Assistant, довольно точно отвечают на устные вопросы. Это включает и простые задачи — например, включить свет (что особенно важно для людей с инвалидностью), записаться к парикмахеру или провести диалог со службой телефонной поддержки. Возможно, это самый заметный признак того, что ИИ уже влияет на нашу жизнь.
• Ключевой элемент цифровых ассистентов — точное распознавание речи. Постепенно в некоторых приложениях точность таких систем достигла уровня человека (Xiong et al., 2018).
• Распознавание объектов тоже сильно продвинулось. Определить объекты на изображении в 2010 году было довольно сложной задачей. В бенчмарке ImageNet исследователи из NEC Labs и Университета Иллинойса в Урбана — Шампейн получили ошибку Top-5, равную 28% (Lin et al., 2010). К 2017 году эта ошибка снизилась до 2,25% (Hu et al., 2018). Аналогично впечатляющие результаты получены при определении видов птиц и диагностике рака кожи.
• Игры долгое время были крепостью человеческого интеллекта. Начиная с TD-Gammon — программы для игры в нарды (backgammon), которая использовала обучение с временно́й разностью, прогресс алгоритмов и вычислений привёл к широкому распространению таких методов. В отличие от нард, в шахматах гораздо более сложное пространство состояний и набор действий. Deep Blue от IBM использовал массовый параллелизм, специализированное оборудование и эффективный поиск по дереву игры (Campbell et al., 2002), чтобы победить Гарри Каспарова. Го намного сложнее из-за огромного пространства состояний. AlphaGo в 2015 году достиг уровня человека в игре, используя глубокое обучение в сочетании с поиском по дереву методом Монте-Карло (Silver et al., 2016). В покере трудность в том, что пространство состояний велико и наблюдается не полностью (мы не знаем карт соперника). Программа Libratus (Brown and Sandholm, 2017) превзошла результаты людей в покере, используя эффективную структурированную стратегию. Это показывает, что в основе впечатляющего прогресса в играх лежат продвинутые алгоритмы.
• Самоуправляемые автомобили и грузовики — ещё одно свидетельство прогресса ИИ. Полностью автономные машины пока не стали повседневностью, но в этом направлении достигнуты серьёзные успехи: продукты таких компаний, как Tesla, NVIDIA и Waymo, обеспечивают как минимум частичную автономность. Полная автономия так трудна, потому что правильное вождение требует умения воспринимать среду, рассуждать и встраивать правила в систему. Сейчас глубокое обучение применяется в основном к компьютерному зрению этих задач, а остальное инженеры настраивают вручную.

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

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

К счастью, мы ещё очень далеки от разумной системы ИИ, способной контролировать своих создателей. Во-первых, системы ИИ проектируются, обучаются и внедряются определённым, целенаправленным образом. Хотя их поведение может создавать иллюзию универсального интеллекта, в основе их дизайна лежит сочетание правил, эвристик и статистических моделей. Во-вторых, пока не существует «искусственного общего интеллекта» — инструментов, которые могли бы самосовершенствоваться, самостоятельно рассуждать и, пытаясь решить общую задачу, менять, расширять и улучшать собственную архитектуру.

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

1.7 Особенности

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

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

Задачи, рассмотренные выше, — обучение на сырых аудиосигналах, на исходных значениях пикселей изображения или отображение предложений произвольной длины в соответствующие предложения на иностранном языке, — это задачи, в которых глубокое обучение превосходит традиционные методы машинного обучения. Оказывается, эти многослойные модели способны обрабатывать низкоуровневые сенсорные данные так, как не могли предыдущие инструменты. Несомненно, самая заметная общая черта методов глубокого обучения — сквозное обучение (end-to-end training). То есть вместо того, чтобы собирать систему из отдельно настроенных компонентов, систему строят целиком и совместно настраивают её характеристики.

Например, в компьютерном зрении учёные привыкли отделять процесс конструирования признаков от построения модели машинного обучения. Детектор границ Canny (Canny, 1987) и извлекатель признаков SIFT (Lowe, 2004), которые отображают изображение в векторы признаков, в прошлом десятилетии занимали безраздельное господство. Раньше ключевой частью применения машинного обучения к этим задачам было придумывание вручную сконструированных признаков, которые преобразовывали бы данные в форму, подходящую для поверхностных моделей. Однако людям через конструирование признаков удаётся сделать очень немного по сравнению с миллионами выборов, которые алгоритм делает автоматически. С появлением глубокого обучения эти извлекатели признаков были заменены автоматически настраиваемыми фильтрами, что повысило точность.

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

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

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

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

Резюме

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

Упражнения

1. Какие части кода, который вы сейчас пишете, могли бы «учиться», то есть улучшаться через обучение и автоматическое определение проектных решений, принятых в коде? Содержит ли ваш код эвристические проектные решения?
2. Для каких ваших задач есть много примеров решений, но нет конкретного автоматизированного способа? Это могут быть главные кандидаты для применения глубокого обучения.
3. Если рассматривать развитие ИИ как новую промышленную революцию, какова связь между алгоритмами и данными? Похожа ли она на связь паровой машины и угля? В чём фундаментальное различие?
4. В каких ещё областях можно применить сквозной метод обучения, например в задачах с рис. 1.2, в физике, инженерии и эконометрике?

Обсуждение

Литература

• Bahdanau, D., Cho, K., & Bengio, Y. (2014). Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473.
• Bishop, C. M. (1995). Training with noise is equivalent to Tikhonov regularization. Neural Computation, 7(1), 108–116.
• Brown, N., & Sandholm, T. (2017). Libratus: The superhuman AI for no-limit poker. In IJCAI (pp. 5226–5228).
• Campbell, M., Hoane Jr., A. J., & Hsu, F.-h. (2002). Deep Blue. Artificial Intelligence, 134(1–2), 57–83.
• Canny, J. (1987). A computational approach to edge detection. In Readings in Computer Vision (pp. 184–203). Elsevier.
• Goodfellow, I., Pouget-Abadie, J., Mirza, M., Xu, B., Warde-Farley, D., Ozair, S., Courville, A., & Bengio, Y. (2014). Generative adversarial nets. In Advances in Neural Information Processing Systems (pp. 2672–2680).
• Graves, A., & Schmidhuber, J. (2005). Framewise phoneme classification with bidirectional LSTM and other neural network architectures. Neural Networks, 18(5–6), 602–610.
• Hebb, D. O. (1949). The organization of behavior. Wiley.
• Hu, J., Shen, L., & Sun, G. (2018). Squeeze-and-excitation networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 7132–7141).
• Jia, X., Song, S., He, W., et al. (2018). Highly scalable deep learning training system with mixed-precision: Training ImageNet in four minutes. arXiv preprint arXiv:1807.11205.
• Karras, T., Aila, T., Laine, S., & Lehtinen, J. (2017). Progressive growing of GANs for improved quality, stability, and variation. arXiv preprint arXiv:1710.10196.
• LeCun, Y., Bottou, L., Bengio, Y., & Haffner, P. (1998). Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11), 2278–2324.
• Li, M. (2017). Scaling distributed machine learning with system and algorithm co-design [PhD thesis]. Carnegie Mellon University.
• Lin, Y., Lv, F., Zhu, S., et al. (2010). ImageNet classification: Fast descriptor coding and large-scale SVM training. Large Scale Visual Recognition Challenge.
• Lowe, D. G. (2004). Distinctive image features from scale-invariant keypoints. International Journal of Computer Vision, 60(2), 91–110.
• McCulloch, W. S., & Pitts, W. (1943). A logical calculus of the ideas immanent in nervous activity. The Bulletin of Mathematical Biophysics, 5(4), 115–133.
• Park, T., Liu, M.-Y., Wang, T.-C., & Zhu, J.-Y. (2019). Semantic image synthesis with spatially-adaptive normalization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (pp. 2337–2346).
• Reed, S., & De Freitas, N. (2015). Neural programmer-interpreters. arXiv preprint arXiv:1511.06279.
• Silver, D., Huang, A., Maddison, C. J., et al. (2016). Mastering the game of Go with deep neural networks and tree search. Nature, 529(7587), 484.
• Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I., & Salakhutdinov, R. (2014). Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1), 1929–1958.
• Sukhbaatar, S., Weston, J., Fergus, R., et al. (2015). End-to-end memory networks. In Advances in Neural Information Processing Systems (pp. 2440–2448).
• Turing, A. M. (1950). Computing machinery and intelligence. Mind, 59(236), 433–460.
• Watkins, C. J. C. H., & Dayan, P. (1992). Q-learning. Machine Learning, 8(3–4), 279–292.
• Xiong, W., Wu, L., Alleva, F., Droppo, J., Huang, X., & Stolcke, A. (2018). The Microsoft 2017 conversational speech recognition system. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP) (pp. 5934–5938). IEEE.
• You, Y., Gitman, I., & Ginsburg, B. (2017). Large batch training of convolutional networks. arXiv preprint arXiv:1708.03888.
• Zhu, J.-Y., Park, T., Isola, P., & Efros, A. A. (2017). Unpaired image-to-image translation using cycle-consistent adversarial networks. In Proceedings of the IEEE International Conference on Computer Vision (pp. 2223–2232).

2. Предварительные знания

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

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

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

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

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

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

2.1 Манипулирование данными

Чтобы выполнять различные операции с данными, нам нужен способ их хранить и обрабатывать. Обычно нужно сделать две важные вещи: (1) получить данные; (2) обработать их после того, как они попали в компьютер. Без способа хранить данные получать их не имеет смысла.

Для начала познакомимся с $n$-мерными массивами, которые также называют тензорами (tensor). Тем, кто пользовался пакетом NumPy для Python, этот раздел будет знаком. Какой бы фреймворк глубокого обучения ни использовался, его класс тензоров (в MXNet это ndarray, в PyTorch и TensorFlow — Tensor) похож на ndarray из NumPy. Однако фреймворки глубокого обучения предлагают несколько важных возможностей, которых нет у ndarray из NumPy: во-первых, они хорошо поддерживают ускоренные вычисления на GPU, тогда как NumPy работает только на CPU; во-вторых, класс тензоров поддерживает автоматическое дифференцирование. Эти возможности делают класс тензоров более подходящим для глубокого обучения. Если не оговорено иное, под тензорами в этой книге понимаются экземпляры класса тензоров.

2.1.1 Начало работы

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

MXNet: Сначала импортируем модуль np (numpy) и модуль npx (numpy_extension) из MXNet. Модуль np содержит функции, которые поддерживает NumPy, а модуль npx — набор расширенных функций для глубокого обучения в среде, похожей на NumPy. При работе с тензорами почти всегда вызывают функцию set_np: она нужна для совместимости с другими компонентами MXNet, работающими с тензорами.

PyTorch: Сначала импортируем torch. Обратите внимание: хотя фреймворк называется PyTorch, в коде используется имя torch, а не pytorch.

TensorFlow: Сначала импортируем tensorflow. Поскольку это имя довольно длинное, после импорта часто используют короткий псевдоним tf.

from mxnet import np, npx
npx.set_np()

import torch

import tensorflow as tf

import warnings
warnings.filterwarnings(action='ignore')
import paddle

Тензор представляет собой массив числовых значений, который может иметь несколько измерений. Тензор с одной осью соответствует математическому понятию вектора (vector); тензор с двумя осями соответствует математической матрице (matrix); тензоры с большим числом осей специального математического названия не имеют.

MXNet: Сначала создадим вектор-строку x с помощью arange. Она содержит первые 12 целых чисел, начиная с 0; по умолчанию они создаются как числа с плавающей точкой. Каждое значение тензора называют его элементом (element). Например, в тензоре x 12 элементов. Если не указано иное, новый тензор сохраняется в оперативной памяти, а вычисления выполняются на CPU.

PyTorch: Сначала создадим вектор-строку x с помощью arange. Она содержит первые 12 целых чисел, начиная с 0; по умолчанию они создаются как целые числа, но можно указать и тип с плавающей точкой. Каждое значение тензора называют его элементом (element). Например, в тензоре x 12 элементов. Если не указано иное, новый тензор сохраняется в оперативной памяти, а вычисления выполняются на CPU.

TensorFlow: Сначала создадим вектор-строку x с помощью range. Она содержит первые 12 целых чисел, начиная с 0; по умолчанию они создаются как целые числа, но можно указать и тип с плавающей точкой. Каждое значение тензора называют его элементом (element). Например, в тензоре x 12 элементов. Если не указано иное, новый тензор сохраняется в оперативной памяти, а вычисления выполняются на CPU.

x = np.arange(12)
x

x = torch.arange(12)
x

x = tf.range(12)
x

x = paddle.arange(12)
x

Форму тензора (длину вдоль каждой оси) можно получить через атрибут shape.

x.shape

Если нужно узнать только общее число элементов тензора, то есть произведение всех элементов формы, можно проверить его размер (size). Поскольку здесь мы работаем с вектором, его shape и size по сути совпадают.

x.size

x.numel()

tf.size(x)

x.numel()

Чтобы изменить форму тензора, не меняя число элементов и их значения, можно вызвать функцию reshape. Например, можно превратить тензор x из вектора-строки формы (12,) в матрицу формы (3, 4). Новый тензор содержит те же значения, что и исходный, но теперь он рассматривается как матрица из 3 строк и 4 столбцов. Важно подчеркнуть: хотя форма тензора изменилась, значения его элементов не изменились. Обратите внимание, что при изменении формы размер тензора не меняется.

X = x.reshape(3, 4)
X

X = tf.reshape(x, (3, 4))
X

X = paddle.reshape(x, (3, 4))
X

Не обязательно указывать каждое измерение вручную. Если целевая форма — (высота, ширина), то, зная ширину, высоту можно вычислить автоматически, и делить самостоятельно не нужно. В предыдущем примере, чтобы получить матрицу из 3 строк, мы вручную указали 3 строки и 4 столбца. К счастью, можно воспользоваться автоматическим вычислением размерности, указав -1. То есть вместо x.reshape(3, 4) можно написать x.reshape(-1, 4) или x.reshape(3, -1).

Иногда хочется инициализировать тензор нулями, единицами, другими константами или числами, случайно выбранными из определённого распределения. Например, создадим тензор формы (2, 3, 4), все элементы которого равны 0. Код выглядит так:

np.zeros((2, 3, 4))

torch.zeros((2, 3, 4))

tf.zeros((2, 3, 4))

paddle.zeros((2, 3, 4))

Аналогично можно создать тензор формы (2, 3, 4), все элементы которого равны 1:

np.ones((2, 3, 4))

torch.ones((2, 3, 4))

tf.ones((2, 3, 4))

paddle.ones((2, 3, 4))

Иногда значения элементов тензора удобно получить случайной выборкой из определённого распределения. Например, когда мы создаём массивы как параметры нейронной сети, их значения обычно задают случайным образом. Следующий код создаёт тензор формы (3, 4). Каждый его элемент случайно выбирается из стандартного нормального (гауссова) распределения со средним 0 и стандартным отклонением 1.

np.random.normal(0, 1, size=(3, 4))

torch.randn(3, 4)

tf.random.normal(shape=[3, 4])

paddle.randn((3, 4),'float32')

Также можно задать значения элементов тензора явно, передав Python-список (или вложенный список) с числами. Здесь внешний список соответствует оси 0, а внутренние списки — оси 1.

np.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

tf.constant([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

paddle.to_tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

2.1.2 Операторы

Нас интересуют не только чтение и запись данных. Мы хотим выполнять над данными математические операции. Самые простые и полезные из них — поэлементные (elementwise) операции. Они применяют стандартный скалярный оператор к каждому элементу массива. Для функций, которые принимают два массива, поэлементная операция применяет бинарный оператор к каждой паре элементов, стоящих в одинаковых позициях двух массивов. Поэлементную функцию можно построить на основе любой функции, которая переводит скаляр в скаляр.

В математической записи унарный скалярный оператор (принимающий один аргумент) обозначается как $f:\mathbb{R}\to \mathbb{R}$. Это значит, что функция отображает любое вещественное число ($\mathbb{R}$) в другое вещественное число. Аналогично бинарный скалярный оператор (принимающий два аргумента) обозначается как $f:\mathbb{R},\mathbb{R}\to \mathbb{R}$. Для любых двух векторов $\mathbf{u}$ и $\mathbf{v}$ одинаковой формы и бинарного оператора $f$ мы получаем вектор $\mathbf{c}=F(\mathbf{u},\mathbf{v})$. Вычисляется он так: $c_i\leftarrow f(u_i,v_i)$, где $c_i$, $u_i$ и $v_i$ — элементы векторов $\mathbf{c}$, $\mathbf{u}$ и $\mathbf{v}$ соответственно. Здесь мы превращаем скалярную функцию в поэлементную векторную операцию и получаем функцию $F:{\mathbb{R}}^d,{\mathbb{R}}^d\to {\mathbb{R}}^d$, которая возвращает вектор.

Для любых тензоров одинаковой формы стандартные арифметические операторы (+, -, *, / и **) выполняются поэлементно. Поэлементную операцию можно выполнять над любыми двумя тензорами одинаковой формы. В примере ниже через запятую перечислены пять результатов поэлементных операций — они образуют кортеж.

x = np.array([1, 2, 4, 8])
y = np.array([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y  # Оператор ** — возведение в степень

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y  # Оператор ** — возведение в степень

x = tf.constant([1.0, 2, 4, 8])
y = tf.constant([2.0, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y  # Оператор ** — возведение в степень

x = paddle.to_tensor([1.0, 2, 4, 8])
y = paddle.to_tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x**y  # Оператор ** — возведение в степень

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

np.exp(x)

torch.exp(x)

tf.exp(x)

paddle.exp(x)

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

Также можно объединять (concatenate) несколько тензоров, укладывая их встык в один больший тензор. Нужно лишь передать список тензоров и указать, по какой оси их соединять. В примере ниже показано, что происходит при соединении двух матриц по строкам (вдоль оси 0, первого элемента формы) и по столбцам (вдоль оси 1, второго элемента формы). Длина первого выходного тензора по оси 0 (6) равна сумме длин входных тензоров по оси 0 ($3+3$); длина второго выходного тензора по оси 1 (8) равна сумме длин входных тензоров по оси 1 ($4+4$).

X = np.arange(12).reshape(3, 4)
Y = np.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
np.concatenate([X, Y], axis=0), np.concatenate([X, Y], axis=1)

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)

X = tf.reshape(tf.range(12, dtype=tf.float32), (3, 4))
Y = tf.constant([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
tf.concat([X, Y], axis=0), tf.concat([X, Y], axis=1)

X = paddle.arange(12, dtype='float32').reshape((3, 4))
Y = paddle.to_tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
paddle.concat((X, Y), axis=0), paddle.concat((X, Y), axis=1)

Иногда нужно построить двоичный тензор с помощью логических операторов. Возьмём X == Y: в каждой позиции, где X и Y равны, соответствующий элемент нового тензора равен 1. Это значит, что логическое выражение X == Y в этой позиции истинно, а в остальных позициях ложно, то есть равно 0.

X == Y

Суммирование всех элементов тензора даёт тензор из одного элемента.

X.sum()

tf.reduce_sum(X)

2.1.3 Механизм broadcasting

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

1. Один или оба массива расширяются за счёт копирования элементов так, чтобы после преобразования оба тензора имели одинаковую форму;
2. Над полученными массивами выполняется поэлементная операция.

В большинстве случаев broadcasting происходит вдоль осей длины 1, как в следующем примере:

a = np.arange(3).reshape(3, 1)
b = np.arange(2).reshape(1, 2)
a, b

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b

a = tf.reshape(tf.range(3), (3, 1))
b = tf.reshape(tf.range(2), (1, 2))
a, b

a = paddle.reshape(paddle.arange(3), (3, 1))
b = paddle.reshape(paddle.arange(2), (1, 2))
a, b

Поскольку a и b — матрицы формы $3\times 1$ и $1\times 2$, их непосредственное сложение невозможно: формы не совпадают. Мы расширяем (broadcast) обе матрицы до одной большей матрицы $3\times 2$: матрица a копирует столбец, матрица b копирует строки, а затем результаты складываются поэлементно.

MXNet, PyTorch, TensorFlow, PaddlePaddle:

a + b

2.1.4 Индексация и срезы

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

Так, с помощью [-1] можно выбрать последний элемент, а с помощью [1:3] — второй и третий элементы:

X[-1], X[1:3]

MXNet, PyTorch: Помимо чтения, с помощью индексов можно записывать значения в элементы матрицы.

TensorFlow: Тензоры (Tensors) в TensorFlow неизменяемы и не поддерживают присваивание. Переменные (Variables) в TensorFlow — изменяемые контейнеры, в которые можно присваивать значения. Помните, что в TensorFlow градиенты не распространяются обратно через Variable. Кроме присваивания всей переменной целиком, можно записывать значения и в отдельные элементы Variable по индексу.

X[1, 2] = 9
X

X_var = tf.Variable(X)
X_var[1, 2].assign(9)
X_var

Если нужно присвоить одно и то же значение нескольким элементам, достаточно проиндексировать все нужные элементы и присвоить им значение. Например, [0:2, :] обращается к первой и второй строкам, где «:» означает все элементы вдоль оси 1 (столбцы). Хотя мы говорим об индексации матриц, это работает и для векторов, и для тензоров с более чем двумя осями.

X[0:2, :] = 12
X

X_var = tf.Variable(X)
X_var[0:2, :].assign(tf.ones(X_var[0:2,:].shape, dtype = tf.float32) * 12)
X_var

2.1.5 Экономия памяти

Некоторые операции могут приводить к выделению памяти под новый результат. Например, если написать Y = X + Y, то Y будет указывать не на прежний тензор, а на тензор в новой области памяти.

В примере ниже мы покажем это с помощью функции id() из Python, которая возвращает адрес объекта в памяти. После выполнения Y = Y + X видно, что id(Y) указывает на другое место. Это происходит потому, что Python сначала вычисляет Y + X, выделяет под результат новую память, и только потом переставляет Y на эту новую область.

before = id(Y)
Y = Y + X
id(Y) == before

Такое поведение может быть нежелательно по двум причинам:

1. Во-первых, нам не хочется без необходимости постоянно выделять память. В машинном обучении могут быть сотни мегабайт параметров, которые обновляются многократно в секунду. Обычно такие обновления хотелось бы выполнять на месте (in-place);
2. Во-вторых, если не обновлять на месте, на старую область памяти по-прежнему будут ссылаться другие переменные, и часть кода может случайно использовать устаревшие параметры.

MXNet, PyTorch: К счастью, выполнить операцию на месте очень просто. Можно присвоить результат операции заранее выделенному массиву с помощью срезов, например Y[:] = <выражение>. Чтобы показать это, сначала создадим новую матрицу Z той же формы, что и Y, и с помощью zeros_like выделим блок из одних нулей.

TensorFlow: Variables — это изменяемые контейнеры в TensorFlow, которые позволяют хранить параметры модели. Результат операции можно присвоить Variable с помощью assign. Чтобы показать это, создадим Z той же формы, что и тензор Y, и с помощью zeros_like выделим блок из одних нулей.

Z = np.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

Z = tf.Variable(tf.zeros_like(Y))
print('id(Z):', id(Z))
Z.assign(X + Y)
print('id(Z):', id(Z))

Z = paddle.zeros_like(Y)
print('id(Z):', id(Z))
Z = X + Y
print('id(Z):', id(Z))

MXNet, PyTorch: Если в дальнейших вычислениях X не используется, можно также написать X[:] = X + Y или X += Y, чтобы уменьшить затраты памяти на операцию.

TensorFlow: Даже если вы храните состояние в Variable, может понадобиться избегать лишнего выделения памяти под тензоры, которые не являются параметрами модели, чтобы дополнительно снизить расход памяти. Поскольку тензоры TensorFlow неизменяемы, а градиенты не проходят через Variable, TensorFlow не предоставляет явного способа выполнить отдельную операцию на месте. Однако TensorFlow предоставляет декоратор tf.function, который заключает вычисления в граф TensorFlow; перед запуском граф компилируется и оптимизируется. Это позволяет TensorFlow удалять неиспользуемые значения и повторно использовать ранее выделенную память для значений, которые уже не нужны. Так расход памяти на вычисления в TensorFlow сводится к минимуму.

before = id(X)
X += Y
id(X) == before

@tf.function
def computation(X, Y):
    Z = tf.zeros_like(Y)  # Это неиспользуемое значение будет удалено
    A = X + Y  # Когда оно больше не нужно, память будет переиспользована
    B = A + Y
    C = B + Y
    return C + Y

computation(X, Y)

2.1.6 Преобразование в другие объекты Python

MXNet, TensorFlow: Преобразовать тензор фреймворка глубокого обучения в NumPy-тензор (ndarray) несложно, и обратное преобразование тоже. Результат при этом не разделяет память с исходным тензором. Эта небольшая неприятность на самом деле очень важна: при вычислениях на CPU или GPU, если пакет NumPy в Python тоже захочет использовать тот же блок памяти для других операций, не хочется останавливать вычисления и ждать его.

PyTorch: Преобразовать тензор фреймворка в NumPy-тензор (ndarray) так же просто, и обратно. Тензоры torch и массивы numpy разделяют одну и ту же область памяти, поэтому изменение одного из них (в том числе операцией на месте) меняет и другой.

A = X.asnumpy()
B = np.array(A)
type(A), type(B)

A = X.numpy()
B = torch.tensor(A)
type(A), type(B)

A = X.numpy()
B = tf.constant(A)
type(A), type(B)

A = X.numpy()
B = paddle.to_tensor(A)
type(A), type(B)

Чтобы преобразовать тензор размера 1 в скаляр Python, можно вызвать функцию item или встроенные функции Python.

a = np.array([3.5])
a, a.item(), float(a), int(a)

a = torch.tensor([3.5])
a, a.item(), float(a), int(a)

a = tf.constant([3.5]).numpy()
a, a.item(), float(a), int(a)

a = paddle.to_tensor([3.5])
a, a.item(), float(a), int(a)

Резюме

• Основной интерфейс для хранения и обработки данных в глубоком обучении — тензор ($n$-мерный массив). Он предоставляет множество возможностей: базовые математические операции, broadcasting, индексацию, срезы, экономию памяти и преобразование в другие объекты Python.

Упражнения

1. Запустите код из этого раздела. Замените условие X == Y на X < Y или X > Y и посмотрите, какой тензор получится.
2. Замените два тензора, над которыми выполняется поэлементная операция с broadcasting, на тензоры другой формы (например, трёхмерные). Совпадает ли результат с вашими ожиданиями?

MXNet: Обсуждение

PyTorch: Обсуждение

TensorFlow: Обсуждение

PaddlePaddle: Обсуждение

2.2 Предобработка данных

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

2.2.1 Чтение набора данных

Для примера мы сначала создадим искусственный набор данных и сохраним его в CSV-файл ../data/house_tiny.csv (файл со значениями, разделёнными запятыми). Данные в других форматах можно обрабатывать похожим образом. Ниже мы построчно запишем набор данных в CSV-файл.

import os

os.makedirs(os.path.join('..', 'data'), exist_ok=True)
data_file = os.path.join('..', 'data', 'house_tiny.csv')
with open(data_file, 'w') as f:
    f.write('NumRooms,Alley,Price\n')  # Имена столбцов
    f.write('NA,Pave,127500\n')  # Каждая строка — один пример данных
    f.write('2,NA,106000\n')
    f.write('4,NA,178100\n')
    f.write('NA,NA,140000\n')

Чтобы загрузить исходный набор данных из созданного CSV-файла, импортируем пакет pandas и вызовем функцию read_csv. В этом наборе данных четыре строки и три столбца. Каждая строка описывает количество комнат («NumRooms»), тип переулка («Alley») и цену дома («Price»).

# Если pandas не установлен, достаточно раскомментировать следующие строки, чтобы его установить
# !pip install pandas
import pandas as pd

data = pd.read_csv(data_file)
print(data)

2.2.2 Обработка пропущенных значений

Обратите внимание: значения «NaN» обозначают пропущенные данные. Для обработки пропущенных данных обычно применяют импутацию (заполнение пропусков) и удаление, где импутация заменяет пропущенное значение подходящим значением, а удаление просто игнорирует пропущенные значения. Здесь мы рассмотрим импутацию.

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

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
inputs = inputs.fillna(inputs.mean())
print(inputs)

Для категориальных или дискретных значений в inputs мы будем считать «NaN» отдельной категорией. Поскольку столбец «Alley» принимает только два категориальных значения «Pave» и «NaN», pandas может автоматически преобразовать его в два столбца «Alley_Pave» и «Alley_nan». Строка, в которой тип переулка «Pave», получит в столбце «Alley_Pave» значение 1, а в столбце «Alley_nan» — значение 0. Строка без типа переулка получит в «Alley_Pave» значение 0, а в «Alley_nan» — значение 1.

inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)

2.2.3 Преобразование в формат тензора

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

from mxnet import np

X, y = np.array(inputs.to_numpy(dtype=float)), np.array(outputs.to_numpy(dtype=float))
X, y

import torch

X = torch.tensor(inputs.to_numpy(dtype=float))
y = torch.tensor(outputs.to_numpy(dtype=float))
X, y

import tensorflow as tf

X = tf.constant(inputs.to_numpy(dtype=float))
y = tf.constant(outputs.to_numpy(dtype=float))
X, y

import warnings
warnings.filterwarnings(action='ignore')
import paddle

X, y = paddle.to_tensor(inputs.values), paddle.to_tensor(outputs.values)
X, y

Резюме

• Пакет pandas — распространённый в Python инструмент анализа данных, и он совместим с тензорами.
• При работе с пропущенными данными в pandas мы в зависимости от ситуации выбираем импутацию или удаление.

Упражнения

Создайте исходный набор данных с большим количеством строк и столбцов.

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

MXNet: Обсуждение

PyTorch: Обсуждение

TensorFlow: Обсуждение

PaddlePaddle: Обсуждение

2.3 Линейная алгебра

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

2.3.1 Скаляры

Если вы когда-нибудь расплачивались в ресторане, вы уже знакомы с некоторыми базовыми понятиями линейной алгебры, например со сложением и умножением чисел. Допустим, температура в Пекине составляет $52^{\circ }F$ (градусы Фаренгейта — единица измерения температуры, отличная от градусов Цельсия). Строго говоря, одно число называют скаляром (scalar). Чтобы перевести это значение в более привычные градусы Цельсия, можно вычислить выражение $c=\frac{5}{9}(f-32)$, подставив $f=52$. В этом выражении каждое из чисел ($5$, $9$ и $32$) — скаляр. Символы $c$ и $f$ называют переменными (variable): они обозначают неизвестные скалярные значения.

В этой книге скалярные переменные обозначаются обычными строчными буквами (например, $x$, $y$ и $z$). Через $\mathbb{R}$ обозначают пространство всех (непрерывных) вещественных скаляров; строгое определение пространства (space) мы дадим позже, а пока достаточно помнить, что запись $x\in \mathbb{R}$ — формальный способ сказать, что $x$ — вещественный скаляр. Символ $\in$ читается как «принадлежит» и означает «является элементом множества». Например, запись $x,y\in \{0,1\}$ показывает, что $x$ и $y$ — числа, которые могут принимать только значения $0$ или $1$.

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

from mxnet import np, npx
npx.set_np()

x = np.array(3.0)
y = np.array(2.0)

x + y, x * y, x / y, x ** y

import torch

x = torch.tensor(3.0)
y = torch.tensor(2.0)

x + y, x * y, x / y, x**y

import tensorflow as tf

x = tf.constant(3.0)
y = tf.constant(2.0)

x + y, x * y, x / y, x**y

import warnings
warnings.filterwarnings(action='ignore')
import paddle

x = paddle.to_tensor([3.0])
y = paddle.to_tensor([2.0])

x + y, x * y, x / y, x**y

2.3.2 Векторы

Вектор можно рассматривать как список скалярных значений. Эти значения называют элементами (element) или компонентами (component) вектора. Когда векторы представляют примеры из набора данных, значения их компонентов имеют вполне конкретный смысл. Например, если мы обучаем модель оценивать риск невозврата кредита, каждому заявителю можно сопоставить вектор, компоненты которого соответствуют его доходу, стажу работы, числу прошлых просрочек и другим факторам. Если же мы изучаем риск сердечного приступа у пациентов больницы, каждого пациента можно представить вектором, компоненты которого — последние показатели жизнедеятельности, уровень холестерина, ежедневное время физической активности и т. д. В математической записи векторы обычно обозначают жирными строчными буквами (например, $\mathbf{x}$, $\mathbf{y}$ и $\mathbf{z}$).

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

x = np.arange(4)
x

x = torch.arange(4)
x

x = tf.range(4)
x

x = paddle.arange(4)
x

К любому элементу вектора можно обратиться по индексу: например, $x_i$ обозначает $i$-й элемент. Заметим, что элемент $x_i$ — скаляр, поэтому при обращении к нему он не выделяется жирным шрифтом. Большинство литературы по умолчанию считает векторы столбцами, и в этой книге мы придерживаемся того же соглашения. В математической записи вектор $\mathbf{x}$ можно представить так:

$$\mathbf{x}=\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right],\text{\hspace{1em}(2.3.1)}$$

где $x_1,\dots ,x_n$ — элементы вектора. В коде элементы вектора доступны через индексацию тензора.

x[3]

x[3]

x[3]

x[3]

2.3.2.1 Длина, размерность и форма

Вектор — это просто массив чисел, и, как у любого массива, у вектора есть длина. Если мы хотим сказать, что вектор $\mathbf{x}$ состоит из $n$ вещественных скаляров, можно записать $\mathbf{x}\in {\mathbb{R}}^n$. Длину вектора обычно называют его размерностью (dimension).

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

len(x)

len(x)

len(x)

len(x)

Когда вектор представлен тензором с одной осью, его длину можно получить и через атрибут .shape. Форма (shape) — это кортеж, в котором перечислены длины тензора вдоль каждой оси (то есть размеры по каждому измерению). У тензора с одной осью форма содержит только один элемент.

x.shape

x.shape

x.shape

x.shape

Слово «размерность» (dimension) в разных контекстах означает разное, и это часто сбивает с толку. Чтобы избежать путаницы, уточним: размерность вектора или оси — это длина вектора или оси, то есть число его элементов. Однако размерность тензора — это число его осей. В этом смысле размерность оси тензора — это длина этой оси.

2.3.3 Матрицы

Как вектор обобщает скаляр с нулевого порядка на первый, так матрица обобщает вектор с первого порядка на второй. Матрицы обычно обозначают жирными заглавными буквами (например, $\mathbf{X}$, $\mathbf{Y}$ и $\mathbf{Z}$), а в коде представляют тензорами с двумя осями.

Запись $\mathbf{A}\in {\mathbb{R}}^{m\times n}$ означает, что матрица $\mathbf{A}$ состоит из $m$ строк и $n$ столбцов вещественных скаляров. Любую матрицу $\mathbf{A}\in {\mathbb{R}}^{m\times n}$ можно представить как таблицу, в которой каждый элемент $a_{ij}$ стоит в $i$-й строке и $j$-м столбце:

$$\mathbf{A}=\left[\begin{array}{cccc}{a}_{11}& a_{12}& \cdots & a_{1n}\\ a_{21}& a_{22}& \cdots & a_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ a_{m1}& a_{m2}& \cdots & a_{mn}\end{array}\right].\text{\hspace{1em}(2.3.2)}$$

Для любой матрицы $\mathbf{A}\in {\mathbb{R}}^{m\times n}$ её форма — ($m$, $n$), или $m\times n$. Если у матрицы одинаковое число строк и столбцов, её форма квадратная; такую матрицу называют квадратной (square matrix).

Когда мы вызываем функцию, создающую тензор, матрицу формы $m\times n$ можно получить, задав два размера $m$ и $n$.

A = np.arange(20).reshape(5, 4)
A

A = torch.arange(20).reshape(5, 4)
A

A = tf.reshape(tf.range(20), (5, 4))
A

A = paddle.reshape(paddle.arange(20), (5, 4))
A

Скалярный элемент $a_{ij}$ матрицы можно получить по индексу строки ($i$) и индексу столбца ($j$), например как $[\mathbf{A}{]}_{ij}$. Если элементы матрицы $\mathbf{A}$ не выписаны явно, как в формуле (2.3.2), для обозначения $[\mathbf{A}{]}_{ij}$ можно просто использовать строчную букву $a$ с двумя индексами. Чтобы запись оставалась компактной, запятую между индексами ставим только тогда, когда это необходимо, например $a_{2,3j}$ и $[\mathbf{A}{]}_{2i-1,3}$.

Если поменять местами строки и столбцы матрицы, результат называют транспонированием (transpose). Транспонированную матрицу обычно обозначают ${\mathbf{A}}^{\top }$: если $\mathbf{B}={\mathbf{A}}^{\top }$, то для любых $i$ и $j$ выполняется $b_{ij}=a_{ji}$. Таким образом, транспонированная матрица из формулы (2.3.2) имеет форму $n\times m$:

$${\mathbf{A}}^{\top }=\left[\begin{array}{cccc}{a}_{11}& a_{21}& \dots & a_{m1}\\ a_{12}& a_{22}& \dots & a_{m2}\\ ⋮& ⋮& \ddots & ⋮\\ a_{1n}& a_{2n}& \dots & a_{mn}\end{array}\right].$$

Теперь получим транспонированную матрицу в коде.

A.T

A.T

tf.transpose(A)

paddle.transpose(A, perm=[1, 0])

Особый вид квадратных матриц составляют симметричные матрицы (symmetric matrix): матрица $\mathbf{A}$ симметрична, если она равна своей транспонированной: $\mathbf{A}={\mathbf{A}}^{\top }$. Определим симметричную матрицу $\mathbf{B}$:

B = np.array([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
B

B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
B

B = tf.constant([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
B

B = paddle.to_tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
B

Теперь сравним B с её транспонированной матрицей.

B == B.T

B == tf.transpose(B)

B == paddle.transpose(B, perm=[1, 0])

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

2.3.4 Тензоры

Так же как векторы обобщают скаляры, а матрицы — векторы, можно построить структуры данных с большим числом осей. Тензоры (здесь слово «тензор» означает алгебраический объект) — общий способ описания $n$-мерных массивов с произвольным числом осей. Например, вектор — это тензор первого порядка, а матрица — тензор второго порядка. Тензоры обозначают прописными буквами особого шрифта (например, $\mathsf{X}$, $\mathsf{Y}$ и $\mathsf{Z}$), а их индексация (например, $x_{ijk}$ и $[\mathsf{X}{]}_{1,2i-1,3}$) устроена так же, как у матриц.

Тензоры становятся особенно важными, когда мы начинаем работать с изображениями. Изображение — это $n$-мерный массив, в котором три оси соответствуют высоте, ширине и каналу (channel) — оси цветовых каналов (красного, зелёного и синего). Однако пока отложим тензоры более высоких порядков и сосредоточимся на основах.

X = np.arange(24).reshape(2, 3, 4)
X

X = torch.arange(24).reshape(2, 3, 4)
X

X = tf.reshape(tf.range(24), (2, 3, 4))
X

X = paddle.reshape(paddle.arange(24), (2, 3, 4))
X

2.3.5 Основные свойства арифметики тензоров

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

A = np.arange(20).reshape(5, 4)
B = A.copy()  # Выделяем новую память и присваиваем B копию A
A, A + B

A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone()  # Выделяем новую память и присваиваем B копию A
A, A + B

A = tf.reshape(tf.range(20, dtype=tf.float32), (5, 4))
B = A  # Нельзя скопировать A в B с выделением новой памяти
A, A + B

A = paddle.reshape(paddle.arange(20, dtype=paddle.float32), (5, 4))
B = A.clone()  # Выделяем новую память и присваиваем B копию A
A, A + B

В частности, поэлементное умножение двух матриц называют произведением Адамара (Hadamard product) и обозначают символом $\odot$. Для матрицы $\mathbf{B}\in {\mathbb{R}}^{m\times n}$ элемент, стоящий в $i$-й строке и $j$-м столбце, равен $b_{ij}$. Произведение Адамара матриц $\mathbf{A}$ (определённой в формуле (2.3.2)) и $\mathbf{B}$ имеет вид:

$$\mathbf{A}\odot \mathbf{B}=\left[\begin{array}{cccc}{a}_{11}{b}_{11}& a_{12}{b}_{12}& \dots & a_{1n}{b}_{1n}\\ a_{21}{b}_{21}& a_{22}{b}_{22}& \dots & a_{2n}{b}_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ a_{m1}{b}_{m1}& a_{m2}{b}_{m2}& \dots & a_{mn}{b}_{mn}\end{array}\right].$$

A * B

A * B

A * B

A * B

Умножение тензора на скаляр или сложение с ним не меняет форму тензора: каждый элемент тензора складывается со скаляром или умножается на него.

a = 2
X = np.arange(24).reshape(2, 3, 4)
a + X, (a * X).shape

a = 2
X = torch.arange(24).reshape(2, 3, 4)
a + X, (a * X).shape

a = 2
X = tf.reshape(tf.range(24), (2, 3, 4))
a + X, (a * X).shape

a = 2
X = paddle.reshape(paddle.arange(24), (2, 3, 4))
a + X, (a * X).shape

2.3.6 Редукция

Полезная операция, которую можно выполнить над любым тензором, — вычисление суммы его элементов. Для обозначения суммы используется символ $\sum$. Сумму элементов вектора длины $d$ можно записать как ${\sum }_{i=1}^d{x}_i$. В коде для этого есть функция суммирования:

x = np.arange(4)
x, x.sum()

x = torch.arange(4, dtype=torch.float32)
x, x.sum()

x = tf.range(4, dtype=tf.float32)
x, tf.reduce_sum(x)

x = paddle.arange(4, dtype=paddle.float32)
x, x.sum()

Можно записать сумму элементов тензора произвольной формы. Например, сумма элементов матрицы $\mathbf{A}$ записывается как ${\sum }_{i=1}^m{\sum }_{j=1}^n{a}_{ij}$.

A.shape, A.sum()

A.shape, A.sum()

A.shape, tf.reduce_sum(A)

A.shape, A.sum()

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

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape

A_sum_axis0 = tf.reduce_sum(A, axis=0)
A_sum_axis0, A_sum_axis0.shape

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape

Указание axis=1 приводит к суммированию элементов по всем столбцам, то есть к уменьшению размерности по оси 1. Поэтому размерность по оси 1 пропадает из формы результата.

A_sum_axis1 = A.sum(axis=1)
A_sum_axis1, A_sum_axis1.shape

A_sum_axis1 = A.sum(axis=1)
A_sum_axis1, A_sum_axis1.shape

A_sum_axis1 = tf.reduce_sum(A, axis=1)
A_sum_axis1, A_sum_axis1.shape

A_sum_axis1 = A.sum(axis=1)
A_sum_axis1, A_sum_axis1.shape

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

A.sum(axis=[0, 1])  # Результат совпадает с A.sum()

tf.reduce_sum(A, axis=[0, 1])  # Результат совпадает с tf.reduce_sum(A)

A.sum(axis=[0, 1])

Связанная с суммой величина — среднее значение (mean или average). Его вычисляют, разделив сумму на число элементов. В коде есть функция для вычисления среднего значения тензора любой формы.

A.mean(), A.sum() / A.size

A.mean(), A.sum() / A.numel()

tf.reduce_mean(A), tf.reduce_sum(A) / tf.size(A).numpy()

A.mean(), A.sum() / A.numel()

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

A.mean(axis=0), A.sum(axis=0) / A.shape[0]

tf.reduce_mean(A, axis=0), tf.reduce_sum(A, axis=0) / A.shape[0]

A.mean(axis=0), A.sum(axis=0) / A.shape[0]

2.3.6.1 Суммирование без уменьшения размерности

Иногда при вычислении суммы или среднего полезно сохранить число осей неизменным.

sum_A = A.sum(axis=1, keepdims=True)
sum_A

sum_A = tf.reduce_sum(A, axis=1, keepdims=True)
sum_A

sum_A = paddle.sum(A, axis=1, keepdim=True)
sum_A

Например, поскольку sum_A после суммирования по строкам по-прежнему имеет две оси, мы можем разделить A на sum_A с помощью broadcasting.

A / sum_A

A / sum_A

A / sum_A

A / sum_A

Если нужно вычислить накопленную сумму элементов A вдоль оси, например axis=0 (по строкам), можно вызвать функцию cumsum. Она не уменьшает размерность входного тензора ни по одной из осей.

A.cumsum(axis=0)

tf.cumsum(A, axis=0)

A.cumsum(axis=0)

2.3.7 Скалярное произведение (dot product)

Мы уже изучили поэлементные операции, суммирование и среднее значение. Ещё одна из самых базовых операций — скалярное произведение. Для двух векторов $\mathbf{x},\mathbf{y}\in {\mathbb{R}}^d$ их скалярное произведение (dot product) ${\mathbf{x}}^{\top }\mathbf{y}$ (или $⟨\mathbf{x},\mathbf{y}⟩$) — это сумма произведений элементов, стоящих на одинаковых позициях: ${\mathbf{x}}^{\top }\mathbf{y}={\sum }_{i=1}^d{x}_i{y}_i$.

y = np.ones(4)
x, y, np.dot(x, y)

y = torch.ones(4, dtype = torch.float32)
x, y, torch.dot(x, y)

y = tf.ones(4, dtype=tf.float32)
x, y, tf.tensordot(x, y, axes=1)

y = paddle.ones(shape=[4], dtype='float32')
x, y, paddle.dot(x, y)

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

np.sum(x * y)

torch.sum(x * y)

tf.reduce_sum(x * y)

paddle.sum(x * y)

Скалярное произведение полезно во многих случаях. Например, пусть задан набор значений, представленный вектором $\mathbf{x}\in {\mathbb{R}}^d$, и набор весов, представленный вектором $\mathbf{w}\in {\mathbb{R}}^d$. Взвешенная сумма значений из $\mathbf{x}$ с весами $\mathbf{w}$ записывается как скалярное произведение ${\mathbf{x}}^{\top }\mathbf{w}$. Если веса неотрицательны и в сумме дают 1 (то есть $\left({\sum }_{i=1}^d{w}_i=1\right)$), скалярное произведение задаёт взвешенное среднее (weighted average). Если нормировать оба вектора до единичной длины, скалярное произведение равно косинусу угла между ними. Понятие длины (length) будет формально введено далее в этом разделе.

2.3.8 Матрично-векторное произведение

Теперь, когда мы знаем, как вычислять скалярное произведение, можно перейти к матрично-векторному произведению (matrix-vector product). Вспомним матрицу $\mathbf{A}\in {\mathbb{R}}^{m\times n}$ и вектор $\mathbf{x}\in {\mathbb{R}}^n$, определённые в формулах (2.3.2) и (2.3.1). Представим матрицу $\mathbf{A}$ через её вектор-строки:

$$\mathbf{A}=\left[\begin{array}{c}{\mathbf{a}}_1^{\top }\\ {\mathbf{a}}_2^{\top }\\ ⋮\\ {\mathbf{a}}_m^{\top }\end{array}\right],$$

где каждый ${\mathbf{a}}_i^{\top }\in {\mathbb{R}}^n$ — вектор-строка, задающая $i$-ю строку матрицы. Матрично-векторное произведение $\mathbf{Ax}$ — это вектор-столбец длины $m$, $i$-й элемент которого равен скалярному произведению ${\mathbf{a}}_i^{\top }\mathbf{x}$:

$$\mathbf{Ax}=\left[\begin{array}{c}{\mathbf{a}}_1^{\top }\\ {\mathbf{a}}_2^{\top }\\ ⋮\\ {\mathbf{a}}_m^{\top }\end{array}\right]\mathbf{x}=\left[\begin{array}{c}{\mathbf{a}}_1^{\top }\mathbf{x}\\ {\mathbf{a}}_2^{\top }\mathbf{x}\\ ⋮\\ {\mathbf{a}}_m^{\top }\mathbf{x}\end{array}\right].$$

Умножение матрицы $\mathbf{A}\in {\mathbb{R}}^{m\times n}$ можно рассматривать как преобразование векторов из ${\mathbb{R}}^n$ в ${\mathbb{R}}^m$. Такие преобразования очень полезны: например, умножение на квадратную матрицу может представлять поворот. В следующих главах мы увидим, что матрично-векторные произведения позволяют описывать сложные вычисления, с помощью которых по значениям предыдущего слоя вычисляется каждый слой нейронной сети.

MXNet: В коде матрично-векторное произведение тензоров вычисляется той же функцией dot, что и скалярное произведение. При вызове np.dot(A, x) для матрицы A и вектора x выполняется матрично-векторное произведение. Заметим, что число столбцов A (длина по оси 1) должно совпадать с размерностью x (его длиной).

PyTorch: В коде матрично-векторное произведение тензоров вычисляется функцией mv. При вызове torch.mv(A, x) для матрицы A и вектора x выполняется матрично-векторное произведение. Заметим, что число столбцов A (длина по оси 1) должно совпадать с размерностью x (его длиной).

TensorFlow: В коде для матрично-векторного произведения тензоров используется функция matvec. При вызове tf.linalg.matvec(A, x) выполняется матрично-векторное произведение. Заметим, что число столбцов A (длина по оси 1) должно совпадать с размерностью x (его длиной).

A.shape, x.shape, np.dot(A, x)

A.shape, x.shape, torch.mv(A, x)

A.shape, x.shape, tf.linalg.matvec(A, x)

A.shape, x.shape, paddle.mv(A, x)

2.3.9 Матрично-матричное умножение

Освоив скалярное произведение и матрично-векторное произведение, понять матрично-матричное умножение (matrix-matrix multiplication) несложно.

Пусть даны две матрицы $\mathbf{A}\in {\mathbb{R}}^{n\times k}$ и $\mathbf{B}\in {\mathbb{R}}^{k\times m}$:

$$\mathbf{A}=\left[\begin{array}{cccc}{a}_{11}& a_{12}& \cdots & a_{1k}\\ a_{21}& a_{22}& \cdots & a_{2k}\\ ⋮& ⋮& \ddots & ⋮\\ a_{n1}& a_{n2}& \cdots & a_{nk}\end{array}\right],\mathbf{B}=\left[\begin{array}{cccc}{b}_{11}& b_{12}& \cdots & b_{1m}\\ b_{21}& b_{22}& \cdots & b_{2m}\\ ⋮& ⋮& \ddots & ⋮\\ b_{k1}& b_{k2}& \cdots & b_{km}\end{array}\right].$$

Обозначим вектор-строкой ${\mathbf{a}}_i^{\top }\in {\mathbb{R}}^k$ $i$-ю строку матрицы $\mathbf{A}$, а вектор-столбцом ${\mathbf{b}}_j\in {\mathbb{R}}^k$ — $j$-й столбец матрицы $\mathbf{B}$. Чтобы получить матричное произведение $\mathbf{C}=\mathbf{AB}$, проще всего рассмотреть строки $\mathbf{A}$ и столбцы $\mathbf{B}$:

$$\mathbf{A}=\left[\begin{array}{c}{\mathbf{a}}_1^{\top }\\ {\mathbf{a}}_2^{\top }\\ ⋮\\ {\mathbf{a}}_n^{\top }\end{array}\right],\mathbf{B}=\left[\begin{array}{cccc}{\mathbf{b}}_1& {\mathbf{b}}_2& \cdots & {\mathbf{b}}_m\end{array}\right].$$

Если просто вычислять каждый элемент $c_{ij}$ как скалярное произведение ${\mathbf{a}}_i^{\top }{\mathbf{b}}_j$, получим:

$$\mathbf{C}=\mathbf{AB}=\left[\begin{array}{c}{\mathbf{a}}_1^{\top }\\ {\mathbf{a}}_2^{\top }\\ ⋮\\ {\mathbf{a}}_n^{\top }\end{array}\right]\left[\begin{array}{cccc}{\mathbf{b}}_1& {\mathbf{b}}_2& \cdots & {\mathbf{b}}_m\end{array}\right]=\left[\begin{array}{cccc}{\mathbf{a}}_1^{\top }{\mathbf{b}}_1& {\mathbf{a}}_1^{\top }{\mathbf{b}}_2& \cdots & {\mathbf{a}}_1^{\top }{\mathbf{b}}_m\\ {\mathbf{a}}_2^{\top }{\mathbf{b}}_1& {\mathbf{a}}_2^{\top }{\mathbf{b}}_2& \cdots & {\mathbf{a}}_2^{\top }{\mathbf{b}}_m\\ ⋮& ⋮& \ddots & ⋮\\ {\mathbf{a}}_n^{\top }{\mathbf{b}}_1& {\mathbf{a}}_n^{\top }{\mathbf{b}}_2& \cdots & {\mathbf{a}}_n^{\top }{\mathbf{b}}_m\end{array}\right].$$

Матрично-матричное умножение $\mathbf{AB}$ можно рассматривать как $m$ матрично-векторных произведений, результаты которых объединяются в матрицу размера $n\times m$. В коде ниже мы перемножаем A и B. Здесь A — матрица 5×4, а B — матрица 4×3. После умножения получаем матрицу 5×3.

B = np.ones(shape=(4, 3))
np.dot(A, B)

B = torch.ones(4, 3)
torch.mm(A, B)

B = tf.ones((4, 3), tf.float32)
tf.matmul(A, B)

B = paddle.ones(shape=[4, 3], dtype='float32')
paddle.mm(A, B)

Матрично-матричное умножение можно называть просто умножением матриц; не путайте его с произведением Адамара.

2.3.10 Нормы

Одними из самых полезных операций линейной алгебры являются нормы (norm). Неформально норма вектора показывает, насколько «велик» этот вектор. Понятие «величины» (size) здесь не связано с размерностью: речь идёт о величине компонентов.

В линейной алгебре норма вектора — это функция $f$, которая сопоставляет вектору скаляр. Для любого вектора $\mathbf{x}$ норма должна обладать определёнными свойствами. Первое свойство: если умножить все элементы вектора на константу $\alpha$, его норма умножится на абсолютное значение этой константы:

$$f(\alpha \mathbf{x})=|\alpha |f(\mathbf{x}).$$

Второе свойство — знакомое неравенство треугольника:

$$f(\mathbf{x}+\mathbf{y})\le f(\mathbf{x})+f(\mathbf{y}).$$

Третье свойство: норма неотрицательна:

$$f(\mathbf{x})\ge 0.$$

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

$$\forall i,[\mathbf{x}{]}_i=0\iff f(\mathbf{x})=0.$$

Норма напоминает метрику расстояния. Неотрицательность и неравенство треугольника, знакомые из школьной геометрии (например, из теоремы Пифагора), дают хорошее представление о том, что это такое. На самом деле евклидово расстояние является $L_2$-нормой: если элементы $n$-мерного вектора $\mathbf{x}$ равны $x_1,\dots ,x_n$, то его $L_2$-норма равна квадратному корню из суммы квадратов его элементов:

$$\Vert \mathbf{x}{\Vert }_2=\sqrt{\sum _{i=1}^n{x}_i^2},$$

где в обозначении $L_2$-нормы индекс $2$, как правило, опускают: $\Vert \mathbf{x}\Vert$ означает $\Vert \mathbf{x}{\Vert }_2$. В коде $L_2$-норму вектора можно вычислить так.

u = np.array([3, -4])
np.linalg.norm(u)

u = torch.tensor([3.0, -4.0])
torch.norm(u)

u = tf.constant([3.0, -4.0])
tf.norm(u)

u = paddle.to_tensor([3.0, -4.0])
paddle.norm(u)

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

$$\Vert \mathbf{x}{\Vert }_1=\sum _{i=1}^n\left|x_i\right|.$$

По сравнению с $L_2$-нормой $L_1$-норма менее чувствительна к выбросам. Для вычисления $L_1$-нормы сочетают функцию модуля и поэлементное суммирование.

np.abs(u).sum()

torch.abs(u).sum()

tf.reduce_sum(tf.abs(u))

paddle.abs(u).sum()

И $L_2$-норма, и $L_1$-норма являются частными случаями более общей $L_p$-нормы:

$$\Vert \mathbf{x}{\Vert }_p={\left(\sum _{i=1}^n{\left|x_i\right|}^p\right)}^{1/p}.$$

Аналогично $L_2$-норме вектора, матрица $\mathbf{X}\in {\mathbb{R}}^{m\times n}$ имеет норму Фробениуса (Frobenius norm) — квадратный корень из суммы квадратов её элементов:

$$\Vert \mathbf{X}{\Vert }_F=\sqrt{\sum _{i=1}^m\sum _{j=1}^n{x}_{ij}^2}.$$

Норма Фробениуса удовлетворяет всем свойствам норм для векторов: её можно рассматривать как $L_2$-норму матрицы, развёрнутой в вектор. Вызов следующей функции вычисляет норму Фробениуса матрицы.

np.linalg.norm(np.ones((4, 9)))

torch.norm(torch.ones((4, 9)))

tf.norm(tf.ones((4, 9)))

paddle.norm(paddle.ones(shape=[4, 9], dtype='float32'))

2.3.10.1 Нормы и цели

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

2.3.11 Дополнительные сведения о линейной алгебре

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

Если хотите узнать о линейной алгебре больше, можно обратиться к онлайн-приложению об операциях линейной алгебры или к другим хорошим ресурсам (Strang, 1993; Kolter, 2008; Petersen and Pedersen, 2008).

Резюме

• Скаляры, векторы, матрицы и тензоры — базовые математические объекты линейной алгебры.
• Векторы обобщают скаляры, а матрицы обобщают векторы.
• Скаляры, векторы, матрицы и тензоры имеют соответственно 0, 1, 2 и произвольное число осей.
• Тензор можно уменьшать по размерности с помощью sum и mean по заданным осям.
• Поэлементное умножение двух матриц называется их произведением Адамара. Оно отличается от матричного умножения.
• В глубоком обучении мы часто используем нормы: $L_1$-норму, $L_2$-норму и норму Фробениуса.
• Над скалярами, векторами, матрицами и тензорами можно выполнять разнообразные операции.

Упражнения

1. Докажите, что транспонирование матрицы $\mathbf{A}$ дважды даёт $\mathbf{A}$, то есть $({\mathbf{A}}^{\top }{)}^{\top }=\mathbf{A}$.
2. Даны матрицы $\mathbf{A}$ и $\mathbf{B}$. Докажите, что сумма их транспонированных равна транспонированной сумме, то есть ${\mathbf{A}}^{\top }+{\mathbf{B}}^{\top }=(\mathbf{A}+\mathbf{B}{)}^{\top }$.
3. Для произвольной квадратной матрицы $\mathbf{A}$ всегда ли матрица $\mathbf{A}+{\mathbf{A}}^{\top }$ симметрична? Почему?
4. В этом разделе определён тензор X формы $(2,3,4)$. Что выведет len(X)?
5. Для тензора X произвольной формы всегда ли len(X) соответствует длине какой-либо оси X? Какой именно?
6. Выполните A/A.sum(axis=1) и посмотрите, что произойдёт. Объясните, почему так происходит.
7. Рассмотрим тензор формы $(2,3,4)$. Какую форму имеет результат суммирования по осям 0, 1 и 2?
8. Передайте в функцию linalg.norm тензор с тремя или более осями и посмотрите на результат. Что эта функция вычисляет для тензора произвольной формы?

MXNet: Обсуждение

PyTorch: Обсуждение

TensorFlow: Обсуждение

PaddlePaddle: Обсуждение

Литература

• Kolter, Z. (2008). Linear Algebra Review and Reference. Available online.
• Petersen, K. B., Pedersen, M. S., et al. (2008). The matrix cookbook. Technical University of Denmark, 7(15), 510.
• Strang, G. (1993). Introduction to linear algebra (Vol. 3). Wellesley-Cambridge Press, Wellesley, MA.

2.4 Математический анализ

2500 лет назад древние греки нашли способ вычислять площадь многоугольника: они разбивали его на треугольники и складывали их площади. Чтобы найти площадь фигуры криволинейной формы (например, круга), древние греки вписывали в неё многоугольники. Как показано на рис. 2.4.1, чем больше равных сторон у вписанного многоугольника, тем он ближе к кругу. Этот процесс также называют методом исчерпывания (method of exhaustion).

Рис. 2.4.1. Вычисление площади круга методом исчерпывания

На самом деле метод исчерпывания — начало интегрального исчисления (integral calculus). Более 2000 лет спустя появилась другая ветвь математического анализа — дифференциальное исчисление (differential calculus). Важнейшее применение дифференциального исчисления — задачи оптимизации, то есть поиск наилучшего способа что-то сделать. Как обсуждалось в разделе 2.3.10.1, такие задачи повсеместны в глубоком обучении.

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

• оптимизация (optimization): подгонка модели под наблюдаемые данные;
• обобщение (generalization): математические принципы и практический опыт, которые помогают получать модели, работающие на данных, выходящих за пределы обучающего набора.

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

2.4.1 Производные и дифференциалы

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

Пусть есть функция $f:\mathbb{R}\to \mathbb{R}$, входные и выходные значения которой — скаляры. Если у $f$ существует производная, её определяет предел

$$f^{\prime }(x)=\underset{h\to 0}{\lim }\frac{f(x+h)-f(x)}{h}.\text{\hspace{1em}(2.4.1)}$$

Если $f^{\prime }(a)$ существует, то функция $f$ называется дифференцируемой (differentiable) в точке $a$. Если $f$ дифференцируема в каждой точке некоторого интервала, то она дифференцируема на этом интервале. Производную $f^{\prime }(x)$ из формулы (2.4.1) можно интерпретировать как мгновенную (instantaneous) скорость изменения $f(x)$ по $x$. Такая мгновенная скорость изменения вычисляется по изменению $h$ аргумента $x$ при стремлении $h$ к $0$.

Чтобы лучше понять производную, проведём эксперимент. Определим $u=f(x)=3x^2-4x$ следующим образом:

%matplotlib inline
from d2l import mxnet as d2l
from matplotlib_inline import backend_inline
from mxnet import np, npx
npx.set_np()

def f(x):
    return 3 * x ** 2 - 4 * x

%matplotlib inline
from d2l import torch as d2l
from matplotlib_inline import backend_inline
import numpy as np

def f(x):
    return 3 * x ** 2 - 4 * x

%matplotlib inline
from d2l import tensorflow as d2l
from matplotlib_inline import backend_inline
import numpy as np

def f(x):
    return 3 * x ** 2 - 4 * x

%matplotlib inline
from d2l import paddle as d2l
from matplotlib_inline import backend_inline
import numpy as np

def f(x):
    return 3 * x ** 2 - 4 * x

Положив $x=1$ и устремив $h$ к $0$, получим, что численное значение $\frac{f(x+h)-f(x)}{h}$ в формуле (2.4.1) приближается к $2$. Хотя этот эксперимент не является математическим доказательством, позже мы увидим, что при $x=1$ производная $u^{\prime }$ действительно равна $2$.

def numerical_lim(f, x, h):
    return (f(x + h) - f(x)) / h

h = 0.1
for i in range(5):
    print(f'h={h:.5f}, численный предел={numerical_lim(f, 1, h):.5f}')
    h *= 0.1

Познакомимся с несколькими эквивалентными обозначениями производной. Для $y=f(x)$, где $x$ и $y$ — независимая и зависимая переменные функции $f$, следующие выражения эквивалентны:

$$f^{\prime }(x)=y^{\prime }=\frac{dy}{dx}=\frac{df}{dx}=\frac{d}{dx}f(x)=Df(x)=D_{x}f(x),$$

где символы $\frac{d}{dx}$ и $D$ — операторы дифференцирования, которые обозначают операцию дифференцирования. Для дифференцирования распространённых функций можно пользоваться следующими правилами:

• $DC=0$ ($C$ — константа)
• $D{x}^n=n{x}^{n-1}$ (степенное правило (power rule), $n$ — любое действительное число)
• $D{e}^x=e^x$
• $D\ln (x)=1/x$

Чтобы продифференцировать функцию, составленную из простых функций, полезны следующие правила. Пусть функции $f$ и $g$ дифференцируемы, а $C$ — константа. Тогда:

Правило константного множителя

$$\frac{d}{dx}[Cf(x)]=C\frac{d}{dx}f(x),$$

Правило суммы

$$\frac{d}{dx}[f(x)+g(x)]=\frac{d}{dx}f(x)+\frac{d}{dx}g(x),$$

Правило произведения

$$\frac{d}{dx}[f(x)g(x)]=f(x)\frac{d}{dx}[g(x)]+g(x)\frac{d}{dx}[f(x)],$$

Правило частного

$$\frac{d}{dx}\left[\frac{f(x)}{g(x)}\right]=\frac{g(x)\frac{d}{dx}[f(x)]-f(x)\frac{d}{dx}[g(x)]}{[g(x){]}^2}.$$

Теперь применим эти правила, чтобы вычислить $u^{\prime }=f^{\prime }(x)=3\frac{d}{dx}{x}^2-4\frac{d}{dx}x=6x-4$. При $x=1$ получаем $u^{\prime }=2$: численный результат в эксперименте выше действительно близок к $2$. При $x=1$ эта производная также равна угловому коэффициенту касательной к кривой $u=f(x)$.

Чтобы наглядно изобразить эту интерпретацию производной, будем использовать matplotlib — популярную библиотеку построения графиков на Python. Чтобы настроить свойства графиков, создаваемых matplotlib, нужно определить несколько вспомогательных функций. Функция use_svg_display указывает пакету matplotlib выводить графики в формате svg для более чёткого изображения.

Обратите внимание: комментарий #@save — специальная отметка, которая сохраняет соответствующую функцию, класс или оператор в пакете d2l. Поэтому их можно вызывать напрямую (например, d2l.use_svg_display()), не определяя заново.

def use_svg_display():  #@save
    """Показывает графики в формате svg в Jupyter"""
    backend_inline.set_matplotlib_formats('svg')

Функция set_figsize задаёт размер графиков. Здесь можно напрямую использовать d2l.plt, поскольку импорт from matplotlib import pyplot as plt помечен для сохранения в пакете d2l.

def set_figsize(figsize=(3.5, 2.5)):  #@save
    """Задаёт размер графика matplotlib"""
    use_svg_display()
    d2l.plt.rcParams['figure.figsize'] = figsize

Функция set_axes задаёт свойства осей графика, построенного с помощью matplotlib.

#@save
def set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend):
    """Задаёт оси графика matplotlib"""
    axes.set_xlabel(xlabel)
    axes.set_ylabel(ylabel)
    axes.set_xscale(xscale)
    axes.set_yscale(yscale)
    axes.set_xlim(xlim)
    axes.set_ylim(ylim)
    if legend:
        axes.legend(legend)
    axes.grid()

Имея эти три функции для настройки графика, определим функцию plot, которая позволяет кратко строить несколько кривых: в книге нам часто придётся визуализировать множество кривых.

#@save
def plot(X, Y=None, xlabel=None, ylabel=None, legend=None, xlim=None,
         ylim=None, xscale='linear', yscale='linear',
         fmts=('-', 'm--', 'g-.', 'r:'), figsize=(3.5, 2.5), axes=None):
    """Строит точки данных"""
    if legend is None:
        legend = []

    set_figsize(figsize)
    axes = axes if axes else d2l.plt.gca()

    # Если у X одна ось, возвращаем True
    def has_one_axis(X):
        return (hasattr(X, "ndim") and X.ndim == 1 or isinstance(X, list)
                and not hasattr(X[0], "__len__"))

    if has_one_axis(X):
        X = [X]
    if Y is None:
        X, Y = [[]] * len(X), X
    elif has_one_axis(Y):
        Y = [Y]
    if len(X) != len(Y):
        X = X * len(Y)
    axes.cla()
    for x, y, fmt in zip(X, Y, fmts):
        if len(x):
            axes.plot(x, y, fmt)
        else:
            axes.plot(y, fmt)
    set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend)

Теперь можем построить график функции $u=f(x)$ и её касательной $y=2x-3$ в точке $x=1$, где коэффициент $2$ — угловой коэффициент касательной.

x = np.arange(0, 3, 0.1)
plot(x, [f(x), 2 * x - 3], 'x', 'f(x)', legend=['f(x)', 'Касательная (x=1)'])

2.4.2 Частные производные

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

Пусть $y=f(x_1,x_2,\dots ,x_n)$ — функция от $n$ переменных. Частная производная (partial derivative) $y$ по $i$-му аргументу $x_i$ равна:

$$\frac{\partial y}{\partial x_i}=\underset{h\to 0}{\lim }\frac{f(x_1,\dots ,x_{i-1},x_i+h,x_{i+1},\dots ,x_n)-f(x_1,\dots ,x_i,\dots ,x_n)}{h}.$$

Чтобы вычислить $\frac{\partial y}{\partial x_i}$, можно считать $x_1,\dots ,x_{i-1},x_{i+1},\dots ,x_n$ константами и найти производную $y$ по $x_i$. Для обозначения частных производных следующие записи эквивалентны:

$$\frac{\partial y}{\partial x_i}=\frac{\partial f}{\partial x_i}=f_{x_i}=f_i=D_{i}f=D_{x_i}f.$$

2.4.3 Градиенты

Частные производные многомерной функции по всем её переменным можно собрать в вектор — градиент (gradient) функции. Точнее, пусть функция $f:{\mathbb{R}}^n\to \mathbb{R}$ принимает $n$-мерный вектор $\mathbf{x}=[x_1,x_2,\dots ,x_n{]}^{\top }$ и возвращает скаляр. Градиент функции $f(\mathbf{x})$ по $\mathbf{x}$ — это вектор из $n$ частных производных:

$${\nabla }_{\mathbf{x}}f(\mathbf{x})=[\frac{\partial f(\mathbf{x})}{\partial x_1},\frac{\partial f(\mathbf{x})}{\partial x_2},\dots ,\frac{\partial f(\mathbf{x})}{\partial x_n}{]}^{\top },$$

где ${\nabla }_{\mathbf{x}}f(\mathbf{x})$ при отсутствии неоднозначности часто записывают как $\nabla f(\mathbf{x})$.

Пусть $\mathbf{x}$ — $n$-мерный вектор. При дифференцировании многомерных функций часто используются следующие правила:

• для всех $\mathbf{A}\in {\mathbb{R}}^{m\times n}$ справедливо ${\nabla }_{\mathbf{x}}\mathbf{Ax}={\mathbf{A}}^{\top }$;
• для всех $\mathbf{A}\in {\mathbb{R}}^{n\times m}$ справедливо ${\nabla }_{\mathbf{x}}{\mathbf{x}}^{\top }\mathbf{A}=\mathbf{A}$;
• для всех $\mathbf{A}\in {\mathbb{R}}^{n\times n}$ справедливо ${\nabla }_{\mathbf{x}}{\mathbf{x}}^{\top }\mathbf{Ax}=(\mathbf{A}+{\mathbf{A}}^{\top })\mathbf{x}$;
• ${\nabla }_{\mathbf{x}}\Vert \mathbf{x}{\Vert }^2={\nabla }_{\mathbf{x}}{\mathbf{x}}^{\top }\mathbf{x}=2\mathbf{x}$.

Аналогично, для любой матрицы $\mathbf{X}$ справедливо ${\nabla }_{\mathbf{X}}\Vert \mathbf{X}{\Vert }_F^2=2\mathbf{X}$. Как мы увидим дальше, градиенты играют важную роль при построении алгоритмов оптимизации в глубоком обучении.

2.4.4 Цепное правило

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

Начнём с функций одной переменной. Пусть функции $y=f(u)$ и $u=g(x)$ дифференцируемы. Тогда по цепному правилу:

$$\frac{dy}{dx}=\frac{dy}{du}\frac{du}{dx}.$$

Теперь рассмотрим более общий случай, когда функция зависит от произвольного числа переменных. Пусть дифференцируемая функция $y$ имеет аргументы $u_1,u_2,\dots ,u_m$, причём каждая дифференцируемая функция $u_i$ имеет аргументы $x_1,x_2,\dots ,x_n$. Заметим, что $y$ — функция от $x_1,x_2,\dots ,x_n$. Для любого $i=1,2,\dots ,n$ цепное правило даёт:

$$\frac{\partial y}{\partial x_i}=\frac{\partial y}{\partial u_1}\frac{\partial u_1}{\partial x_i}+\frac{\partial y}{\partial u_2}\frac{\partial u_2}{\partial x_i}+\cdots +\frac{\partial y}{\partial u_m}\frac{\partial u_m}{\partial x_i}$$

Резюме

• Дифференцирование и интегрирование — две ветви математического анализа; первое применимо к задачам оптимизации в глубоком обучении.
• Производную можно интерпретировать как мгновенную скорость изменения функции по её переменной; она также равна угловому коэффициенту касательной к графику функции.
• Градиент — это вектор, компонентами которого служат частные производные многомерной функции по всем её переменным.
• Цепное правило позволяет дифференцировать составные функции.

Упражнения

1. Постройте график функции $y=f(x)=x^3-\frac{1}{x}$ и её касательной в точке $x=1$.
2. Найдите градиент функции $f(\mathbf{x})=3x_1^2+5e^{x_2}$.
3. Чему равен градиент функции $f(\mathbf{x})=\Vert \mathbf{x}{\Vert }_2$?
4. Запишите цепное правило для функции $u=f(x,y,z)$, где $x=x(a,b)$, $y=y(a,b)$, $z=z(a,b)$.

MXNet: Обсуждение

PyTorch: Обсуждение

TensorFlow: Обсуждение

PaddlePaddle: Обсуждение

2.5 Автоматическое дифференцирование

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

Фреймворки глубокого обучения ускоряют вычисление производных, вычисляя их автоматически, то есть используя автоматическое дифференцирование (automatic differentiation). На практике по заданной модели система строит вычислительный граф (computational graph), в котором отслеживается, какие данные и какие операции комбинируются для получения результата. Автоматическое дифференцирование позволяет системе затем распространять градиенты назад (backpropagate). Здесь обратное распространение (backpropagation) означает обход всего вычислительного графа с заполнением частных производных по каждому параметру.

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

В качестве демонстрации предположим, что мы хотим продифференцировать функцию $y=2{\mathbf{x}}^{\top }\mathbf{x}$ по вектору-столбцу $\mathbf{x}$. Сначала создадим переменную x и присвоим ей начальное значение.

from mxnet import autograd, np, npx
npx.set_np()

x = np.arange(4.0)
x

import torch

x = torch.arange(4.0)
x

import tensorflow as tf

x = tf.range(4, dtype=tf.float32)
x

import warnings
warnings.filterwarnings(action='ignore')
import paddle

x = paddle.arange(4, dtype='float32')
x

Прежде чем вычислять градиент $y$ по $\mathbf{x}$, нужно место, где он будет храниться. Важно, что мы не будем выделять новую память при каждом дифференцировании по параметру. Поскольку мы часто обновляем одни и те же параметры тысячи раз, выделение новой памяти каждый раз может быстро исчерпать ресурсы. Заметим, что градиент скалярной функции по вектору $\mathbf{x}$ — это вектор той же формы, что и $\mathbf{x}$.

# Выделяем память под градиент тензора вызовом attach_grad
x.attach_grad()
# После вычисления градиента по x он доступен через атрибут 'grad'; изначально его значение равно 0
x.grad

x.requires_grad_(True)  # Эквивалентно x=torch.arange(4.0,requires_grad=True)
x.grad  # Значение по умолчанию — None

x = tf.Variable(x)

x = paddle.to_tensor(x, stop_gradient=False)
x.grad  # Значение по умолчанию — None

Теперь вычислим $y$.

# Помещаем код внутрь autograd.record, чтобы построить вычислительный граф
with autograd.record():
    y = 2 * np.dot(x, x)
y

y = 2 * torch.dot(x, x)
y

# Записываем все вычисления на ленту
with tf.GradientTape() as t:
    y = 2 * tf.tensordot(x, x, axes=1)
y

y = 2 * paddle.dot(x, x)
y

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

y.backward()
x.grad

y.backward()
x.grad

x_grad = t.gradient(y, x)
x_grad

y.backward()
x.grad

Градиент функции $y=2{\mathbf{x}}^{\top }\mathbf{x}$ по $\mathbf{x}$ должен быть равен $4\mathbf{x}$. Быстро проверим, что градиент вычислен верно.

x.grad == 4 * x

x_grad == 4 * x

Теперь вычислим другую функцию от x.

with autograd.record():
    y = x.sum()
y.backward()
x.grad  # Перезаписывается новым вычисленным градиентом

# По умолчанию PyTorch накапливает градиенты, поэтому предыдущие значения нужно обнулить
x.grad.zero_()
y = x.sum()
y.backward()
x.grad

with tf.GradientTape() as t:
    y = tf.reduce_sum(x)
t.gradient(y, x)  # Перезаписывается новым вычисленным градиентом

# По умолчанию PaddlePaddle накапливает градиенты, поэтому предыдущие значения нужно очистить
x.clear_gradient()
y = paddle.sum(x)
y.backward()
x.grad

2.5.2 Обратное распространение для нескалярных переменных

Когда y не является скаляром, наиболее естественной интерпретацией производной вектора y по вектору x будет матрица. Для тензоров высокого порядка и размерности результатом дифференцирования может быть тензор высокого порядка.

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

# При вызове backward для векторной переменной y (функции от x) элементы y суммируются,
# образуя новую скалярную переменную. Затем вычисляется градиент этой скалярной переменной по x
with autograd.record():
    y = x * x  # y — вектор
y.backward()
x.grad  # Эквивалентно y=sum(x*x)

# Для вызова backward у нескаляра нужно передать аргумент gradient, задающий градиент
# дифференцируемой функции по self. В этом примере нам нужна только сумма частных производных,
# поэтому подходит градиент, равный 1
x.grad.zero_()
y = x * x
# Эквивалентно y.backward(torch.ones(len(x)))
y.sum().backward()
x.grad

with tf.GradientTape() as t:
    y = x * x
t.gradient(y, x)  # Эквивалентно y=tf.reduce_sum(x*x)

x.clear_gradient()
y = x * x
paddle.sum(y).backward()
x.grad

2.5.3 Отделение вычислений

Иногда мы хотим вынести некоторые вычисления за пределы записанного вычислительного графа. Например, пусть y вычисляется как функция x, а z — как функция y и x. Предположим, мы хотим вычислить градиент z по x, но по какой-то причине хотим рассматривать y как константу и учитывать только то, как x действует после вычисления y.

Здесь можно отделить y, вернув новую переменную u, которая имеет то же значение, что и y, но отбрасывает информацию о том, как y была вычислена в графе. Иными словами, градиент не будет распространяться назад через u к x. Поэтому следующая функция обратного распространения вычисляет частную производную z=u*x по x, рассматривая u как константу, а не частную производную z=x*x*x по x.

with autograd.record():
    y = x * x
    u = y.detach()
    z = u * x
z.backward()
x.grad == u

x.grad.zero_()
y = x * x
u = y.detach()
z = u * x

z.sum().backward()
x.grad == u

# Установите persistent=True, чтобы вызывать t.gradient несколько раз
with tf.GradientTape(persistent=True) as t:
    y = x * x
    u = tf.stop_gradient(y)
    z = u * x

x_grad = t.gradient(z, x)
x_grad == u

x.clear_gradient()
y = x * x
u = y.detach()
z = u * x

paddle.sum(z).backward()
x.grad == u

Поскольку вычисление y записано, мы можем затем вызвать обратное распространение для y и получить производную y=x*x по x, то есть 2*x.

y.backward()
x.grad == 2 * x

x.grad.zero_()
y.sum().backward()
x.grad == 2 * x

t.gradient(y, x) == 2 * x

x.clear_gradient()
paddle.sum(y).backward()
x.grad == 2 * x

2.5.4 Вычисление градиентов для потока управления Python

Одно из преимуществ автоматического дифференцирования в том, что даже если вычислительный граф функции строится через управляющие конструкции Python (условия, циклы или произвольные вызовы функций), мы всё равно можем вычислить градиент получившейся переменной. В приведённом ниже коде число итераций цикла while и результат оператора if зависят от значения входа a.

def f(a):
    b = a * 2
    while np.linalg.norm(b) < 1000:
        b = b * 2
    if b.sum() > 0:
        c = b
    else:
        c = 100 * b
    return c

def f(a):
    b = a * 2
    while b.norm() < 1000:
        b = b * 2
    if b.sum() > 0:
        c = b
    else:
        c = 100 * b
    return c

def f(a):
    b = a * 2
    while tf.norm(b) < 1000:
        b = b * 2
    if tf.reduce_sum(b) > 0:
        c = b
    else:
        c = 100 * b
    return c

def f(a):
    b = a * 2
    while paddle.norm(b) < 1000:
        b = b * 2
    if paddle.sum(b) > 0:
        c = b
    else:
        c = 100 * b
    return c

Вычислим градиент.

a = np.random.normal()
a.attach_grad()
with autograd.record():
    d = f(a)
d.backward()

a = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()

a = tf.Variable(tf.random.normal(shape=()))
with tf.GradientTape() as t:
    d = f(a)
d_grad = t.gradient(d, a)
d_grad

a = paddle.to_tensor(paddle.randn(shape=[1]), stop_gradient=False)
d = f(a)
d.backward()

Теперь проанализируем определённую выше функцию f. Заметим, что по входу a она кусочно-линейна. Иными словами, для любого a найдётся некоторая константа k, такая что f(a)=k*a, причём значение k зависит от входа a. Поэтому правильность градиента можно проверить, сравнив его с d/a.

a.grad == d / a

d_grad == d / a

Резюме

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

Упражнения

1. Почему вычисление производной второго порядка обходится дороже, чем производной первого порядка?
2. Запустите функцию обратного распространения сразу повторно после её выполнения и посмотрите, что произойдёт.
3. В примере с потоком управления мы вычисляем производную d по a. Что произойдёт, если изменить переменную a на случайный вектор или матрицу?
4. Придумайте другой пример для вычисления градиента с потоком управления, запустите его и проанализируйте результат.
5. Пусть $f(x)=\sin (x)$. Постройте графики $f(x)$ и $\frac{df(x)}{dx}$, причём производную вычислите без использования равенства $f^{\prime }(x)=\cos (x)$.

MXNet: Обсуждение

PyTorch: Обсуждение

TensorFlow: Обсуждение

PaddlePaddle: Обсуждение

2.6 Вероятность

Попросту говоря, машинное обучение — это предсказание.

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

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

Рис. 2.6.1. Изображения разного разрешения ($10\times 10$, $20\times 20$, $40\times 40$, $80\times 80$ и $160\times 160$ пикселей)

Как видно на рис. 2.6.1, хотя человек легко распознаёт кошек и собак при разрешении $160\times 160$ пикселей, при $40\times 40$ пикселях это становится трудной задачей, а при $10\times 10$ пикселях почти невозможно. Иначе говоря, наша способность различать кошек и собак на большом расстоянии (а значит, при меньшем разрешении) может превратиться в простое угадывание. Теория вероятностей даёт нам формальный способ выразить степень нашей уверенности. Если мы полностью уверены, что на изображении кошка, то вероятность того, что метка $y$ — «кошка», то есть $P(y=\text{кошка})$, равна $1$. Если у нас нет никаких доказательств того, что $y=\text{кошка}$ или $y=\text{собака}$, то можно считать эти два варианта равновероятными: $P(y=\text{кошка})=P(y=\text{собака})=0.5$. Если мы не очень уверены, что на изображении кошка, можно приписать вероятности значение $0.5<P(y=\text{кошка})<1$.

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

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

2.6.1 Основы теории вероятностей

Допустим, мы бросаем кубик и хотим узнать, какова вероятность выпадения единицы, а не какого-либо другого числа. Если кубик честный, то все шесть исходов $\{1,\dots ,6\}$ равновозможны, и поэтому можно сказать, что вероятность выпадения $1$ равна $\frac{1}{6}$.

Однако для реального кубика, полученного с завода, нужно проверить, нет ли в нём дефекта. Единственный способ сделать это — бросить его много раз и записать результаты. Каждый бросок даёт одно значение из $\{1,\dots ,6\}$. Для каждого значения естественный способ — разделить число его появлений на общее число бросков. Так мы получаем оценку вероятности этого события (event). Закон больших чисел (law of large numbers) утверждает: по мере увеличения числа бросков эта оценка будет всё ближе к истинной вероятности. Попробуем это на коде!

Сначала импортируем необходимые пакеты.

%matplotlib inline
from d2l import mxnet as d2l
from mxnet import np, npx
import random
npx.set_np()

%matplotlib inline
from d2l import torch as d2l
import torch
from torch.distributions import multinomial

%matplotlib inline
from d2l import tensorflow as d2l
import tensorflow as tf
import tensorflow_probability as tfp
import numpy as np

%matplotlib inline
from d2l import paddle as d2l
import warnings
warnings.filterwarnings("ignore")
import paddle
import random
import numpy as np

В статистике процесс извлечения выборки из распределения вероятностей называют выборкой (sampling). Грубо говоря, распределение (distribution) можно считать присвоением вероятностей событиям; более строгое определение мы дадим позже. Распределение, которое присваивает вероятности некоторому набору дискретных вариантов, называют мультиномиальным распределением (multinomial distribution).

Чтобы извлечь выборку, то есть бросить кубик, достаточно передать вектор вероятностей. Результат — другой вектор той же длины: его значение с индексом $i$ — это число раз, когда в выборке выпал исход $i$.

fair_probs = [1.0 / 6] * 6
np.random.multinomial(1, fair_probs)

fair_probs = torch.ones([6]) / 6
multinomial.Multinomial(1, fair_probs).sample()

fair_probs = tf.ones(6) / 6
tfp.distributions.Multinomial(1, fair_probs).sample()

fair_probs = [1.0 / 6] * 6
paddle.distribution.Multinomial(1, paddle.to_tensor(fair_probs)).sample()

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

np.random.multinomial(10, fair_probs)

multinomial.Multinomial(10, fair_probs).sample()

tfp.distributions.Multinomial(10, fair_probs).sample()

paddle.distribution.Multinomial(10, paddle.to_tensor(fair_probs)).sample()

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

counts = np.random.multinomial(1000, fair_probs).astype(np.float32)
counts / 1000

# Сохраняем результаты как 32-битные числа с плавающей точкой для деления
counts = multinomial.Multinomial(1000, fair_probs).sample()
counts / 1000  # Относительная частота как оценка

counts = tfp.distributions.Multinomial(1000, fair_probs).sample()
counts / 1000

counts = paddle.distribution.Multinomial(1000, paddle.to_tensor(fair_probs)).sample()
counts / 1000

Поскольку данные получены с честного кубика, мы знаем, что истинная вероятность каждого исхода равна $\frac{1}{6}$, примерно $0.167$, поэтому оценки, полученные выше, выглядят разумно.

Мы также можем увидеть, как эти вероятности со временем сходятся к истинным. Проведём 500 групп экспериментов, в каждой из которых возьмём по 10 выборок.

counts = np.random.multinomial(10, fair_probs, size=500)
cum_counts = counts.astype(np.float32).cumsum(axis=0)
estimates = cum_counts / cum_counts.sum(axis=1, keepdims=True)

d2l.set_figsize((6, 4.5))
for i in range(6):
    d2l.plt.plot(estimates[:, i].asnumpy(),
                 label=("P(кубик=" + str(i + 1) + ")"))
d2l.plt.axhline(y=0.167, color='black', linestyle='dashed')
d2l.plt.gca().set_xlabel('Группы экспериментов')
d2l.plt.gca().set_ylabel('Оценка вероятности')
d2l.plt.legend();

counts = multinomial.Multinomial(10, fair_probs).sample((500,))
cum_counts = counts.cumsum(dim=0)
estimates = cum_counts / cum_counts.sum(dim=1, keepdims=True)

d2l.set_figsize((6, 4.5))
for i in range(6):
    d2l.plt.plot(estimates[:, i].numpy(),
                 label=("P(кубик=" + str(i + 1) + ")"))
d2l.plt.axhline(y=0.167, color='black', linestyle='dashed')
d2l.plt.gca().set_xlabel('Группы экспериментов')
d2l.plt.gca().set_ylabel('Оценка вероятности')
d2l.plt.legend();

counts = tfp.distributions.Multinomial(10, fair_probs).sample(500)
cum_counts = tf.cumsum(counts, axis=0)
estimates = cum_counts / tf.reduce_sum(cum_counts, axis=1, keepdims=True)

d2l.set_figsize((6, 4.5))
for i in range(6):
    d2l.plt.plot(estimates[:, i].numpy(),
                 label=("P(кубик=" + str(i + 1) + ")"))
d2l.plt.axhline(y=0.167, color='black', linestyle='dashed')
d2l.plt.gca().set_xlabel('Группы экспериментов')
d2l.plt.gca().set_ylabel('Оценка вероятности')
d2l.plt.legend();

counts = paddle.distribution.Multinomial(10, paddle.to_tensor(fair_probs)).sample((500,1))
cum_counts = counts.cumsum(axis=0)
cum_counts = cum_counts.squeeze(axis=1)
estimates = cum_counts / cum_counts.sum(axis=1, keepdim=True)

d2l.set_figsize((6, 4.5))
for i in range(6):
    d2l.plt.plot(estimates[:, i],
                 label=("P(кубик=" + str(i + 1) + ")"))
d2l.plt.axhline(y=0.167, color='black', linestyle='dashed')
d2l.plt.gca().set_xlabel('Группы экспериментов')
d2l.plt.gca().set_ylabel('Оценка вероятности')
d2l.plt.legend()

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

2.6.1.1 Аксиомы теории вероятностей

В случае с бросанием кубика множество $\mathcal{S}=\{1,2,3,4,5,6\}$ называют пространством выборки (sample space) или пространством исходов (outcome space), а каждый его элемент — исходом (outcome). Событие (event) — это набор исходов из пространства выборки. Например, «выпала $5$» ($\{5\}$) и «выпало нечётное число» ($\{1,3,5\}$) — допустимые события при бросании кубика. Заметим, что если исход случайного эксперимента принадлежит $\mathcal{A}$, то событие $\mathcal{A}$ произошло. То есть если выпала $3$, то, поскольку $3\in \{1,3,5\}$, можно сказать, что событие «выпало нечётное число» произошло.

Вероятность (probability) можно рассматривать как функцию, которая сопоставляет множествам действительные значения. В заданном пространстве выборки $\mathcal{S}$ вероятность события $\mathcal{A}$, обозначаемая $P(\mathcal{A})$, обладает следующими свойствами:

• для любого события $\mathcal{A}$ его вероятность никогда не бывает отрицательной: $P(\mathcal{A})\ge 0$;
• вероятность всего пространства выборки равна $1$: $P(\mathcal{S})=1$;
• для любой счётной последовательности несовместных (mutually exclusive) событий ${\mathcal{A}}_1,{\mathcal{A}}_2,\dots$, то есть таких, что ${\mathcal{A}}_i\cap {\mathcal{A}}_j=\varnothing$ для всех $i\ne j$, вероятность того, что произойдёт одно из них, равна сумме их вероятностей: $P({\bigcup }_{i=1}^{\infty }{\mathcal{A}}_i)={\sum }_{i=1}^{\infty }P({\mathcal{A}}_i)$.

Перечисленные свойства — аксиомы теории вероятностей, которые предложил Колмогоров в 1933 году. С помощью этой системы аксиом можно обойти философские споры о случайности и вместо этого строго рассуждать на языке математики. Например, пусть событие ${\mathcal{A}}_1$ — всё пространство выборки, а для всех $i>1$ выполнено ${\mathcal{A}}_i=\varnothing$. Тогда можно доказать, что $P(\varnothing )=0$, то есть вероятность невозможного события равна $0$.

2.6.1.2 Случайные величины

В нашем эксперименте с бросанием кубика мы ввели понятие случайной величины (random variable). Случайная величина может быть почти любой величиной, и она принимает одно из значений, возможных в случайном эксперименте. Рассмотрим случайную величину $X$, значения которой принадлежат пространству выборки кубика $\mathcal{S}=\{1,2,3,4,5,6\}$. Событие «выпала $5$» можно записать как $\{X=5\}$ или $X=5$, а его вероятность — как $P(\{X=5\})$ или $P(X=5)$. Записью $P(X=a)$ мы отличаем случайную величину $X$ от значений $a$, которые она может принимать. Однако такая запись может быть громоздкой. Чтобы упростить обозначения, с одной стороны, $P(X)$ можно записывать как распределение (distribution) случайной величины $X$: оно сообщает, с какой вероятностью $X$ принимает то или иное значение. С другой стороны, можно просто писать $P(a)$ для вероятности того, что случайная величина принимает значение $a$. Поскольку события в теории вероятностей — это наборы исходов из пространства выборки, можно задавать диапазоны значений случайной величины. Например, $P(1\le X\le 3)$ обозначает событие $\{1\le X\le 3\}$, то есть вероятность того, что $X$ принимает значение $1$, $2$ или $3$. Эквивалентно, $P(1\le X\le 3)$ — это вероятность того, что случайная величина $X$ принимает значения из $\{1,2,3\}$.

Обратите внимание на различие между дискретными (discrete) случайными величинами (например, гранями кубика) и непрерывными (continuous) случайными величинами (например, весом и ростом человека). В реальной жизни не имеет особого смысла измерять, совпадает ли рост двух людей в точности. Если производить измерения достаточно точно, окажется, что на Земле нет двух людей с одинаковым ростом. В таких случаях осмысленнее спрашивать, попадает ли рост человека в заданный интервал, например между 1,79 м и 1,81 м. В подобных ситуациях возможность получить то или иное значение выражают через плотность (density). Вероятность того, что рост в точности равен 1,80 м, равна 0, но плотность не равна 0. На любом интервале между двумя разными ростами вероятность ненулевая. В оставшейся части раздела мы будем рассматривать вероятности в дискретном пространстве. Вероятности непрерывных случайных величин можно найти в разделе о случайных величинах математического приложения к книге.

2.6.2 Работа с несколькими случайными величинами

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

Ещё более сложный пример: изображение содержит миллионы пикселей, а значит, миллионы случайных величин. Во многих случаях к изображению прилагается метка (label), указывающая объект на изображении; метку тоже можно рассматривать как случайную величину. Можно даже считать случайными величинами все метаданные: положение, время, диафрагму, фокусное расстояние, ISO, расстояние фокусировки и тип камеры. Все эти величины случайны и встречаются совместно. Когда мы работаем с несколькими случайными величинами, нас интересует сразу несколько из них.

2.6.2.1 Совместная вероятность

Первое понятие — совместная вероятность (joint probability) $P(A=a,B=b)$. Для любых значений $a$ и $b$ совместная вероятность отвечает на вопрос: какова вероятность того, что одновременно выполняются $A=a$ и $B=b$? Заметим, что для любых значений $a$ и $b$ выполняется $P(A=a,B=b)\le P(A=a)$. Это очевидно: чтобы одновременно произошли $A=a$ и $B=b$, должно произойти $A=a$, и должно произойти $B=b$ (и наоборот). Поэтому вероятность одновременного наступления $A=a$ и $B=b$ не превышает вероятности наступления каждого из этих событий по отдельности.

2.6.2.2 Условная вероятность

Из неравенства для совместной вероятности следует интересное соотношение: $0\le \frac{P(A=a,B=b)}{P(A=a)}\le 1$. Это отношение называют условной вероятностью (conditional probability) и обозначают $P(B=b\mid A=a)$: это вероятность того, что $B=b$, при условии, что $A=a$ уже произошло.

2.6.2.3 Теорема Байеса

Из определения условной вероятности можно вывести одно из самых полезных уравнений статистики — теорему Байеса (Bayes’ theorem). По правилу умножения (multiplication rule) имеем $P(A,B)=P(B\mid A)P(A)$. По симметрии получаем $P(A,B)=P(A\mid B)P(B)$. Предполагая, что $P(B)>0$, и выражая одну из условных вероятностей, получаем

$$P(A\mid B)=\frac{P(B\mid A)P(A)}{P(B)}.$$

Здесь мы используем компактную запись: $P(A,B)$ — совместное распределение (joint distribution), а $P(A\mid B)$ — условное распределение (conditional distribution). Такое распределение можно вычислить при заданных значениях $A=a,B=b$.

2.6.2.4 Маргинализация

Чтобы складывать вероятности событий, нужно правило суммы (sum rule): вероятность $B$ равна сумме совместных вероятностей $B$ со всеми возможными значениями $A$:

$$P(B)=\sum _{A}P(A,B),$$

Это называется маргинализацией (marginalization). Вероятность или распределение, полученное в результате маргинализации, называют маргинальной вероятностью (marginal probability) или маргинальным распределением (marginal distribution).

2.6.2.5 Независимость

Другое полезное свойство — зависимость (dependence) и независимость (independence). Если две случайные величины $A$ и $B$ независимы, то наступление события $A$ не зависит от наступления события $B$. В этом случае статистики обычно записывают $A\perp B$. По теореме Байеса сразу получаем и $P(A\mid B)=P(A)$. Во всех остальных случаях мы называем $A$ и $B$ зависимыми. Например, два последовательных броска кубика — независимые события. В отличие от них, положение выключателя и яркость комнаты не независимы (потому что возможны перегорание лампочки, перебой электропитания или поломка выключателя).

Поскольку $P(A\mid B)=\frac{P(A,B)}{P(B)}=P(A)$ равносильно $P(A,B)=P(A)P(B)$, две случайные величины независимы тогда и только тогда, когда их совместное распределение равно произведению их отдельных распределений. Аналогично, при заданной третьей случайной величине $C$ две величины $A$ и $B$ условно независимы (conditionally independent) тогда и только тогда, когда $P(A,B\mid C)=P(A\mid C)P(B\mid C)$. Это записывают как $A\perp B\mid C$.

2.6.2.6 Применение

Разберём пример! Предположим, врач проводит пациенту тест на ВИЧ (вирус иммунодефицита человека). Тест довольно точен: если пациент здоров, вероятность ложного положительного результата составляет всего 1%; если пациент действительно инфицирован ВИЧ, тест никогда не даёт отрицательного результата. Обозначим через $D_1$ результат диагностики ($1$ — положительный, $0$ — отрицательный), а через $H$ — статус ВИЧ-инфекции ($1$ — инфицирован, $0$ — нет). Условные вероятности приведены в таблице 2.6.1.

Таблица 2.6.1. Условная вероятность $P(D_1\mid H)$

Заметим, что сумма по каждому столбцу равна 1 (а по строкам — нет), поскольку условные вероятности, как и вероятности, должны в сумме давать 1. Вычислим вероятность того, что пациент инфицирован ВИЧ, если тест положителен, то есть $P(H=1\mid D_1=1)$. Очевидно, что ответ зависит от того, насколько распространено заболевание, поскольку это влияет на число ложных срабатываний. Предположим, что население в целом здорово, например $P(H=1)=0.0015$. Чтобы применить теорему Байеса, нужно с помощью маргинализации и правила умножения найти