Книжная полка Сохранить
Размер шрифта:
А
А
А
|  Шрифт:
Arial
Times
|  Интервал:
Стандартный
Средний
Большой
|  Цвет сайта:
Ц
Ц
Ц
Ц
Ц

Глубокое обучение с JAX

Покупка
Новинка
Артикул: 890868.01.99
Доступ онлайн
2 549 ₽
В корзину
Книга обучает созданию эффективных нейронных сетей с применением библиотеки JAX от Google. Специальные инструменты JAX помогут вам справиться с проблемами нехватки производительности, характерными для глубокого обучения на больших данных. Примеры реалистичных проектов и листинги исходного кода с подробными комментариями показывают, как парадигма функционального программирования JAX улучшает сочетаемость различных программных компонентов и возможности распараллеливания. Для читателей, имеющих опыт программирования на языке Python и знакомых с принципами глубокого обучения.
Сапунов, Г. Глубокое обучение с JAX : практическое руководство / Г. Сапунов ; пер. с англ. А. В. Снастина. – Москва : ДМК Пресс, 2025. - 528 с. – ISBN 978-5-93700-192-4. - Текст : электронный. - URL: https://znanium.ru/catalog/product/2275281 (дата обращения: 18.11.2026). – Режим доступа: по подписке.
Фрагмент текстового слоя документа размещен для индексирующих роботов
Григорий Сапунов
Глубокое обучение с JAX


Deep Learning with JAX
GRIGORY SAPUNOV


Глубокое обучение с JAX
ГРИГОРИЙ САПУНОВ
Москва, 2025


УДК	 004.85JAX
ББК	 16.6
С19
Сапунов Г.
С19	
Глубокое обучение с JAX / пер. с англ. А. В. Снастина. – М.: ДМК Пресс, 2025. – 
526 с.: ил. 
ISBN 978-5-93700-192-4
Книга обучает созданию эффективных нейронных сетей с применением библиотеки JAX от Google. Специальные инструменты JAX помогут вам справиться 
с проблемами нехватки производительности, характерными для глубокого обучения 
на больших данных. Примеры реалистичных проектов и листинги исходного кода 
с подробными комментариями показывают, как парадигма функционального программирования JAX улучшает сочетаемость различных программных компонентов 
и возможности распараллеливания.
Для читателей, имеющих опыт программирования на языке Python и знакомых 
с принципами глубокого обучения.
УДК  004.85JAX
ББК  16.6
Copyright © DMK Press 2025. Authorized translation of the English edition. 
© 2024 Manning Publications. This translation is published and sold by permission of Manning 
Publications, the owner of all rights to publish and sell the same.
Все права защищены. Любая часть этой книги не может быть воспроизведена в какой 
бы то ни было форме и какими бы то ни было средствами без письменного разрешения владельцев авторских прав.
ISBN 978-1-6334-3888-0 (англ.)	
©  Manning Publications, 2024
ISBN 978-5-93700-192-4 (рус.)	
©  Перевод, оформление, издание, ДМК Пресс, 2025


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


Оглавление
Часть I	
ПЕРВЫЕ ШАГИ.......................................................................................... 23
1    Когда и зачем используется JAX......................................................................... 25
2    Первая программа в JAX...................................................................................... 46
Часть II	 ЯДРО JAX..................................................................................................... 79
3    Работа с массивами............................................................................................... 81
4    Вычисление градиентов......................................................................................132
5    Компиляция кода..................................................................................................178
6    Векторизация кода...............................................................................................223
7    Распараллеливание вычислений......................................................................254
8    Использование сегментирования тензоров...................................................305
9    Случайные числа в JAX........................................................................................333
10    Работа с pytree........................................................................................................368
Часть III	 ЭКОСИСТЕМА...........................................................................................393
11    Высокоуровневые библиотеки поддержки нейронных сетей...................395
12    Другие члены экосистемы JAX...........................................................................445


Содержание
Оглавление............................................................................................................ 6
Предисловие........................................................................................................ 12
Благодарности................................................................................................... 14
О книге................................................................................................................ 16
Об авторе........................................................................................................... 21
Об иллюстрации на обложке............................................................................ 22
Часть I		
ПЕРВЫЕ ШАГИ.......................................................................... 23
1	
Когда и зачем используется JAX................................................... 25
1.1	
Почему нужно использовать JAX........................................................ 30
1.1.1	
Производительность вычислений............................................... 30
1.1.2	
Функциональный подход.............................................................. 34
1.1.3	
Экосистема JAX........................................................................... 35
1.2	
Чем JAX отличается от NumPy............................................................. 37
1.2.1	
JAX как NumPy............................................................................. 38
1.2.2	
Компонуемые трансформации.................................................... 39
1.3	
Чем JAX отличается от TensorFlow и PyTorch.................................... 42
Резюме................................................................................................................ 45
2	
Первая программа в JAX.................................................................... 46
2.1	
Учебная задача машинного обучения: классификация  
	
рукописных цифр.................................................................................. 47
2.2	
Общий обзор проекта глубокого обучения с использованием  
	
JAX............................................................................................................ 49
2.3	
Загрузка и подготовка набора данных............................................... 51
2.4	
Простая нейронная сеть с использованием JAX............................... 54
2.4.1	
Инициализация нейронной сети................................................. 56
2.4.2	
Нейронная сеть с прямой связью................................................. 58


Содержание
2.5	
vmap: автоматически векторизованные вычисления  
	
для обработки пакетов......................................................................... 61
2.6	
Autodiff: как вычислять градиенты, ничего не зная  
	
о производных....................................................................................... 65
2.6.1	
Функция потерь........................................................................... 67
2.6.2	
Определение градиентов............................................................. 68
2.6.3	
Шаг обновления градиента......................................................... 68
2.6.4	
Цикл тренировки......................................................................... 70
2.7	
JIT: компиляция кода для ускорения его выполнения.................... 72
2.8	
Сохранение и развертывание модели................................................ 74
2.9	
Чистые функции и компонуемые трансформации: почему  
	
они так важны........................................................................................ 76
Упражнение 2.1................................................................................................. 77
Резюме................................................................................................................ 78
Часть II	
ЯДРО JAX......................................................................................... 79
3	
Работа с массивами.............................................................................. 81
3.1	
Обработка изображений с использованием массивов NumPy....... 82
3.1.1	
Загрузка изображения в массив NumPy....................................... 84
3.1.2	
Выполнение простых операций предварительной  
	
обработки с изображением......................................................... 88
3.1.3	
Добавление шума в изображение................................................ 90
3.1.4	
Реализация фильтрации изображения........................................ 92
3.1.5	
Сохранение тензора как файла изображения............................. 98
3.2	
Массивы в JAX........................................................................................ 99
3.2.1	
Переход на NumPy-подобный API JAX........................................100
3.2.2	
Что такое Array?.......................................................................102
3.2.3	
Операции, связанные с устройствами.......................................104
3.2.4	
Асинхронная диспетчеризация...................................................111
3.2.5	
Выполнение вычислений на TPU.................................................112
3.3	
Отличия от NumPy................................................................................117
3.3.1	
Неизменяемость.........................................................................117
3.3.2	
Типы............................................................................................121
3.4	
Интерфейсы высокого и низкого уровней: jax.numpy  
	
и jax.lax................................................................................................126
3.4.1	
Базисные элементы управления потоком выполнения.............127
3.4.2	
Повышение (расширение) типа..................................................129
Упражнение 3.1................................................................................................130
Резюме...............................................................................................................130
4	
Вычисление градиентов.....................................................................132
4.1	
Различные способы вычисления производных..............................134
4.1.1	
Дифференцирование вручную.....................................................136
4.1.2	
Символьное дифференцирование................................................137
4.1.3	
Численное дифференцирование..................................................139
4.1.4	
Автоматическое дифференцирование.......................................141
4.2	
Вычисление градиентов с использованием autodiff.......................144
4.2.1	
Работа с градиентами в TensorFlow..........................................146


