Практическое обучение | Библиотека глубокого обучения PyTorch (с кодом)

Оригинальное название:

Введение в PyTorch — простая, но мощная библиотека для глубокого обучения

Автор: ФАЙЗАН ШЕЙХ

Перевод: и китайский

Эта статья о3600 слов, рекомендуется к прочтению15 минут. Эта статья поможет вам шаг за шагом начать работу с PyTorch с помощью примеров.

  

вводить

Время от времени рождается библиотека Python, которая может изменить ландшафт глубокого обучения, и PyTorch — одна из них.

 

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

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

 

Давайте начнем!

 

Примечание. В этой статье предполагается, что у вас есть базовые знания о глубоком обучении. Если вам нужно быстрое понимание, сначала прочитайте эту статью https://www.analyticsvidhya.com/blog/2016/03/introduction-deep-learning-fundamentals-neural-networks/

 

содержание

• Обзор PyTorch

• глубокие технологии

• Numpy VS PyTorch для построения нейронных сетей

• Сравнение с другими библиотеками глубокого обучения

• Практический пример --- Решение проблем распознавания изображений с помощью PyTorch

 

Обзор PyTorch

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

 

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

Рабочий процесс PyTorch максимально приближен к библиотеке научных вычислений Python, numpy.

 

Вы можете спросить, почему мы используем PyTorch для создания моделей глубокого обучения? Я перечисляю три пункта, чтобы ответить на этот вопрос:

 

• Простой в использовании API:Простой и удобный в использовании, как Python;

• Питон поддерживается:Как упоминалось выше, PyTorch легко интегрируется со стеком обработки данных Python. Он настолько похож на Numpy, что вы даже не заметите разницы;

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

 

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

 

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

 

глубокие технологии

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

 

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

 

Источник: http://pytorch.org/about/

 

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

 

conda install pytorch torchvision cuda91 -cpytorch

 

Основные элементы, которые следует понимать, когда мы начинаем работу с PyTorch:

 

• Тензоры PyTorch (тензоры)

• вычисление

• Модуль Автоград

• Оптимальный модуль

• модуль nn

 

Ниже мы подробно опишем каждую часть.

 

1. Тензор PyTorch

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

 

Вы можете определить простую одномерную матрицу следующим образом:

 

# import pytorch

import torch

# define a tensor

torch.FloatTensor([2])

 

2

[torch.FloatTensor of size 1]

 

2. Математические операции

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

 

Ниже приведен пример простой операции сложения:

 

a = torch.FloatTensor([2])

b = torch.FloatTensor([3])

a + b

5

[torch.FloatTensor of size 1]

 

Разве это не похоже на типичный подход Python? Мы также можем выполнять различные матричные операции с определенными тензорами PyTorch. Например, мы транспонируем 2D-матрицу:

 

matrix = torch.randn(3, 3)

matrix

-1.3531 -0.5394  0.8934

 1.7457 -0.6291 -0.0484

-1.3502 -0.6439 -1.5652

[torch.FloatTensor of size 3x3]

matrix.t()

-1.3531  1.7457  -1.3502

-0.5394 -0.6291  -0.6439

 0.8934  -0.0484  -1.5652

[torch.FloatTensor of size 3x3]

 

3. Модуль Автоград

 

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

 

Источник: http://pytorch.org/about/

 

from torch.autograd import Variable

x = Variable(train_x)

y = Variable(train_y, requires_grad=False)

 

4. Оптимальный модуль

Torch.optim — модуль, реализующий различные алгоритмы оптимизации для построения нейронных сетей. Большинство распространенных методов уже поддерживаются, поэтому нам не нужно создавать их с нуля (если только вы этого не хотите!).

 

Вот фрагмент кода, который использует оптимизатор Adam:

 

optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

5. нн модуль

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

 

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

 

Вы можете думать о модуле nn как о ядрах PyTorch!

 

import torch

# define model

model = torch.nn.Sequential(

 torch.nn.Linear(input_num_units, hidden_num_units),

 torch.nn.ReLU(),

 torch.nn.Linear(hidden_num_units, output_num_units),

)

loss_fn = torch.nn.CrossEntropyLoss()

 

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

 

Numpy VS PyTorch для построения нейронных сетей

