PyTorch — Введение

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

Первоначально PyTorch был разработан Хью Перкинсом как оболочка Python для LusJIT, основанная на платформе Torch. Есть два варианта PyTorch.

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

Характеристики

Основные функции PyTorch упомянуты ниже —

Простой интерфейс — PyTorch предлагает простой в использовании API; следовательно, он считается очень простым в работе и работает на Python. Выполнение кода в этой среде довольно просто.

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

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

PyTorch известен тем, что имеет три уровня абстракции, как указано ниже —

Тензор — императивный n-мерный массив, работающий на GPU.
Переменная — узел в вычислительном графе. Это хранит данные и градиент.
Модуль — Уровень нейронной сети, в котором будут храниться данные о состоянии или изучаемых весах.

Тензор — императивный n-мерный массив, работающий на GPU.

Переменная — узел в вычислительном графе. Это хранит данные и градиент.

Модуль — Уровень нейронной сети, в котором будут храниться данные о состоянии или изучаемых весах.

Преимущества PyTorch

Ниже приведены преимущества PyTorch —

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

Код легко отлаживать и понимать.

Он включает в себя много слоев, как факел.

Включает в себя множество функций потери.

Это можно рассматривать как расширение NumPy для графических процессоров.

Это позволяет строить сети, структура которых зависит от самих вычислений.

TensorFlow vs. PyTorch

Мы рассмотрим основные различия между TensorFlow и PyTorch ниже —

PyTorch	TensorFlow
PyTorch тесно связан с основанным на lua фреймворком Torch, который активно используется в Facebook.	TensorFlow разработан Google Brain и активно используется в Google.
PyTorch является относительно новым по сравнению с другими конкурентными технологиями.	TensorFlow не является новым и рассматривается многими исследователями и профессионалами в качестве инструмента, необходимого для работы.
PyTorch включает в себя все в императивной и динамичной манере.	TensorFlow включает в себя статические и динамические графики в виде комбинации.
Граф вычислений в PyTorch определяется во время выполнения.	TensorFlow не включает опцию времени выполнения.
PyTorch включает в себя возможность развертывания для мобильных и встроенных платформ.	TensorFlow лучше работает для встроенных фреймворков.

PyTorch тесно связан с основанным на lua фреймворком Torch, который активно используется в Facebook.

TensorFlow разработан Google Brain и активно используется в Google.

PyTorch является относительно новым по сравнению с другими конкурентными технологиями.

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

PyTorch включает в себя все в императивной и динамичной манере.

TensorFlow включает в себя статические и динамические графики в виде комбинации.

Граф вычислений в PyTorch определяется во время выполнения.

TensorFlow не включает опцию времени выполнения.

PyTorch включает в себя возможность развертывания для мобильных и встроенных платформ.

TensorFlow лучше работает для встроенных фреймворков.

PyTorch — Установка

PyTorch является популярной средой глубокого обучения. В этом уроке мы рассматриваем «Windows 10» как нашу операционную систему. Шаги для успешной настройки среды следующие:

Шаг 1

Следующая ссылка содержит список пакетов, который включает в себя подходящие пакеты для PyTorch.

https://drive.google.com/drive/folders/0B-X0-FlSGfCYdTNldW02UGl4MXM

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

pytorch

Шаг 2

Он включает проверку установки платформы PyTorch с использованием Anaconda Framework.

Следующая команда используется для проверки того же —

conda list

«Conda list» показывает список установленных фреймворков.

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

Математические строительные блоки нейронных сетей

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

Важность тем математики для машинного обучения и науки о данных упомянута ниже —

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

векторы

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

Векторное представление отображается как указано ниже —

temp = torch.FloatTensor([23,24,24.5,26,27.2,23.0])
temp.size()
Output - torch.Size([6])

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

Скаляры

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

x = torch.rand(10)
x.size()
Output - torch.Size([10])

Матрицы

Большая часть структурированных данных обычно представляется в виде таблиц или конкретной матрицы. Мы будем использовать набор данных под названием Boston House Prices, который легко доступен в библиотеке машинного обучения scthonit-learn Python.

boston_tensor = torch.from_numpy(boston.data)
boston_tensor.size()
Output: torch.Size([506, 13])
boston_tensor[:2]
Output:
Columns 0 to 7
0.0063 18.0000 2.3100 0.0000 0.5380 6.5750 65.2000 4.0900
0.0273 0.0000 7.0700 0.0000 0.4690 6.4210 78.9000 4.9671
Columns 8 to 12
1.0000 296.0000 15.3000 396.9000 4.9800
2.0000 242.0000 17.8000 396.9000 9.1400

