Наука о данных

Учебное пособие по PyTorch с линейной регрессией

Учебное пособие по PyTorch с линейной регрессией
PyTorch - это научный пакет на основе Python, который обеспечивает замену NumPy ndarrays в качестве Tensors, который максимально использует преимущества графических процессоров. Еще один положительный момент фреймворка PyTorch - это скорость и гибкость, которые он обеспечивает во время вычислений. PyTorch - эффективная альтернатива работе с Tensor с использованием Tensorflow, о которой мы уже говорили ранее.

PyTorch имеет несколько больших преимуществ как вычислительный пакет, например:

PyTorch в основном используется сообществом Data Science из-за его способности удобно определять нейронные сети. Давайте посмотрим на этот вычислительный пакет в действии на этом уроке.

Установка PyTorch

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

Python -m virtualenv pytorch
источник pytorch / bin / activate

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

pip install pytorch

В этом уроке мы будем использовать Anaconda и Jupyter. Если вы хотите установить его на свой компьютер, посмотрите урок, который описывает «Как установить Anaconda Python на Ubuntu 18».04 LTS »и поделитесь своим мнением, если у вас возникнут проблемы. Чтобы установить PyTorch с Anaconda, используйте следующую команду в терминале от Anaconda:

conda install -c pytorch pytorch

Мы видим что-то подобное, когда выполняем указанную выше команду:

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

импортный фонарик

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

Начало работы с PyTorch

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

импортный фонарик

Затем мы можем определить неинициализированный тензор с определенным размером:

x = фонарик.пустой (4, 4)
print ("Тип массива: ".формат (x.type)) # type
print ("Форма массива: ".формат (x.shape)) # shape
печать (х)

Мы видим что-то подобное, когда выполняем приведенный выше скрипт:

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

Давайте запустим еще один пример, в котором мы инициализируем тензор Torched со случайными значениями:

random_tensor = факел.ранд (5, 4)
печать (random_tensor)

Когда мы запустим приведенный выше код, мы увидим напечатанный случайный тензорный объект:

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

Преобразование между NumPy и PyTorch

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

Например, мы импортируем NumPy в наш скрипт и определим простой случайный массив:

импортировать numpy как np
массив = np.случайный.ранд (4, 3)
transformed_tensor = факел.from_numpy (массив)
print (" \ n".формат (transformed_tensor))

Когда мы запустим приведенный выше код, мы увидим напечатанный преобразованный тензорный объект:

Теперь попробуем преобразовать этот тензор обратно в массив NumPy:

numpy_arr = преобразованный_тензор.numpy ()
печать (" \ п".формат (тип (numpy_arr), numpy_arr))

Когда мы запустим приведенный выше код, мы увидим напечатанный преобразованный массив NumPy:

Если присмотреться, даже точность преобразования сохраняется при преобразовании массива в тензор и последующем преобразовании его обратно в массив NumPy.

Тензорные операции

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

Нарезка тензора

Мы уже рассмотрели, как сделать новый тензор, давайте сделаем его сейчас и ломтик Это:

вектор = факел.тензор ([1, 2, 3, 4, 5, 6])
печать (вектор [1: 4])

Приведенный выше фрагмент кода предоставит нам следующий результат:

тензор ([2, 3, 4])

Мы можем игнорировать последний индекс:

печать (вектор [1:])

И мы вернем то, что ожидается, со списком Python:

тензор ([2, 3, 4, 5, 6])

Создание плавающего тензора

Теперь создадим плавающий тензор:

float_vector = факел.FloatTensor ([1, 2, 3, 4, 5, 6])
печать (float_vector)

Приведенный выше фрагмент кода предоставит нам следующий результат:

тензор ([1., 2., 3., 4., 5., 6.])

Тип этого Тензор будет:

печать (float_vector.dtype)

Отдает:

факел.float32

Арифметические операции над тензорами

Мы можем добавить два тензора, как любые математические элементы, например:

тензор_1 = факел.тензор ([2, 3, 4])
тензор_2 = факел.тензор ([3, 4, 5])
тензор_1 + тензор_2

Приведенный выше фрагмент кода даст нам:

Мы можем умножать тензор со скаляром:

тензор_1 * 5

Это даст нам:

Мы можем выполнить скалярное произведение также между двумя тензорами:

d_product = факел.точка (тензор_1, тензор_2)
d_product

Приведенный выше фрагмент кода предоставит нам следующий результат:

В следующем разделе мы рассмотрим более высокие измерения тензоров и матриц.

Умножение матриц

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

Мы определим матрицу для начала:

матрица = факел.тензор ([1, 3, 5, 6, 8, 0]).вид (2, 3)

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

количество строк, умноженное на количество столбцов = количество элементов

Когда мы визуализируем вышеуказанный двумерный тензор, мы увидим следующую матрицу:

Мы определим еще одну идентичную матрицу другой формы:

matrix_b = факел.тензор ([1, 3, 5, 6, 8, 0]).вид (3, 2)

Теперь мы можем, наконец, выполнить умножение:

факел.матмуль (матрица, матрица_b)

Приведенный выше фрагмент кода предоставит нам следующий результат:

Линейная регрессия с PyTorch

Линейная регрессия - это алгоритм машинного обучения, основанный на методах контролируемого обучения для выполнения регрессионного анализа независимых и зависимых переменных. Уже запутался? Давайте определим линейную регрессию простыми словами.

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

Метод линейной регрессии обычно использует уравнение линии для представления взаимосвязи между зависимой переменной (y) и независимой переменной (x):

у = м * х + с

В приведенном выше уравнении:

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

house_prices_array = [3, 4, 5, 6, 7, 8, 9]
house_price_np = np.массив (house_prices_array, dtype = np.float32)
house_price_np = house_price_np.изменить форму (-1,1)
house_price_tensor = переменная (факел.from_numpy (house_price_np))
house_size = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.массив (размер_дома, dtype = np.float32)
house_size_np = house_size_np.изменить форму (-1, 1)
house_size_tensor = переменная (факел.from_numpy (размер_дома_np))
# давайте визуализировать наши данные
импортировать matplotlib.pyplot как plt
plt.разброс (house_prices_array, house_size_np)
plt.xlabel ("Стоимость дома, $")
plt.ylabel ("Размеры дома")
plt.title ("Цена дома в $ VS Размер дома")
plt

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

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

Цель применения линейной регрессии - найти линию, которая соответствует нашим данным с минимальной ошибкой. Здесь шаги, которые мы выполним, чтобы применить алгоритм линейной регрессии к нашим данным:

  1. Создайте класс для линейной регрессии
  2. Определите модель из этого класса линейной регрессии
  3. Рассчитайте MSE (среднеквадратическую ошибку)
  4. Выполните оптимизацию, чтобы уменьшить ошибку (SGD i.е. стохастический градиентный спуск)
  5. Выполнить обратное распространение
  6. Наконец, сделайте прогноз

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

импортный фонарик
от факела.переменная импорта автограда
импортный фонарик.nn как nn

Затем мы можем определить наш класс линейной регрессии, который наследуется от модуля нейронной сети PyTorch:

class LinearRegression (nn.Модуль):
def __init __ (self, input_size, output_size):
# суперфункция наследуется от nn.Модуль, чтобы мы могли получить доступ ко всему из nn.Модуль
супер (Линейная регрессия, сам).__в этом__()
# Линейная функция
себя.linear = nn.Линейный (input_dim, output_dim)
def вперед (self, x):
вернуть себя.линейный (x)

Теперь, когда мы готовы с классом, давайте определим нашу модель с размером входа и выхода 1:

input_dim = 1
output_dim = 1
model = LinearRegression (input_dim, output_dim)

Мы можем определить MSE как:

mse = nn.MSELoss ()

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

# Оптимизация (найти параметры, минимизирующие ошибку)
learning_rate = 0.02
optimizer = torch.оптим.SGD (модель.параметры (), lr = скорость обучения)

Наконец, мы можем построить график функции потерь для нашей модели:

loss_list = []
iteration_number = 1001
для итерации в диапазоне (iteration_number):
# выполнить оптимизацию с нулевым градиентом
оптимизатор.zero_grad ()
результаты = модель (house_price_tensor)
loss = mse (результаты, размер_дома)
# вычисляем производную, отступая назад
потеря.назад ()
# Обновление параметров
оптимизатор.шаг()
потеря # магазина
loss_list.добавить (потеря.данные)
# потеря печати
если (итерация% 50 == 0):
print ('эпоха , потеря '.формат (итерация, потеря.данные))
plt.сюжет (диапазон (номер_терации), список_потери)
plt.xlabel ("Количество итераций")
plt.ylabel ("Потеря")
plt

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

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

# спрогнозируем цену нашей машины
предсказано = модель (house_price_tensor).данные.numpy ()
plt.scatter (house_prices_array, house_size, label = "исходные данные", color = "red")
plt.scatter (house_prices_array, предсказано, метка = "предсказанные данные", цвет = "синий")
plt.легенда ()
plt.xlabel ("Стоимость дома, $")
plt.ylabel ("Размер дома")
plt.title ("Исходные и прогнозируемые значения")
plt.показывать()

Вот сюжет, который поможет нам сделать прогноз:

Заключение

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

Битва за Веснот 1.13.6 Выпущена разработка
Битва за Веснот 1.13.6, выпущенная в прошлом месяце, является шестой разработкой в ​​1.13.x и содержит ряд улучшений, в первую очередь пользовательско...
Как установить League Of Legends на Ubuntu 14.04
Если вы поклонник League of Legends, то это возможность для вас протестировать League of Legends. Обратите внимание, что LOL поддерживается в PlayOnLi...
Установите последнюю версию игры OpenRA Strategy в Ubuntu Linux
OpenRA - это игровой движок Libre / Free Real Time Strategy, воссоздающий ранние игры Westwood, такие как классическая Command & Conquer: Red Alert. Р...