Содержание
Работа с градиентами в PyTorch...............................................148
4.2.3	
Работа с градиентами в JAX......................................................149
4.2.4	
Производные более высоких порядков........................................158
4.2.5	
Вариант со многими переменными...........................................160
4.3	
Прямой и обратный режимы autodiff...............................................164
4.3.1	
Трассировка оценок....................................................................165
4.3.2	
Прямой режим и jvp()................................................................166
4.3.3	
Обратный режим и vjp()...........................................................171
4.3.4	
Материалы для более глубокого изучения..................................175
Резюме...............................................................................................................176
5	
Компиляция кода....................................................................................178
5.1	
Использование компиляции..............................................................180
5.1.1	
Использование JIT-компиляции..................................................181
5.1.2	
Чистые функции и процесс компиляции.....................................190
5.2	
Внутренний механизм JIT...................................................................193
5.2.1	
Jaxpr – промежуточное представление для программ JAX.......193
5.2.2	
XLA..............................................................................................204
5.2.3	
Использование AOT-компиляции................................................211
5.3	
Ограничения JIT-компиляции...........................................................216
5.3.1	
Чистые функции и функции, не являющиеся чистыми..............216
5.3.2	
Точные числовые данные.............................................................216
5.3.3	
Условные выражения, использующие значения входных 
параметров.............................................................................................216
5.3.4	
Медленная компиляция...............................................................217
5.3.5	
Методы класса...........................................................................219
5.3.6	
Простые функции.......................................................................221
Упражнение 5.1................................................................................................221
Резюме...............................................................................................................221
6	
Векторизация кода...............................................................................223
6.1	
Различные способы векторизации функции...................................224
6.1.1	
Простейшие методики...............................................................226
6.1.2	
Векторизация вручную...............................................................229
6.1.3	
Автоматическая векторизация................................................230
6.1.4	
Сравнение скорости выполнения...............................................231
6.2	
Управление поведением vmap().........................................................233
6.2.1	
Управление осями массива для выполнения  
	
преобразования...........................................................................233
6.2.2	
Управление осями выходного массива........................................237
6.2.3	
Использование именованных аргументов..................................238
6.2.4	
Использование стиля декоратора.............................................241
6.2.5	
Использование коллективных операций....................................241
6.3	
Варианты использования vmap() из реальной практики...............243
6.3.1	
Обработка пакетов данных.......................................................244
6.3.2	
Пакетная обработка моделей нейронных сетей.......................246
6.3.3	
Поэлементные градиенты.........................................................247
6.3.4	
Векторизация циклов.................................................................249
Резюме...............................................................................................................253


Содержание
Распараллеливание вычислений...................................................254
7.1	
Распараллеливание вычислений с помощью pmap()......................256
7.1.1	
Установка начальных условий задачи........................................257
7.1.2	
Использование pmap (почти) так же, как vmap...........................260
7.2	
Управление поведением pmap().........................................................268
7.2.1	
Управление отображением осей входных и выходных  
	
данных.........................................................................................268
7.2.2	
Использование именованных осей и коллективных  
	
операций.....................................................................................276
7.3	
Пример программы тренировки нейронной сети  
	
с распараллеливанием  по данным....................................................285
7.3.1	
Подготовка данных и структуры нейронной сети...................286
7.3.2	
Реализация процедуры тренировки с распараллеливанием  
	
по данным...................................................................................290
7.4	
Использование конфигураций с несколькими хостами................296
Резюме...............................................................................................................303
8	
Использование сегментирования тензоров.........................305
8.1	
Основы сегментирования тензоров..................................................307
8.1.1	
Сетка устройств.......................................................................310
8.1.2	
Позиционное сегментирование..................................................310
8.1.3	
Пример с применением двумерной сетки..................................311
8.1.4	
Использование репликации.........................................................316
8.1.5	
Ограничения сегментирования..................................................319
8.1.6	
Сегментирование с именованием..............................................320
8.1.7	
Стратегия размещения устройств и ошибки...........................322
8.2	
Многослойный перцептрон с применением  
	
сегментирования тензоров.................................................................325
8.2.1	
Восьмиканальное распараллеливание данных............................325
8.2.2	
Четырехканальное распараллеливание по данным,  
	
двухканальное распараллеливание тензора..............................327
Резюме...............................................................................................................332
9	
Случайные числа в JAX.......................................................................333
9.1	
Генерация случайных данных............................................................335
9.1.1	
Загрузка набора данных..............................................................337
9.1.2	
Генерация случайного шума........................................................340
9.1.3	
Выполнение случайного расширения данных..............................344
9.2	
Отличия от NumPy................................................................................347
9.2.1	
Как работает NumPy.................................................................347
9.2.2	
Начальное число и состояние в NumPy......................................349
9.2.3	
PRNG в JAX..................................................................................353
9.2.4	
Более подробная конфигурация JAX PRNG.................................361
9.3	
Генерация случайных чисел в реальных приложениях..................362
9.3.1	
Создание полного конвейера расширения данных......................363
9.3.2	
Генерация случайных инициализаций для нейронной сети........364
Резюме...............................................................................................................366


Доступ онлайн
2 549 ₽
В корзину