PyTorch — Основы нейронной сети

Основной принцип нейронной сети включает в себя набор базовых элементов, то есть искусственного нейрона или персептрона. Он включает в себя несколько основных входов, таких как x1, x2… .. xn, которые создают двоичный выход, если сумма больше, чем потенциал активации.

Схематическое изображение образца нейрона упоминается ниже —

Сгенерированный выход можно рассматривать как взвешенную сумму с потенциалом активации или смещением.

$Выход = \ sum_jw_jx_j + Bias$

Типичная архитектура нейронной сети описана ниже —

Слои между входом и выходом называются скрытыми слоями, а плотность и тип соединений между слоями — это конфигурация. Например, полностью подключенная конфигурация имеет все нейроны слоя L, связанные с нейронами L + 1. Для более выраженной локализации мы можем подключить только локальную окрестность, скажем, девять нейронов, к следующему слою. Рисунок 1-9 иллюстрирует два скрытых слоя с плотными связями.

Различные типы нейронных сетей следующие:

Нейронные сети с прямой связью

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

Рекуррентные нейронные сети

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

Нейронные сети могут быть построены с использованием пакета torch.nn.

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

С помощью PyTorch мы можем использовать следующие шаги для типичной процедуры обучения для нейронной сети —

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

rule: weight = weight -learning_rate * gradient

Универсальный рабочий процесс машинного обучения

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

Машинное обучение

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

Образец обучения под наблюдением
Необучаемая модель обучения

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

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

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

Процесс машинного обучения определяется с помощью следующих шагов —

Идентифицирует соответствующие наборы данных и подготавливает их для анализа.
Выбирает тип используемого алгоритма.
Создает аналитическую модель на основе используемого алгоритма.
Обучает модель на тестовых наборах данных, пересматривая ее по мере необходимости.
Запускает модель для генерации результатов тестов.

PyTorch — машинное обучение против глубокого обучения

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

Количество данных

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

Аппаратные зависимости

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

Характеристика

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

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

PyTorch — внедрение первой нейронной сети

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

Мы будем использовать следующие шаги для реализации первой нейронной сети с использованием PyTorch —

Шаг 1

Сначала нам нужно импортировать библиотеку PyTorch с помощью следующей команды:

import torch 
import torch.nn as nn

Шаг 2

Определите все слои и размер пакета, чтобы начать выполнение нейронной сети, как показано ниже —

# Defining input size, hidden layer size, output size and batch size respectively
n_in, n_h, n_out, batch_size = 10, 5, 1, 10

Шаг 3

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

# Create dummy input and target tensors (data)
x = torch.randn(batch_size, n_in)
y = torch.tensor([[1.0], [0.0], [0.0], 
[1.0], [1.0], [1.0], [0.0], [0.0], [1.0], [1.0]])

Шаг 4

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

# Create a model
model = nn.Sequential(nn.Linear(n_in, n_h),
   nn.ReLU(),
   nn.Linear(n_h, n_out),
   nn.Sigmoid())

Шаг 5

Построить функцию потерь с помощью оптимизатора Gradient Descent, как показано ниже —

Construct the loss function
criterion = torch.nn.MSELoss()
# Construct the optimizer (Stochastic Gradient Descent in this case)
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)

Шаг 6

Реализовать модель градиентного спуска с помощью итерационного цикла с заданными строками кода —

# Gradient Descent
for epoch in range(50):
   # Forward pass: Compute predicted y by passing x to the model
   y_pred = model(x)

   # Compute and print loss
   loss = criterion(y_pred, y)
   print('epoch: ', epoch,' loss: ', loss.item())

   # Zero gradients, perform a backward pass, and update the weights.
   optimizer.zero_grad()

   # perform a backward pass (backpropagation)
   loss.backward()

   # Update the parameters
   optimizer.step()

Шаг 7

Сгенерированный вывод выглядит следующим образом:

epoch: 0 loss: 0.2545787990093231
epoch: 1 loss: 0.2545052170753479
epoch: 2 loss: 0.254431813955307
epoch: 3 loss: 0.25435858964920044
epoch: 4 loss: 0.2542854845523834
epoch: 5 loss: 0.25421255826950073
epoch: 6 loss: 0.25413978099823
epoch: 7 loss: 0.25406715273857117
epoch: 8 loss: 0.2539947032928467
epoch: 9 loss: 0.25392240285873413
epoch: 10 loss: 0.25385022163391113
epoch: 11 loss: 0.25377824902534485
epoch: 12 loss: 0.2537063956260681
epoch: 13 loss: 0.2536346912384033
epoch: 14 loss: 0.25356316566467285
epoch: 15 loss: 0.25349172949790955
epoch: 16 loss: 0.25342053174972534
epoch: 17 loss: 0.2533493936061859
epoch: 18 loss: 0.2532784342765808
epoch: 19 loss: 0.25320762395858765
epoch: 20 loss: 0.2531369626522064
epoch: 21 loss: 0.25306645035743713
epoch: 22 loss: 0.252996027469635
epoch: 23 loss: 0.2529257833957672
epoch: 24 loss: 0.25285571813583374
epoch: 25 loss: 0.25278574228286743
epoch: 26 loss: 0.25271597504615784
epoch: 27 loss: 0.25264623761177063
epoch: 28 loss: 0.25257670879364014
epoch: 29 loss: 0.2525072991847992
epoch: 30 loss: 0.2524380087852478
epoch: 31 loss: 0.2523689270019531
epoch: 32 loss: 0.25229987502098083
epoch: 33 loss: 0.25223103165626526
epoch: 34 loss: 0.25216227769851685
epoch: 35 loss: 0.252093642950058
epoch: 36 loss: 0.25202515721321106
epoch: 37 loss: 0.2519568204879761
epoch: 38 loss: 0.251888632774353
epoch: 39 loss: 0.25182053446769714
epoch: 40 loss: 0.2517525553703308
epoch: 41 loss: 0.2516847252845764
epoch: 42 loss: 0.2516169846057892
epoch: 43 loss: 0.2515493929386139
epoch: 44 loss: 0.25148195028305054
epoch: 45 loss: 0.25141456723213196
epoch: 46 loss: 0.2513473629951477
epoch: 47 loss: 0.2512802183628082
epoch: 48 loss: 0.2512132525444031
epoch: 49 loss: 0.2511464059352875

PyTorch — Нейронные сети к функциональным блокам

Обучение алгоритму глубокого обучения включает в себя следующие шаги —

Построение конвейера данных
Построение сетевой архитектуры
Оценка архитектуры с использованием функции потерь
Оптимизация весов сетевой архитектуры с использованием алгоритма оптимизации

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

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

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

PyTorch — Терминологии

В этой главе мы обсудим некоторые наиболее часто используемые термины в PyTorch.

PyTorch NumPy

Тензор PyTorch идентичен массиву NumPy. Тензор — это n-мерный массив, и по отношению к PyTorch он предоставляет множество функций для работы с этими тензорами.

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

Переменные и автоград

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

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

Динамические Графики

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

Основное различие между ними заключается в том, что вычислительные графы Tensor Flow являются статическими, а PyTorch использует динамические вычислительные графы.

Оптим Пакет

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

многопроцессорная обработка

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

PyTorch — загрузка данных

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

Dataset

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

trainset = torchvision.datasets.CIFAR10(root = './data', train = True,
   download = True, transform = transform)

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

trainloader = torch.utils.data.DataLoader(trainset, batch_size = 4,
   shuffle = True, num_workers = 2)

Пример: загрузка файла CSV

Мы используем пакет Panda Python для загрузки файла CSV. Исходный файл имеет следующий формат: (имя изображения, 68 ориентиров — каждый ориентир имеет координаты топора и y).

landmarks_frame = pd.read_csv('faces/face_landmarks.csv')

n = 65
img_name = landmarks_frame.iloc[n, 0]
landmarks = landmarks_frame.iloc[n, 1:].as_matrix()
landmarks = landmarks.astype('float').reshape(-1, 2)

PyTorch — линейная регрессия

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

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

Y = Ax+b

Далее мы разработаем алгоритм линейной регрессии, который позволит нам понять две важные концепции, приведенные ниже:

Функция стоимости
Алгоритмы градиентного спуска

Схематическое представление линейной регрессии упоминается ниже

Интерпретация результата

$Y = ах + Ь$

Значение а является наклоном.
Значение b — это y — пересечение .
r — коэффициент корреляции .
r ² — коэффициент корреляции .

Значение а является наклоном.

Значение b — это y — пересечение .

r — коэффициент корреляции .

r ² — коэффициент корреляции .

Графическое представление уравнения линейной регрессии упоминается ниже —

Следующие шаги используются для реализации линейной регрессии с использованием PyTorch —

