Рубрики
Без рубрики

Учебное пособие Pytorch: быстрое руководство для новых учеников

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

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

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

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

Вот что мы рассмотрим сегодня:

  • Что такое Pytorch?
  • Зачем использовать Pytorch?
  • Основы Pytorch
  • Графики вычислений с Pytorch
  • Практическое с помощью Pytorch: график вычислений с несколькими путями
  • Следующие шаги для вашего обучения

Начните строить проекты Pytorch в половину от времени

Научитесь строить и оптимизировать нейронные сети Pytorch с практической практикой.

Сделайте свой первый Gan с помощью Pytorch

Что такое Pytorch?

Pytorch-это библиотека Python с открытым исходным кодом, используемая для реализаций глубокого обучения, таких как компьютерное зрение (с использованием TOCHVISION и обработка естественного языка Анкет Он был разработан в исследовательской лаборатории ИИ в Facebook (FAIR) в 2016 году и с тех пор был принят в области науки о данных и ML.

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

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

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

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

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

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

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

Pytorch vs. Tensorflow

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

  • Популярность : Tensorflow-текущий инструмент для профессионалов отрасли и исследователей, потому что он был выпущен на 1 год раньше, чем Pytorch. Тем не менее, пользователи Pytorch растут быстрее, чем Tensorflow, что позволяет предположить, что Pytorch может быть самым популярным.

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

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

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

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

Основы Pytorch

Тензоры

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

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

Тензоры входят в 5 типов:

  • Floattensor : 32-битный поплавок
  • Doubletensor : 64-битный поплавок
  • Halftensor : 16-битный поплавок
  • Inttensor : 32-битный инт
  • Лонгтенсор : 64-битный инт

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

torch.set_default_tensor_type(t)

Инициализировать два Floattensors :

import torch
# initializing tensors
a = torch.tensor(2)
b = torch.tensor(1)

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

# addition
print(a+b)
# subtraction
print(b-a)
# multiplication
print(a*b)
# division
print(a/b)

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

if torch.cuda.is_available():
    x = x.cuda()
    y = y.cuda()
    x + y

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

ones_tensor = torch.ones((2, 2)) # tensor containing all ones
rand_tensor = torch.rand((2, 2)) # tensor containing random values

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

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

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

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

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

Pytorch определяет нейронные сети, используя Torch.nn Пакет, который содержит набор модулей для представления каждого уровня сети.

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

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

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

import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 3x3 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.conv2 = nn.Conv2d(6, 16, 3)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        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:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features
net = Net()
print(net)

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

Далее мы определяем прямой метод, чтобы описать, как сделать прямое распространение. Нам не нужно определять метод обратного распространения, потому что Pytorch включает в себя назад () Функция по умолчанию.

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

Автограда

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

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

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

import torch
# pytorch tensor
x = torch.tensor(3.5, requires_grad=True)
# y is defined as a function of x
y = (x-1) * (x-2) * (x-3)
# work out gradients
y.backward()

По умолчанию, Требуется_града установлен на ЛОЖЬ и Pytorch не будет отслеживать градиенты. Указание Требуется_града как Истинный Во время инициализации будут создавать градиенты трассы Pytorch для этого конкретного тензора всякий раз, когда мы выполняем некоторую операцию на нем.

Этот код смотрит на y и видит, что это произошло от (X-1) * (x-2) * (X-3) и автоматически разрабатывает градиент dy/dx, 3x^2 - 12x + 11

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

Все вместе, градиент 3 * (3,5 * 3,5) - 12 * (3,5) +.75 Анкет

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

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

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

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

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

import torch.optim as optim
params = torch.tensor([1.0, 0.0], requires_grad=True)
learning_rate = 1e-3
## SGD
optimizer = optim.SGD([params], lr=learning_rate)

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

    for params in model.parameters(): 
       params -= params.grad * learning_rate

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

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

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

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

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

y^2

Z + 3

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

dz/dx = (dz/dy) * (dy/dx)

DZ/DX.2X

DZ/DX

Используя это, мы видим этот вход x = 3,5 сделает z Анкет

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

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

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

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

import torch
# set up simple graph relating x, y and z
x = torch.tensor(3.5, requires_grad=True)
y = x*x
z = 2*y + 3
print("x: ", x)
print("y = x*x: ", y)
print("z= 2*y + 3: ", z)
# work out gradients
z.backward()
print("Working out gradients dz/dx")
# what is gradient at x = 3.5
print("Gradient at x = 3.5: ", x.grad)

Это находит это z так же, как мы нашли вручную выше!

Продолжайте изучать Pytorch.

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

Сделайте свой первый Gan с помощью Pytorch

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

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

Во -первых, определить два тензора, A и беременный , чтобы функционировать как наши входные данные. Обязательно установите TERSH_GRAD = Истинный Таким образом, мы можем сделать градиенты вниз по линии.

import torch
# set up simple graph relating x, y and z
a = torch.tensor(3.0, requires_grad=True)
b = torch.tensor(2.0, requires_grad=True)

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

import torch
# set up simple graph relating x, y and z
a = torch.tensor(3.0, requires_grad=True)
b = torch.tensor(2.0, requires_grad=True)

x = 2*a + 3*b
y = 5*a*a + 3*b*b*b
z = 2*x + 3*y

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

Теперь мы можем выработать градиент dz/da Следуя по пути обратно с z к A Анкет

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

Мы бы нашли тот же результат, если бы мы выработали dz/da Используя правило цепи исчисления.

Первый путь через x дает нам 2 * 2 и второй путь через y дает нам 3 * 10a Анкет Итак, скорость, с которой z Изменения с A это 4 + 30A Анкет

Если A 22, тогда dz/da Это 4+30 ∗ 2 = 64 Анкет

Мы можем подтвердить это в Pytorch, добавив обратное распространение из z Затем спрашивая градиент (или производную) A Анкет

import torch
# set up simple graph relating x, y and z
a = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(1.0, requires_grad=True)
x = 2*a + 3*b
y = 5*a*a + 3*b*b*b
z = 2*x + 3*y
print("a: ", a)
print("b: ", b)
print("x: ", x)
print("y: ", y)
print("z: ", z)
# work out gradients
z.backward()
print("Working out gradient dz/da")
# what is gradient at a = 2.0
print("Gradient at a=2.0:", a.grad)

Следующие шаги для вашего обучения

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

Когда вы изучаете продвинутые навыки глубокого обучения и приложения, вы захотите изучить:

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

Чтобы помочь вам почувствовать себя комфортно с реальными проектами глубокого обучения, образовательное образование сделало Сделайте свой первый Gan с помощью Pytorch Анкет Этот курс дает вам крах, создавая нейронные сети с помощью Pytorch и учит вас повысить их точность с помощью Gans.

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

Счастливого обучения!

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

Оригинал: “https://dev.to/educative/pytorch-tutorial-a-quick-guide-for-new-learners-a10”

Читайте ещё по теме: