Урок за PyTorch с линейна регресия

PyTorch е базиран на Python научен пакет, който осигурява заместване на NumPy ndarrays като Тензори, което се възползва максимално от графичните процесори. Друг положителен момент за рамката на PyTorch е скоростта и гъвкавостта, които тя осигурява по време на изчисленията. PyTorch е ефективна алтернатива за работа с тензори, използващи Tensorflow, за която разгледахме по-рано.

PyTorch има няколко големи предимства като изчислителен пакет, като:

Възможно е да изграждаме изчислителни графики, докато вървим. Това означава, че не е необходимо предварително да се знае за изискванията към паметта на графиката. Можем свободно да създаваме невронна мрежа и да я оценяваме по време на изпълнение.
Лесен за API на Python, който е лесно интегрируем
Подкрепена от Facebook, така че подкрепата на общността е много силна
Осигурява родна поддръжка на няколко GPU

PyTorch се възприема главно от общността на Data Science поради способността му удобно да дефинира невронни мрежи. Нека да видим този изчислителен пакет в действие в този урок.

Инсталиране на PyTorch

Само бележка преди започване, можете да използвате виртуална среда за този урок, която можем да направим със следната команда:

python -m virtualenv pytorch
източник pytorch / bin / активиране

След като виртуалната среда е активна, можете да инсталирате библиотека PyTorch във виртуалната среда, за да могат да се изпълняват примери, които създаваме по-нататък:

pip инсталирайте pytorch

В този урок ще използваме Анаконда и Юпитер. Ако искате да го инсталирате на вашата машина, погледнете урока, който описва „Как да инсталирате 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.тип)) # тип
print ("Форма на масива: ".формат (x.форма)) # форма
печат (x)

Виждаме нещо подобно, когато изпълняваме горния скрипт:

Току-що направихме неинициализиран тензор с определен размер в горния скрипт. За да повторим нашия урок Tensorflow, тензори могат да бъдат наречени n-мерни масиви което ни позволява да представяме данни в сложни измерения.

Нека да стартираме друг пример, при който инициализираме Torched тензор с произволни стойности:

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

Когато стартираме горния код, ще видим отпечатан обект на случаен тензор:

Моля, обърнете внимание, че изходът за горния случаен тензор може да бъде различен за вас, тъй като е случаен !

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

NumPy и PyTorch са напълно съвместими помежду си. Ето защо е лесно да трансформирате масивите NumPy в тензори и обратно. Освен лекотата, която предлага API, вероятно е по-лесно да визуализирате тензорите под формата на масиви NumPy вместо Tensors или просто да го наречете любовта си към NumPy!

За пример ще импортираме NumPy в нашия скрипт и ще определим прост случаен масив:

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

Когато стартираме горния код, ще видим отпечатания трансформиран тензорен обект:

Сега, нека се опитаме да преобразуваме този тензор обратно в масив NumPy:

numpy_arr = трансформиран_тензор.numpy ()
печат (" \ n".формат (тип (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

Това ще ни даде:

Можем да изпълним a точков продукт между два тензора също:

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)

Най-накрая можем да извършим умножението сега:

факла.matmul (матрица, matrix_b)

По-горе кодов фрагмент ще ни предостави следния изход:

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

Линейната регресия е алгоритъм за машинно обучение, базиран на контролирани техники за обучение за извършване на регресионен анализ на независима и зависима променлива. Объркан вече? Нека дефинираме линейната регресия с прости думи.

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

Техниката на линейна регресия обикновено използва уравнението на права, за да представи връзката между зависимата променлива (y) и независимата променлива (x):

y = m * x + c

В горното уравнение:

m = наклон на кривата
c = пристрастие (точка, която пресича оста y)

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

къща_цени_масив = [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))
размер на къщата = [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 (house_size_np))
# позволява да визуализираме нашите данни
импортиране на matplotlib.pyplot като plt
plt.разпръскване (къща_цени_масив, къща_размер_np)
plt.xlabel ("Цена на къщата $")
plt.ylabel ("Размери на къщата")
plt.заглавие ("Цена на къщата $ VS Размер на къщата")
plt

Имайте предвид, че използвахме Matplotlib, който е отлична библиотека за визуализация. Прочетете повече за това в урока по Matplotlib. Ще видим следната графика, след като стартираме горния кодов фрагмент:

Когато правим линия през точките, тя може да не е идеална, но все пак е достатъчна за вида на връзката между променливите. След като събрахме и визуализирахме данните си, искаме да направим прогноза, какъв ще бъде размерът на къщата, ако тя е била продадена за $ 650 000.

Целта на прилагането на линейна регресия е да се намери линия, която да пасва на нашите данни с минимална грешка. Тук са стъпките, които ще извършим, за да приложим алгоритъма на линейна регресия към нашите данни:

Изградете клас за линейна регресия
Дефинирайте модела от този клас на линейна регресия
Изчислете MSE (средна квадратична грешка)
Извършете оптимизация, за да намалите грешката (SGD i.д. стохастичен градиент спускане)
Извършете обратно размножаване
Накрая направете прогнозата

Нека започнем да прилагаме горните стъпки с правилен импорт:

факел за внос
от факла.autograd променлива
факел за внос.nn като nn

След това можем да дефинираме нашия клас на линейна регресия, който наследява от модула на невронната мрежа PyTorch:

клас LinearRegression (nn.Модул):
def __init __ (самостоятелно, размер на входа, размер на изхода):
# супер функция наследява от nn.Модул, за да имаме достъп до всичко от nn.Модул
супер (LinearRegression, самостоятелно).__в него__()
# Линейна функция
себе си.линейно = 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 ()

Готови сме да дефинираме оптимизацията, която може да бъде извършена върху прогнозата на модела за най-добра производителност:

# Оптимизация (намиране на параметри, които минимизират грешката)
скорост на обучение = 0.02
оптимизатор = факел.оптимално.SGD (модел.параметри (), lr = скорост на обучение)

Най-накрая можем да направим график за функцията за загуба на нашия модел:

списък със загуби = []
номер на итерация = 1001
за итерация в обхват (iteration_number):
# извършете оптимизация с нулев градиент
оптимизатор.zero_grad ()
резултати = модел (къща_цена_тензор)
загуба = mse (резултати, house_size_tensor)
# изчислява производна, като стъпвам назад
загуба.назад ()
# Актуализиране на параметрите
оптимизатор.стъпка ()
# загуба на магазин
списък със загуби.добавяне (загуба.данни)
# загуба на печат
if (итерация% 50 == 0):
print ('епоха , загуба '.формат (итерация, загуба.данни))
plt.парцел (диапазон (номер на итерация), списък на загуби)
plt.xlabel ("Брой повторения")
plt.ylabel ("Загуба")
plt

Направихме оптимизации няколко пъти за функцията за загуба и се опитахме да визуализираме колко загуба се увеличи или намали. Ето парцела, който е резултатът:

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

# предскажете нашата цена на автомобила
прогнозира = модел (къща_цена_тензор).данни.numpy ()
plt.разпръскване (къща_цени_масив, размер_ къща_, етикет = "оригинални данни", цвят = "червен")
plt.разпръскване (house_prices_array, прогнозирано, label = "прогнозирани данни", color = "синьо")
plt.легенда ()
plt.xlabel ("Цена на къщата $")
plt.ylabel ("Размер на къщата")
plt.заглавие ("Оригинал срещу прогнозирани стойности")
plt.покажи ()

Ето сюжета, който ще ни помогне да направим прогнозата:

Заключение

В този урок разгледахме отличен изчислителен пакет, който ни позволява да правим по-бързи и ефективни прогнози и много повече. PyTorch е популярен поради начина, по който ни позволява да управляваме невронните мрежи по основен начин с тензори.