Шаг 1

Импортируйте необходимые пакеты для создания линейной регрессии в PyTorch, используя следующий код —

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
import seaborn as sns
import pandas as pd
%matplotlib inline

sns.set_style(style = 'whitegrid')
plt.rcParams["patch.force_edgecolor"] = True

Шаг 2

Создайте единый тренировочный набор с доступным набором данных, как показано ниже —

m = 2 # slope
c = 3 # interceptm = 2 # slope
c = 3 # intercept
x = np.random.rand(256)

noise = np.random.randn(256) / 4

y = x * m + c + noise

df = pd.DataFrame()
df['x'] = x
df['y'] = y

sns.lmplot(x ='x', y ='y', data = df)

Шаг 3

Реализуйте линейную регрессию с библиотеками PyTorch, как упомянуто ниже —

import torch
import torch.nn as nn
from torch.autograd import Variable
x_train = x.reshape(-1, 1).astype('float32')
y_train = y.reshape(-1, 1).astype('float32')

class LinearRegressionModel(nn.Module):
   def __init__(self, input_dim, output_dim):
      super(LinearRegressionModel, self).__init__()
      self.linear = nn.Linear(input_dim, output_dim)

   def forward(self, x):
      out = self.linear(x)
      return out
input_dim = x_train.shape[1]
output_dim = y_train.shape[1]
input_dim, output_dim(1, 1)
model = LinearRegressionModel(input_dim, output_dim)
criterion = nn.MSELoss()
[w, b] = model.parameters()

def get_param_values():
   return w.data[0][0], b.data[0]

def plot_current_fit(title = ""):
plt.figure(figsize = (12,4))
plt.title(title)
plt.scatter(x, y, s = 8)
w1 = w.data[0][0]
b1 = b.data[0]
x1 = np.array([0., 1.])
y1 = x1 * w1 + b1
plt.plot(x1, y1, 'r', label = 'Current Fit ({:.3f}, {:.3f})'.format(w1, b1))
plt.xlabel('x (input)')
plt.ylabel('y (target)')
plt.legend()
plt.show()
plot_current_fit('Before training')

Сюжет генерируется следующим образом —

PyTorch — сверточная нейронная сеть

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

Два важных типа глубоких нейронных сетей приведены ниже —

Сверточные нейронные сети
Рекуррентные нейронные сети.

В этой главе мы сосредоточимся на первом типе, то есть на сверточных нейронных сетях (CNN).

Сверточные нейронные сети

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

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

Доминирующий подход CNN включает решение проблем распознавания. Ведущие компании, такие как Google и Facebook, инвестировали в исследовательские и опытно-конструкторские проекты проектов по распознаванию, чтобы выполнять действия быстрее.

Каждая сверточная нейронная сеть включает в себя три основные идеи —

Местные соответствующие поля
свертка
объединение

Давайте разберемся с каждой из этих терминов в деталях.

Местные соответствующие поля

CNN использует пространственные корреляции, которые существуют во входных данных. Каждый в параллельных слоях нейронных сетей соединяет несколько входных нейронов. Этот конкретный регион называется Местное поле восприятия. Он фокусируется только на скрытых нейронах. Скрытый нейрон будет обрабатывать входные данные внутри упомянутого поля, не осознавая изменений за пределами определенной границы.

Представление диаграммы генерации локальных соответствующих полей упоминается ниже —

свертка

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

Отображение соединений от входного слоя к карте скрытых объектов определяется как «общие веса», а включенное смещение называется «общим смещением».

объединение

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

Реализация PyTorch

Следующие шаги используются для создания сверточной нейронной сети с использованием PyTorch.

Шаг 1

Импортируйте необходимые пакеты для создания простой нейронной сети.

from torch.autograd import Variable
import torch.nn.functional as F

Шаг 2

Создайте класс с пакетным представлением сверточной нейронной сети. Наша форма пакета для ввода x имеет размерность (3, 32, 32).

class SimpleCNN(torch.nn.Module):
   def __init__(self):
      super(SimpleCNN, self).__init__()
      #Input channels = 3, output channels = 18
      self.conv1 = torch.nn.Conv2d(3, 18, kernel_size = 3, stride = 1, padding = 1)
      self.pool = torch.nn.MaxPool2d(kernel_size = 2, stride = 2, padding = 0)
      #4608 input features, 64 output features (see sizing flow below)
      self.fc1 = torch.nn.Linear(18 * 16 * 16, 64)
      #64 input features, 10 output features for our 10 defined classes
      self.fc2 = torch.nn.Linear(64, 10)