Ранее я упоминал, что PyTorch и Numpy очень похожи, давайте посмотрим, почему. В этом разделе мы увидим, как можно реализовать простую нейронную сеть для задач бинарной классификации. Вы можете получить подробное объяснение по адресу https://www.analyticsvidhya.com/blog/2017/05/neural-network-from-scratch-in-python-and-r/.

 

## Neural network in numpy

import numpy as np

#Input array

X=np.array([[1,0,1,0],[1,0,1,1],[0,1,0,1]])

#Output

y=np.array([[1],[1],[0]])

#Sigmoid Function

def sigmoid (x):

 return 1/(1 + np.exp(-x))

#Derivative of Sigmoid Function

def derivatives_sigmoid(x):

 return x * (1 - x)

#Variable initialization

epoch=5000 #Setting training iterations

lr=0.1 #Setting learning rate

inputlayer_neurons = X.shape[1] #number of features in data set

hiddenlayer_neurons = 3 #number of hidden layers neurons

output_neurons = 1 #number of neurons at output layer

#weight and bias initialization

wh=np.random.uniform(size=(inputlayer_neurons,hiddenlayer_neurons))

bh=np.random.uniform(size=(1,hiddenlayer_neurons))

wout=np.random.uniform(size=(hiddenlayer_neurons,output_neurons))

bout=np.random.uniform(size=(1,output_neurons))

for i in range(epoch):

  #Forward Propogation

  hidden_layer_input1=np.dot(X,wh)

  hidden_layer_input=hidden_layer_input1 + bh

  hiddenlayer_activations = sigmoid(hidden_layer_input)

  output_layer_input1=np.dot(hiddenlayer_activations,wout)

  output_layer_input= output_layer_input1+ bout

  output = sigmoid(output_layer_input)

  #Backpropagation

  E = y-output

  slope_output_layer = derivatives_sigmoid(output)

  slope_hidden_layer = derivatives_sigmoid(hiddenlayer_activations)

  d_output = E * slope_output_layer

  Error_at_hidden_layer = d_output.dot(wout.T)

  d_hiddenlayer = Error_at_hidden_layer * slope_hidden_layer

  wout += hiddenlayer_activations.T.dot(d_output) *lr

  bout += np.sum(d_output, axis=0,keepdims=True) *lr

  wh += X.T.dot(d_hiddenlayer) *lr

  bh += np.sum(d_hiddenlayer, axis=0,keepdims=True) *lr

print('actual :\n', y, '\n')

print('predicted :\n', output)

 

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

 

## neural network in pytorch

import torch

#Input array

X = torch.Tensor([[1,0,1,0],[1,0,1,1],[0,1,0,1]])

#Output

y = torch.Tensor([[1],[1],[0]])

#Sigmoid Function

def sigmoid (x):

  return 1/(1 + torch.exp(-x))

#Derivative of Sigmoid Function

def derivatives_sigmoid(x):

  return x * (1 - x)

#Variable initialization

epoch=5000 #Setting training iterations

lr=0.1 #Setting learning rate

inputlayer_neurons = X.shape[1] #number of features in data set

hiddenlayer_neurons = 3 #number of hidden layers neurons

output_neurons = 1 #number of neurons at output layer

#weight and bias initialization

wh=torch.randn(inputlayer_neurons, hiddenlayer_neurons).type(torch.FloatTensor)

bh=torch.randn(1, hiddenlayer_neurons).type(torch.FloatTensor)

wout=torch.randn(hiddenlayer_neurons, output_neurons)

bout=torch.randn(1, output_neurons)

for i in range(epoch):

  #Forward Propogation

  hidden_layer_input1 = torch.mm(X, wh)

  hidden_layer_input = hidden_layer_input1 + bh

  hidden_layer_activations = sigmoid(hidden_layer_input)

  output_layer_input1 = torch.mm(hidden_layer_activations, wout)

  output_layer_input = output_layer_input1 + bout

  output = sigmoid(output_layer_input1)

  #Backpropagation

  E = y-output

  slope_output_layer = derivatives_sigmoid(output)

  slope_hidden_layer = derivatives_sigmoid(hidden_layer_activations)

  d_output = E * slope_output_layer

  Error_at_hidden_layer = torch.mm(d_output, wout.t())

  d_hiddenlayer = Error_at_hidden_layer * slope_hidden_layer

  wout += torch.mm(hidden_layer_activations.t(), d_output) *lr

  bout += d_output.sum() *lr

  wh += torch.mm(X.t(), d_hiddenlayer) *lr

  bh += d_output.sum() *lr

