PyTorch tutorial: краткое руководство для новичков

Что такое PyTorch?

PyTorch — это машина с открытым исходным кодом, обучающаяся ng Библиотека Python, используемая для реализаций глубокого обучения, таких как компьютерное зрение (с использованием TorchVision) и обработка естественного языка. Он был разработан исследовательской лабораторией искусственного интеллекта Facebook (FAIR) в 2016 году и с тех пор был принят во всех областях науки о данных и машинного обучения.

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

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

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

Зачем использовать PyTorch?

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

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

PyTorch делает еще один шаг вперед в этой доступности, ведя себя как стандартный Python. Кроме того, вы можете использовать дополнительные библиотеки Python с PyTorch, такие как популярные отладчики, такие как отладчик PyCharm.

PyTorch vs. TensorFlow

Основное различие между PyTorch и TensorFlow — это компромисс между простотой и производительностью: PyTorch легче изучать (особенно для программистов Python), в то время как TensorFlow имеет время обучения, но работает лучше и более широко используется.

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

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

• Динамический против статического Графики : PyTorch по умолчанию имеет динамические графики, которые немедленно реагируют на новые данные. TensorFlow имеет ограниченную поддержку динамических графиков с использованием TensorFlow Fold, но в основном использует статические графики.

• Интеграции : PyTorch удобен в использовании для проектов на AWS из-за его тесного подключения через TorchServe. TensorFlow хорошо интегрирован с Google Cloud и подходит для мобильных приложений благодаря использованию Swift API.

• Визуализация : TensorFlow имеет более надежные инструменты визуализации и предлагает более точный контроль над настройками графиков. Инструмент визуализации Visdom PyTorch или другие стандартные библиотеки построения графиков, такие как matplotlib, не так полнофункциональны, как TensorFlow, но их легче освоить.

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

Основы PyTorch

Тензоры

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

Они похожи на n-мерный массив NumPy и даже могут быть преобразованы в массив NumPy всего в одну строку.

Тензоры бывают 5 типов:

• FloatTensor : 32-битное число с плавающей запятой.
• DoubleTensor : 64-битное число с плавающей запятой
• HalfTensor : 16-битное число с плавающей запятой
• IntTensor : 32-битное int
• LongTensor : 64-bit int

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

  torch. set_default_tensor_type (t)  

Для инициализации двух FloatTensor :

  import torch # инициализация тензоровa  = torch.tensor (2) b = torch.tensor (1)  

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

  # additionprint (a + b) # subtractionprint (ba) # multiplicationprint  (a * b) # divisionprint (a/b)  

Вы также можете перемещать тензоры для обработки графическим процессором, используя cuda .

  если torch.cuda.is_available (): x = x.cuda () y = y.cuda () x + y  

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

  ones_tensor = torch.ones ((2, 2)) # тензор, содержащий все единицы и_тензор  = torch.rand ((2, 2)) # тензор, содержащий случайные значения  

Здесь мы указываем, что наш тензор должен быть 2 х2 кв. Квадрат заполняется либо всеми единицами при использовании функции ones () , либо случайными числами при использовании функции rand () .

Нейронные сети

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

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

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

PyTorch определяет нейронные сети с помощью пакета torch.nn , который содержит набор модулей для представления каждого уровня сети.

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

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

Вот пример нейронной сети в PyTorch:

  импортировать torchimport torch.nn как nnimport torch.nn.functional as  Fclass Net (nn.Module): def __init __ (self): super (Net, self) .__ init __ () # 1 входной канал изображения, 6 выходных каналов, квадратная свертка 3x3 # ядро ​​self.conv1 = nn.Conv2d (1, 6  , 3) self.conv2 = nn.Conv2d (6, 16, 3) # аффинная операция: y = Wx + b self.fc1 = nn.Linear (16 * 6 * 6, 120) # 6 * 6 от размера изображения  self.fc2 = nn.Linear (120, 84) self.fc3 = nn.Linear (84, 10) def forward (self, x): # Максимальный пул в окне (2, 2) x = F.max_pool2d (F  .relu (self.conv1 (x)), (2, 2)) # Если размер - квадрат, вы можете указать только одно число x = F.max_pool2d (F.relu (self.conv2 (x)), 2  ) x = x.view (-1, self.num_flat_features (x)) x = F.relu (self.fc1 (x)) x = F.relu (self.fc2 (x)) x = self.fc3 (x  ) return x def num_flat_features (self, x): size = x.size () [1:] # все измерения, кроме пакетного измерения num_features = 1 для размера s: num_features * = s re  Turn num_featuresnet = Net () print (net)  

nn.module обозначает, что это будет нейронная сеть, тогда мы определяем ее с помощью 2 Слои conv2d, которые выполняют двумерную свертку, и 3 линейных слоя, которые выполняют линейные преобразования.

Затем мы определяем прямой метод, чтобы обрисовать, как выполнять прямое распространение. Нам не нужно определять метод обратного распространения, потому что PyTorch по умолчанию включает функцию backwards () .

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

Autograd

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

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

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

  import torch # pytorch tensorx = torch.tensor (3.5, requires_grad = True) # y определяется как  функция xy = (x-1) * (x-2) * (x-3) # работа с gradienty.backward ()  

По умолчанию requires_grad имеет значение false , и PyTorch не будет отслеживать градиенты.. Указание requires_grad как True во время инициализации заставит PyTorch отслеживать градиенты для этого конкретного тензора всякий раз, когда мы выполняем с ним какую-либо операцию.

Этот код смотрит на y и видит, что он пришел из (x-1) * (x-2) * (x-3) , и автоматически работает градиент d y d x frac {dy} {dx } dx dy, 3 x 2 — 1 2 x + 1 1 3x ^ 2 — 12x + 11 3x 2 −12x + 11