Шаг 3

Вычислить активацию первого изменения размера свертки от (3, 32, 32) до (18, 32, 32).

Размер измерения изменяется от (18, 32, 32) до (18, 16, 16). Изменение размера данных входного слоя нейронной сети, из-за которого размер изменяется с (18, 16, 16) на (1, 4608).

Напомним, что -1 выводит это измерение из другого данного измерения.

def forward(self, x):
   x = F.relu(self.conv1(x))
   x = self.pool(x)
   x = x.view(-1, 18 * 16 *16)
   x = F.relu(self.fc1(x))
   #Computes the second fully connected layer (activation applied later)
   #Size changes from (1, 64) to (1, 10)
   x = self.fc2(x)
   return(x)

PyTorch — рекуррентная нейронная сеть

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

Диаграмма ниже определяет полный подход и работу рекуррентных нейронных сетей —

На приведенном выше рисунке c1, c2, c3 и x1 рассматриваются как входные данные, которые включают в себя некоторые скрытые входные значения, а именно h1, h2 и h3, обеспечивающие соответствующий выходной сигнал o1. Теперь мы сосредоточимся на реализации PyTorch для создания синусоиды с помощью рекуррентных нейронных сетей.

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

Шаг 1

Импортируйте необходимые пакеты для реализации рекуррентных нейронных сетей, используя следующий код —

import torch
from torch.autograd import Variable
import numpy as np
import pylab as pl
import torch.nn.init as init

Шаг 2

Мы установим гиперпараметры модели с размером входного слоя 7. Для создания целевой последовательности будет 6 контекстных нейронов и 1 входной нейрон.

dtype = torch.FloatTensor
input_size, hidden_size, output_size = 7, 6, 1
epochs = 300
seq_length = 20
lr = 0.1
data_time_steps = np.linspace(2, 10, seq_length + 1)
data = np.sin(data_time_steps)
data.resize((seq_length + 1, 1))

x = Variable(torch.Tensor(data[:-1]).type(dtype), requires_grad=False)
y = Variable(torch.Tensor(data[1:]).type(dtype), requires_grad=False)

Мы сгенерируем обучающие данные, где x — последовательность входных данных, а y — требуемая последовательность.

Шаг 3

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

w1 = torch.FloatTensor(input_size, 
hidden_size).type(dtype)
init.normal(w1, 0.0, 0.4)
w1 = Variable(w1, requires_grad = True)
w2 = torch.FloatTensor(hidden_size, output_size).type(dtype)
init.normal(w2, 0.0, 0.3)
w2 = Variable(w2, requires_grad = True)

Шаг 4

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

def forward(input, context_state, w1, w2):
   xh = torch.cat((input, context_state), 1)
   context_state = torch.tanh(xh.mm(w1))
   out = context_state.mm(w2)
   return (out, context_state)

Шаг 5

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

for i in range(epochs):
   total_loss = 0
   context_state = Variable(torch.zeros((1, hidden_size)).type(dtype), requires_grad = True)
   for j in range(x.size(0)):
      input = x[j🙁j+1)]
      target = y[j🙁j+1)]
      (pred, context_state) = forward(input, context_state, w1, w2)
      loss = (pred - target).pow(2).sum()/2
      total_loss += loss
      loss.backward()
      w1.data -= lr * w1.grad.data
      w2.data -= lr * w2.grad.data
      w1.grad.data.zero_()
      w2.grad.data.zero_()
      context_state = Variable(context_state.data)
   if i % 10 == 0:
      print("Epoch: {} loss {}".format(i, total_loss.data[0]))

context_state = Variable(torch.zeros((1, hidden_size)).type(dtype), requires_grad = False)
predictions = []

for i in range(x.size(0)):
   input = x[i:i+1]
   (pred, context_state) = forward(input, context_state, w1, w2)
   context_state = context_state
   predictions.append(pred.data.numpy().ravel()[0])

Шаг 6

Теперь пришло время построить синусоидальную волну так, как она нужна.

pl.scatter(data_time_steps[:-1], x.data.numpy(), s = 90, label = "Actual")
pl.scatter(data_time_steps[1:], predictions, label = "Predicted")
pl.legend()
pl.show()

Выход

Выход для вышеуказанного процесса выглядит следующим образом:

PyTorch — наборы данных

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

MNIST
COCO (субтитры и обнаружение)

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

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

Transform — функция, которая берет изображение и возвращает модифицированную версию стандартного материала. Они могут быть составлены вместе с преобразованиями.