print('actual :\n', y, '\n')

print('predicted :\n', output)

 

• Сравнение с другими библиотеками глубокого обучения

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

 

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

 

Сравнивая инструменты загрузки данных (читатели, очереди и т. д.) в TensorFlow, я обнаружил, что модуль загрузки данных PyTorch очень прост в использовании. Кроме того, PyTorch не вызывает затруднений, когда мы пытаемся построить нейронные сети, поэтому нам не нужно полагаться на сторонние высокоуровневые библиотеки, такие как keras (keras опирается на tensorflow или theano).

 

С другой стороны, я не рекомендую использовать PyTorch для развертывания. PyTorch все еще находится в разработке. Как выразились разработчики PyTorch: «Мы видим, что пользователи сначала создают модель PyTorch, а когда они готовы развернуть модель в рабочей среде, они просто преобразуют ее в модель Caffe 2 и публикуют на мобильном устройстве. платформе или других платформах».

Практический пример: решение проблем распознавания изображений с помощью PyTorch

Чтобы познакомиться с PyTorch, мы рассмотрим практическую проблему глубокого обучения Analytics Vidhya — распознавание чисел. Давайте посмотрим на нашу постановку задачи:

 

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

 

Сначала загрузите файлы обучения и тестирования. Набор данных содержит сжатые файлы всех изображений, и как train.csv, так и test.csv имеют имена соответствующих обучающих и тестовых изображений. Никаких других функций в наборе данных не предусмотрено, только необработанные изображения в формате «.png».

 

Давайте начнем:

 

Шаг 0: Подготовка

1. Импортируйте все необходимые библиотеки:

# import modules

%pylab inline

import os

import numpy as np

import pandas as pd

from scipy.misc import imread

from sklearn.metrics import accuracy_score

 

2. Установите начальное значение, чтобы мы могли контролировать случайность модели.

# To stop potential randomness

seed = 128

rng = np.random.RandomState(seed)

3. Первый шаг - установить путь к каталогу для безопасного хранения!

root_dir = os.path.abspath('.')

data_dir = os.path.join(root_dir, 'data')

# check for existence

os.path.exists(root_dir), os.path.exists(data_dir)

 

Шаг 1: Загрузка данных и предварительная обработка

1. Теперь давайте прочитаем набор данных. Они имеют формат .csv и имеют имена файлов с соответствующими метками.

 

# load dataset

train = pd.read_csv(os.path.join(data_dir, 'Train', 'train.csv'))

test = pd.read_csv(os.path.join(data_dir, 'Test.csv'))

sample_submission = pd.read_csv(os.path.join(data_dir, 'Sample_Submission.csv'))

train.head()

 

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

# print an image

img_name = rng.choice(train.filename)

filepath = os.path.join(data_dir, 'Train', 'Images', 'train', img_name)

img = imread(filepath, flatten=True)

pylab.imshow(img, cmap='gray')

pylab.axis('off')

pylab.show()

3. Чтобы упростить манипулирование данными, мы храним все изображения в виде пустых массивов.

 

# load images to create train and test set

temp = []

for img_name in train.filename:

  image_path = os.path.join(data_dir, 'Train', 'Images', 'train', img_name)

  img = imread(image_path, flatten=True)

  img = img.astype('float32')

  temp.append(img)

train_x = np.stack(temp)

train_x /= 255.0

train_x = train_x.reshape(-1, 784).astype('float32')

temp = []

for img_name in test.filename:

  image_path = os.path.join(data_dir, 'Train', 'Images', 'test', img_name)

  img = imread(image_path, flatten=True)

  img = img.astype('float32')

  temp.append(img)

test_x = np.stack(temp)

test_x /= 255.0

test_x = test_x.reshape(-1, 784).astype('float32')

train_y = train.label.values

 

4. Поскольку это типичная проблема машинного обучения, для проверки правильности функциональности нашей модели мы создаем проверочный набор. Мы разделили наборы для обучения и проверки в соотношении 70:30.

 

# create validation set

split_size = int(train_x.shape[0]*0.7)

train_x, val_x = train_x[:split_size], train_x[split_size:]

train_y, val_y = train_y[:split_size], train_y[split_size:]

 

Шаг 2: Постройте модель