Инструкция также вычисляет числовое значение этот градиент и помещает его в тензор x рядом с фактическим значением x , 3.5 .

Все вместе, t градиент: 3 * (3,5 * 3,5) - 12 * (3,5) + 11 = 5,75 .

Градиенты накапливаются по умолчанию, что может повлиять на результат, если их не сбросить. Используйте model.zero_grad () , чтобы обнулять график после каждого градиента.

Оптимизаторы

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

Все оптимизаторы PyTorch содержатся в пакете torch.optim с каждой оптимизацией Схема предназначена для использования в конкретных ситуациях. Модуль torch.optim позволяет вам построить абстрактную схему оптимизации, просто передав список параметров. PyTorch предлагает множество оптимизаторов на выбор, то есть почти всегда есть тот, который лучше всего соответствует вашим потребностям.

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

  импортировать torch.optim как optimparams = torch.tensor ([1.0, 0.0], requires_grad = True) learning_rate = 1e-3 ## SGDoptimizer = optim.SGD ([  params], lr = learning_rate)  

После обновления модели используйте optimizer.step () , чтобы сообщить PyTorch о необходимости пересчета модели. Без использования оптимизаторам, нам нужно будет вручную обновлять параметры модели один за другим, используя цикл:

  для параметров в model.parameters (): params - = params.grad * learning_rate  

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

Графики вычислений с PyTorch

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

Другими словами, вход x используется для поиска y , который затем используется для поиска выходных данных z .

Представьте, что y и z вычисляются следующим образом:

y = x 2 y = x ^ 2 y = x 2

z = 2 y + 3 z = 2y + 3 z = 2y + 3

Однако нас интересует, как вывод z изменяется с вводом x , поэтому нам нужно выполнить некоторые вычисления:

dz d x = d z d y ∗ d y d x frac {dz} {dx} = frac {dz} {dy} * frac {dy} {dx} dx dz = dy dz ∗ dx dy

dz d x = 2 . 2 x frac {dz} {dx} = 2.2x dx dz = 2.2x

d z d x = 4 x frac {dz} { dx} = 4x ​​ dx dz = 4x

Используя это, мы видим, что input x = 3.5 сделает z = 14 .

Знание того, как определить каждый тензор в терминах других ( y и z в терминах x , z в терминах y и т. д.) позволяет PyTorch построить картину того, как эти тензоры связаны.

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

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

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

  import torch # установить простой график, связывающий x, y и zx = torch.tensor (3.5, requires_grad = True) y = x * xz = 2 * y + 3print  ("x:", x) print ("y = x * x:", y) print ("z = 2 * y + 3:", z) # отработка градиентов z.backward () print ("Разработка градиентов  dz/dx ") # что такое градиент при x = 3.5print (" Gradient at x = 3.5: ", x.grad)  

Это обнаруживает, что z = 14 точно так же, как мы нашли вручную выше!

Практическое занятие с PyTorch: граф вычислений с несколькими путями

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

Сначала определите два тензора, a и b , которые будут работать как наши входные данные. Обязательно установите requires_grad = True , чтобы мы могли создавать градиенты по строке.

  import torch # настраиваем простой график, относящийся к x, y  и za = torch.tensor (3.0, requires_grad = True) b = torch.tensor (2.0, requires_grad = True)  

Затем настройте отношения между нашим вводом и каждым слоем нашей нейронной сети, x , y и z . Обратите внимание, что z определяется в терминах x и y , а x и y определяются с использованием наших входных значений a и b .

  import torch # настроить простой график, связывающий x, y и za = torch.tensor (3.0, requires_grad = True) b = torch.tensor (2.0, requires_grad = True) x = 2 * a + 3 * by = 5  * a * a + 3 * b * b * bz = 2 * x + 3 * y  

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

Теперь мы можем разработать градиент d z d a frac {dz} {da} da dz, пройдя путь назад от z в a .

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

Мы бы получили тот же результат, если бы работали с d z d a frac {dz} {da} da dz с использованием цепного правила исчисления.

Первый путь через x дает нам 2 ∗ 2 2 * 2 2 ∗ 2 и второй путь через y дает нам 3 ∗ 1 0 a 3 * 10a семантика > 3 ∗ 10a. Итак, скорость, с которой z изменяется с a a a is 4 + 3 0 a 4 + 30a 4 + 30a.

Если a равно 22, то d z d а frac {dz} {da} da dz Равно 4 + 30 * 2 = 64.

Мы можем подтвердить это в PyTorch, добавив обратное распространение от z , а затем запросив градиент ( или производная) от a .

  import torch # установить простой график, связывающий x, y и za = torch.tensor (2.0, requires_grad  = True) b = torch.tensor (1.0, requires_grad = True) x = 2 * a + 3 * by = 5 * a * a + 3 * b * b * bz = 2 * x + 3 * yprint ("a:  ", a) print (" b: ", b) print (" x: ", x) print (" y: ", y) print (" z: ", z) # w  ork out gradientz.backward () print ("Разработка градиента dz/da") # что такое градиент при a = 2.0print ("Gradient at a = 2.0:", a.grad)  

Далее шаги для вашего обучения

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

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

• Сложный нейронные сети с оптимизацией
• Дизайн визуализации
• Обучение с использованием GAN

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

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

Удачного обучения!

Продолжить чтение о глубоком обучении и Python

• Простой анализ данных: руководство по Python Pandas
• Что такое глубокое обучение? Учебник для начинающих
• Учебник Scikit-learn: как реализовать линейную регрессию