Target_transform — функция, которая берет цель и трансформирует ее. Например, принимает строку заголовка и возвращает тензор мировых индексов.

MNIST

Ниже приведен пример кода для набора данных MNIST:

dset.MNIST(root, train = TRUE, transform = NONE, 
target_transform = None, download = FALSE)

Параметры следующие:

root — корневой каталог набора данных, в котором существуют обработанные данные.
train — True = обучающий набор, False = тестовый набор
download — True = загружает набор данных из Интернета и помещает его в корневой каталог.

root — корневой каталог набора данных, в котором существуют обработанные данные.

train — True = обучающий набор, False = тестовый набор

download — True = загружает набор данных из Интернета и помещает его в корневой каталог.

COCO

Это требует установки COCO API. Следующий пример используется для демонстрации реализации набора данных COCO с использованием PyTorch —

import torchvision.dataset as dset
import torchvision.transforms as transforms
cap = dset.CocoCaptions(root = ‘ dir where images are’, 
annFile = ’json annotation file’,
transform = transforms.ToTensor())
print(‘Number of samples: ‘, len(cap))
print(target)

Достигнутый результат следующий:

Number of samples: 82783
Image Size: (3L, 427L, 640L)

PyTorch — Введение в Конвенты

Convents — это все о создании модели CNN с нуля. Архитектура сети будет содержать комбинацию следующих шагов —

Conv2d
MaxPool2d
Выпрямленная линейная единица
Посмотреть
Линейный слой

Обучение модели

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