5. Теперь наступает основная часть, определяющая архитектуру нашей нейронной сети. Мы определяем трехслойную нейронную сеть, а именно входной, скрытый и выходной слои. Количество нейронов во входном и выходном слоях фиксировано, потому что вход — это наше изображение 28x28, а выход — вектор 10x1, представляющий класс. Мы используем 50 нейронов в скрытом слое. Здесь мы используем Адама в качестве алгоритма оптимизации, который является эффективным вариантом алгоритма градиентного спуска.

 

import torch

from torch.autograd import Variable

# number of neurons in each layer

input_num_units = 28*28

hidden_num_units = 500

output_num_units = 10

# set remaining variables

epochs = 5

batch_size = 128

learning_rate = 0.001

6. Время обучить модель

 

# define model

model = torch.nn.Sequential(

  torch.nn.Linear(input_num_units, hidden_num_units),

  torch.nn.ReLU(),

  torch.nn.Linear(hidden_num_units, output_num_units),

)

loss_fn = torch.nn.CrossEntropyLoss()

# define optimization algorithm

optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

## helper functions

# preprocess a batch of dataset

def preproc(unclean_batch_x):

  """Convert values to range 0-1"""

  temp_batch = unclean_batch_x / unclean_batch_x.max()

  return temp_batch

# create a batch

def batch_creator(batch_size):

  dataset_name = 'train'

  dataset_length = train_x.shape[0]

  batch_mask = rng.choice(dataset_length, batch_size)

  batch_x = eval(dataset_name + '_x')[batch_mask]

  batch_x = preproc(batch_x)

  if dataset_name == 'train':

    batch_y = eval(dataset_name).ix[batch_mask, 'label'].values

  return batch_x, batch_y

# train network

total_batch = int(train.shape[0]/batch_size)

for epoch in range(epochs):

  avg_cost = 0

  for i in range(total_batch):

    # create batch

    batch_x, batch_y = batch_creator(batch_size)

    # pass that batch for training

    x, y = Variable(torch.from_numpy(batch_x)), Variable(torch.from_numpy(batch_y), requires_grad=False)

    pred = model(x)

    # get loss

    loss = loss_fn(pred, y)

    # perform backpropagation

    loss.backward()

    optimizer.step()

    avg_cost += loss.data[0]/total_batch

  print(epoch, avg_cost)

# get training accuracy

x, y = Variable(torch.from_numpy(preproc(train_x))), Variable(torch.from_numpy(train_y), requires_grad=False)

pred = model(x)

final_pred = np.argmax(pred.data.numpy(), axis=1)

accuracy_score(train_y, final_pred)

# get validation accuracy

x, y = Variable(torch.from_numpy(preproc(val_x))), Variable(torch.from_numpy(val_y), requires_grad=False)

pred = model(x)

final_pred = np.argmax(pred.data.numpy(), axis=1)

accuracy_score(val_y, final_pred)

Тренировочный балл:

0.8779008746355685

И оценка проверки:

0.867482993197279

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

Эпилог

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

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

Вы когда-нибудь использовали PyTorch для создания приложений или использовали его в каком-либо проекте по науке о данных? Позвольте мне знать в комментариях ниже.

Оригинальная ссылка:

https://www.analyticsvidhya.com/blog/2018/02/pytorch-tutorial/

Профиль переводчика

и Китай,Магистр программной инженерии в Германии. Из-за интереса к машинному обучению в магистерской диссертации было выбрано улучшение традиционных kmeans с использованием идеи генетического алгоритма. В настоящее время практикует работу с большими данными в Ханчжоу. Присоединившись к THU, я надеюсь внести свою лепту для коллег по ИТ и надеюсь завести много друзей-единомышленников.

Информация о наборе команды переводчиков

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

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

Другие преимущества:Сотрудничайте и общайтесь с работниками по обработке данных из известных предприятий, Пекинского университета, Университета Цинхуа и иностранными студентами из известных университетов.

Нажмите «Прочитать исходный текст» в конце статьи, чтобы присоединиться к команде данных~

Уведомление о перепечатке

Если вам нужно перепечатать, пожалуйста, укажите автора и источник на видном месте в начале статьи (воспроизведено из: Datapi THU ID: DatapiTHU) и поместите привлекательный QR-код datapi THU в конце статьи. Если есть оригинальная идентифицированная статья, отправьте [название статьи — имя и идентификатор официальной учетной записи для авторизации] на контактный адрес электронной почты, подайте заявку на авторизацию в белом списке и отредактируйте ее по мере необходимости.

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

нажмите«Прочитай исходный текст»Примите организацию