def fit(epoch,model,data_loader,phase 
= 'training',volatile = False):
   if phase == 'training':
      model.train()
   if phase == 'training':
      model.train()
   if phase == 'validation':
      model.eval()
   volatile=True
   running_loss = 0.0
   running_correct = 0
   for batch_idx , (data,target) in enumerate(data_loader):
      if is_cuda:
         data,target = data.cuda(),target.cuda()
         data , target = Variable(data,volatile),Variable(target)
      if phase == 'training':
         optimizer.zero_grad()
         output = model(data)
         loss = F.nll_loss(output,target)
         running_loss + = 
         F.nll_loss(output,target,size_average = 
         False).data[0]
         preds = output.data.max(dim = 1,keepdim = True)[1]
         running_correct + = 
         preds.eq(target.data.view_as(preds)).cpu().sum()
         if phase == 'training':
            loss.backward()
            optimizer.step()
   loss = running_loss/len(data_loader.dataset)
   accuracy = 100. * running_correct/len(data_loader.dataset)
   print(f'{phase} loss is {loss:{5}.{2}} and {phase} accuracy is {running_correct}/{len(data_loader.dataset)}{accuracy:{return loss,accuracy}})

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

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

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

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

PyTorch — обучение монастыря с нуля

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

Шаг 1

Создайте необходимый класс с соответствующими параметрами. Параметры включают веса со случайным значением.

class Neural_Network(nn.Module):
   def __init__(self, ):
      super(Neural_Network, self).__init__()
      self.inputSize = 2
      self.outputSize = 1
      self.hiddenSize = 3
      # weights
      self.W1 = torch.randn(self.inputSize, 
      self.hiddenSize) # 3 X 2 tensor
      self.W2 = torch.randn(self.hiddenSize, self.outputSize) # 3 X 1 tensor

Шаг 2

Создайте шаблон функции прямой связи с сигмовидными функциями.

def forward(self, X):
   self.z = torch.matmul(X, self.W1) # 3 X 3 ".dot" 
   does not broadcast in PyTorch
   self.z2 = self.sigmoid(self.z) # activation function
   self.z3 = torch.matmul(self.z2, self.W2)
   o = self.sigmoid(self.z3) # final activation 
   function
   return o
   def sigmoid(self, s):
      return 1 / (1 + torch.exp(-s))
   def sigmoidPrime(self, s):
      # derivative of sigmoid
      return s * (1 - s)
   def backward(self, X, y, o):
      self.o_error = y - o # error in output
      self.o_delta = self.o_error * self.sigmoidPrime(o) # derivative of sig to error
      self.z2_error = torch.matmul(self.o_delta, torch.t(self.W2))
      self.z2_delta = self.z2_error * self.sigmoidPrime(self.z2)
      self.W1 + = torch.matmul(torch.t(X), self.z2_delta)
      self.W2 + = torch.matmul(torch.t(self.z2), self.o_delta)

Шаг 3

Создайте модель обучения и прогнозирования, как указано ниже —

def train(self, X, y):
   # forward + backward pass for training
   o = self.forward(X)
   self.backward(X, y, o)
def saveWeights(self, model):
   # Implement PyTorch internal storage functions
   torch.save(model, "NN")
   # you can reload model with all the weights and so forth with:
   # torch.load("NN")
def predict(self):
   print ("Predicted data based on trained weights: ")
   print ("Input (scaled): \n" + str(xPredicted))
   print ("Output: \n" + str(self.forward(xPredicted)))

PyTorch — функция извлечения в конвентах

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

Шаг 1

Импортируйте соответствующие модели, чтобы создать модель извлечения объектов с помощью «PyTorch».

import torch
import torch.nn as nn
from torchvision import models

Шаг 2

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

class Feature_extractor(nn.module):
   def forward(self, input):
      self.feature = input.clone()
      return input
new_net = nn.Sequential().cuda() # the new network
target_layers = [conv_1, conv_2, conv_4] # layers you want to extract`
i = 1
for layer in list(cnn):
   if isinstance(layer,nn.Conv2d):
      name = "conv_"+str(i)
      art_net.add_module(name,layer)
      if name in target_layers:
         new_net.add_module("extractor_"+str(i),Feature_extractor())
      i+=1
   if isinstance(layer,nn.ReLU):
      name = "relu_"+str(i)
      new_net.add_module(name,layer)
   if isinstance(layer,nn.MaxPool2d):
      name = "pool_"+str(i)
      new_net.add_module(name,layer)
new_net.forward(your_image)
print (new_net.extractor_3.feature)

PyTorch — Визуализация конвенций

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

Шаг 1

Импортируйте необходимые модули, что важно для визуализации обычных нейронных сетей.

import os
import numpy as np
import pandas as pd
from scipy.misc import imread
from sklearn.metrics import accuracy_score

import keras
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Flatten, Activation, Input
from keras.layers import Conv2D, MaxPooling2D
import torch

Шаг 2

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

seed = 128
rng = np.random.RandomState(seed)
data_dir = "../../datasets/MNIST"
train = pd.read_csv('../../datasets/MNIST/train.csv')
test = pd.read_csv('../../datasets/MNIST/Test_fCbTej3.csv')
img_name = rng.choice(train.filename)
filepath = os.path.join(data_dir, 'train', img_name)
img = imread(filepath, flatten=True)

Шаг 3

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

pylab.imshow(img, cmap ='gray')
pylab.axis('off')
pylab.show()

Вывод отображается как ниже —

PyTorch — обработка последовательности с помощью конвентов

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

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

Следующие шаги используются для создания модели обработки последовательности с конвенциями с использованием PyTorch —

Шаг 1

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

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout, Flatten 
from keras.layers import Conv2D, MaxPooling2D 
import numpy as np

Шаг 2

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

batch_size = 128 
num_classes = 10 
epochs = 12
# input image dimensions 
img_rows, img_cols = 28, 28
# the data, split between train and test sets 
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000,28,28,1) 
x_test = x_test.reshape(10000,28,28,1)
print('x_train shape:', x_train.shape) 
print(x_train.shape[0], 'train samples') 
print(x_test.shape[0], 'test samples')
y_train = keras.utils.to_categorical(y_train, num_classes) 
y_test = keras.utils.to_categorical(y_test, num_classes)

Шаг 3

Скомпилируйте модель и поместите шаблон в упомянутую традиционную модель нейронной сети, как показано ниже —

model.compile(loss = 
keras.losses.categorical_crossentropy, 
optimizer = keras.optimizers.Adadelta(), metrics = 
['accuracy'])
model.fit(x_train, y_train, 
batch_size = batch_size, epochs = epochs, 
verbose = 1, validation_data = (x_test, y_test)) 
score = model.evaluate(x_test, y_test, verbose = 0) 
print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

Сгенерированный вывод выглядит следующим образом:

PyTorch — вложение слов

В этой главе мы разберемся с известной моделью встраивания слов — word2vec. Модель Word2vec используется для встраивания слов с помощью группы связанных моделей. Модель Word2vec реализована с использованием чистого C-кода, а градиент вычисляется вручную.

Реализация модели word2vec в PyTorch объясняется в следующих шагах:

Шаг 1

Реализовать библиотеки для встраивания слов, как указано ниже —

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F

Шаг 2

Реализуйте модель встраивания слов Пропустить Грамма с классом word2vec. Включает атрибуты типа emb_size, emb_dimension, u_embedding, v_embedding .

class SkipGramModel(nn.Module):
   def __init__(self, emb_size, emb_dimension):
      super(SkipGramModel, self).__init__()
      self.emb_size = emb_size
      self.emb_dimension = emb_dimension
      self.u_embeddings = nn.Embedding(emb_size, emb_dimension, sparse=True)
      self.v_embeddings = nn.Embedding(emb_size, emb_dimension, sparse = True)
      self.init_emb()
   def init_emb(self):
      initrange = 0.5 / self.emb_dimension
      self.u_embeddings.weight.data.uniform_(-initrange, initrange)
      self.v_embeddings.weight.data.uniform_(-0, 0)
   def forward(self, pos_u, pos_v, neg_v):
      emb_u = self.u_embeddings(pos_u)
      emb_v = self.v_embeddings(pos_v)
      score = torch.mul(emb_u, emb_v).squeeze()
      score = torch.sum(score, dim = 1)
      score = F.logsigmoid(score)
      neg_emb_v = self.v_embeddings(neg_v)
      neg_score = torch.bmm(neg_emb_v, emb_u.unsqueeze(2)).squeeze()
      neg_score = F.logsigmoid(-1 * neg_score)
      return -1 * (torch.sum(score)+torch.sum(neg_score))
   def save_embedding(self, id2word, file_name, use_cuda):
      if use_cuda:
         embedding = self.u_embeddings.weight.cpu().data.numpy()
      else:
         embedding = self.u_embeddings.weight.data.numpy()
      fout = open(file_name, 'w')
      fout.write('%d %d\n' % (len(id2word), self.emb_dimension))
      for wid, w in id2word.items():
         e = embedding[wid]
         e = ' '.join(map(lambda x: str(x), e))
         fout.write('%s %s\n' % (w, e))
def test():
   model = SkipGramModel(100, 100)
   id2word = dict()
   for i in range(100):
      id2word[i] = str(i)
   model.save_embedding(id2word)

Шаг 3

Реализуйте метод main, чтобы правильно отобразить модель встраивания слов.

if __name__  ==  '__main__':
   test()

PyTorch — Рекурсивные нейронные сети

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

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

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

Особенности рекурсивной нейронной сети

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

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

Узлы пройдены в топологическом порядке.

Этот тип сети обучается в режиме обратного автоматического дифференцирования.

Обработка естественного языка включает в себя особый случай рекурсивных нейронных сетей.

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

Пример рекурсивной нейронной сети показан ниже —

PyTorch — Краткое руководство

PyTorch — Введение

Характеристики

Преимущества PyTorch

TensorFlow vs. PyTorch

PyTorch — Установка

Шаг 1

Шаг 2

Математические строительные блоки нейронных сетей

векторы

Скаляры

Матрицы

PyTorch — Основы нейронной сети

Нейронные сети с прямой связью

Рекуррентные нейронные сети

Универсальный рабочий процесс машинного обучения

Машинное обучение

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

PyTorch — машинное обучение против глубокого обучения

Количество данных

Аппаратные зависимости

Характеристика

PyTorch — внедрение первой нейронной сети

Шаг 1

Шаг 2

Шаг 3

Шаг 4

Шаг 5

Шаг 6

Шаг 7

PyTorch — Нейронные сети к функциональным блокам

PyTorch — Терминологии

PyTorch NumPy

Переменные и автоград

Динамические Графики

Оптим Пакет

многопроцессорная обработка

PyTorch — загрузка данных

Dataset

Пример: загрузка файла CSV

PyTorch — линейная регрессия

Интерпретация результата

Шаг 1

Шаг 2

Шаг 3

PyTorch — сверточная нейронная сеть

Сверточные нейронные сети

Местные соответствующие поля

свертка

объединение

Реализация PyTorch

Шаг 1

Шаг 2

Шаг 3

PyTorch — рекуррентная нейронная сеть

Шаг 1

Шаг 2

Шаг 3

Шаг 4

Шаг 5

Шаг 6

Выход

PyTorch — наборы данных

MNIST

COCO

PyTorch — Введение в Конвенты

Обучение модели

PyTorch — обучение монастыря с нуля

Шаг 1

Шаг 2

Шаг 3

PyTorch — функция извлечения в конвентах

Шаг 1

Шаг 2

PyTorch — Визуализация конвенций

Шаг 1

Шаг 2

Шаг 3

PyTorch — обработка последовательности с помощью конвентов

Шаг 1