Phenquestions
Като цяло ще разгледаме три основни теми в този урок:
- Какво представляват Tensors и TensorFlow
- Прилагане на ML алгоритми с TensorFlow
- Примери за използване на TensorFlow
TensorFlow е отличен Python пакет от Google, който използва добре парадигмата за програмиране на потока от данни за силно оптимизирани математически изчисления. Някои от характеристиките на TensorFlow са:
- Възможност за разпределено изчисление, което улеснява управлението на данни в големи набори
- Дълбокото обучение и поддръжката на невронни мрежи са добри
- Той управлява много ефективно сложни математически структури като n-мерни масиви
Благодарение на всички тези функции и обхвата на алгоритмите за машинно обучение TensorFlow внедрява, го прави библиотека за производствен мащаб. Нека да се потопим в концепции в TensorFlow, за да можем да си замърсим ръцете с код веднага след това.
Инсталиране на TensorFlow
Тъй като ще използваме Python API за TensorFlow, добре е да знаете, че той работи и с двете Python 2.7 и 3.3+ версии. Нека инсталираме библиотека TensorFlow, преди да преминем към действителните примери и концепции. Има два начина за инсталиране на този пакет. Първият включва използването на мениджъра на пакети на Python, pip:
pip инсталирайте tensorflowВторият начин е свързан с Anaconda, ние можем да инсталираме пакета като:
conda install -c conda-forge tensorflowЧувствайте се свободни да търсите нощни компилации и версии на графичния процесор на официалните страници за инсталиране на TensorFlow.
Ще използвам мениджъра на Anaconda за всички примери в този урок. Ще пусна Jupyter Notebook за същото:
Сега, когато сме готови с всички оператори за импортиране да напишем някакъв код, нека започнем да се гмуркаме в пакета SciPy с някои практически примери.
Какво представляват тензорите?
Тензорите са основните структури от данни, използвани в Tensorflow. Да, те са просто начин за представяне на данни при задълбочено обучение. Нека ги визуализираме тук:
Както е описано на изображението, тензори могат да бъдат наречени n-мерни масиви което ни позволява да представяме данни в сложни измерения. Можем да възприемаме всяко измерение като различна характеристика на данните в дълбокото обучение. Това означава, че тензорите могат да станат доста сложни, когато става въпрос за сложни набори от данни с много функции.
След като разберем какво са Tensors, мисля, че е доста лесно да се извлече какво се случва в TensorFlow. Тези термини означават как тензори или характеристики могат да се движат в набори от данни, за да произвеждат ценна продукция, докато изпълняваме различни операции върху нея.
Разбиране на TensorFlow с константи
Точно както четохме по-горе, TensorFlow ни позволява да изпълняваме алгоритми за машинно обучение на Tensors, за да произведем ценна продукция. С TensorFlow проектирането и обучението на модели за дълбоко обучение е направо напред.
TensorFlow идва със сграда Графики за изчисления. Графиките за изчисление са графики на потока от данни, в които математическите операции са представени като възли, а данните са представени като ръбове между тези възли. Нека напишем много прост кодов фрагмент, за да осигурим конкретна визуализация:
импортиране на tensorflow като tfx = tf.постоянен (5)
y = tf.постоянна (6)
z = x * y
печат (z)
Когато стартираме този пример, ще видим следния изход:
Защо умножението е грешно? Не това очаквахме. Това се случи, защото по този начин не можем да извършваме операции с TensorFlow. Първо, трябва да започнем a сесия за да работи изчислителната графика,
С Sessions можем капсулира контрола на операциите и състоянието на тензорите. Това означава, че сесията може също да съхранява резултата от изчислителна графика, така че да може да предаде този резултат на следващата операция по реда на изпълнение на конвейерите. Нека създадем сесия сега, за да получим правилния резултат:
# Започнете с обекта на сесиятасесия = tf.Сесия()
# Предоставете изчислението за сесия и го съхранявайте
резултат = сесия.бягане (z)
# Отпечатайте резултата от изчислението
печат (резултат)
# Затваряне на сесията
сесия.близо()
Този път получихме сесията и й предоставихме изчисленията, необходими за изпълнението на възлите. Когато стартираме този пример, ще видим следния изход:
Въпреки че получихме предупреждение от TensorFlow, все пак получихме правилния изход от изчислението.
Едноелементни тензорни операции
Подобно на това, което умножихме два постоянни тензора в последния пример, имаме много други операции в TensorFlow, които могат да бъдат изпълнени върху отделни елементи:
- добавете
- изваждане
- умножете
- div
- мод
- коремни мускули
- отрицателен
- знак
- квадрат
- кръгъл
- sqrt
- прах
- опит
- дневник
- максимум
- минимум
- cos
- грях
Едноелементни операции означават, че дори когато предоставите масив, операциите ще се извършват върху всеки от елементите на този масив. Например:
импортиране на tensorflow като tfимпортиране на numpy като np
тензор = np.масив ([2, 5, 8])
тензор = tf.convert_to_tensor (тензор, dtype = tf.float64)
с tf.Сесия () като сесия:
печат (сесия.тичам (tf.cos (тензор)))
Когато стартираме този пример, ще видим следния изход:
Тук разбрахме две важни концепции:
- Всеки масив NumPy може лесно да бъде преобразуван в тензор с помощта на функцията convert_to_tensor
- Операцията е извършена върху всеки от елемента на масива NumPy
Заместители и променливи
В един от предишните раздели разгледахме как можем да използваме константи на Tensorflow, за да направим изчислителни графики. Но TensorFlow също ни позволява да взимаме входни данни в хода, така че изчислителната графика да може да бъде динамична по своята същност. Това е възможно с помощта на Placeholders и Variables.
В действителност, Placeholder не съдържат никакви данни и трябва да имат валидни входове по време на изпълнение и както се очаква, без въвеждане, те ще генерират грешка.
Placeholder може да се нарече като споразумение в графика, която със сигурност ще бъде предоставена по време на изпълнение. Ето пример за заместители:
импортиране на tensorflow като tf# Два запазени места
x = tf. заместител (tf.float32)
y = tf. заместител (tf.float32)
# Възлагане на операция за умножение w.r.T. а & b към възел mul
z = x * y
# Създайте сесия
сесия = tf.Сесия()
# Пропускайте стойности за пласформерите
резултат = сесия.бягане (z, x: [2, 5], y: [3, 7])
print ('Умножаване на x и y:', резултат)
Когато стартираме този пример, ще видим следния изход:
Сега, след като имаме знания за заместителите, нека обърнем поглед към променливите. Знаем, че изходът на уравнение може да се промени за същия набор от входове с течение на времето. Така че, когато тренираме нашата променлива на модела, тя може да промени поведението си с течение на времето. В този сценарий променлива ни позволява да добавим тези обучими параметри към нашата изчислителна графика. Променлива може да бъде дефинирана както следва:
x = tf.Променлива ([5.2], dtype = tf.float32)В горното уравнение x е променлива, на която се предоставя първоначалната стойност и типа на данните. Ако не предоставим типа на данните, той ще изведе от TensorFlow с първоначалната си стойност. Вижте типовете данни TensorFlow тук.
За разлика от константата, ние трябва да извикаме функция на Python, за да инициализираме всички променливи на графика:
init = tf.global_variables_initializer ()сесия.тичам (init)
Уверете се, че сте изпълнили горната функция TensorFlow, преди да използваме нашата графика.
Линейна регресия с TensorFlow
Линейната регресия е един от най-често срещаните алгоритми, използвани за установяване на връзка в дадени непрекъснати данни. Тази връзка между координатните точки, да речем x и y, се нарича a хипотеза. Когато говорим за линейна регресия, хипотезата е права линия:
y = mx + cТук m е наклонът на линията, а тук е вектор, представляващ тежести. c е постоянният коефициент (y-intercept) и тук той представлява Пристрастие. Теглото и пристрастието се наричат параметри на модела.
Линейните регресии ни позволяват да изчислим стойностите на теглото и пристрастията, така че да имаме минимум функция на разходите. И накрая, x е независимата променлива в уравнението, а y е зависимата променлива. Сега нека започнем да изграждаме линейния модел в TensorFlow с прост кодов фрагмент, който ще обясним:
импортиране на tensorflow като tf# Променливи за наклон на параметъра (W) с начална стойност 1.1
W = tf.Променлива ([1.1], сл.float32)
# Променлива за пристрастие (b) с начална стойност -1.1
b = tf.Променлива ([- 1.1], сл.float32)
# Заместители за предоставяне на вход или независима променлива, обозначени с x
x = tf.заместител (tf.float32)
# Уравнение на права или линейна регресия
линеен_модел = W * x + b
# Инициализиране на всички променливи
сесия = tf.Сесия()
init = tf.global_variables_initializer ()
сесия.тичам (init)
# Изпълнете регресионен модел
печат (сесия.бягане (линеен_модел x: [2, 5, 7, 9]))
Тук направихме точно това, което обяснихме по-рано, нека обобщим тук:
- Започнахме с импортиране на TensorFlow в нашия скрипт
- Създайте няколко променливи, които да представят теглото на вектора и пристрастието на параметъра
- Ще бъде необходим заместител, който да представя входа, x
- Представят линейния модел
- Инициализирайте всички стойности, необходими за модела
Когато стартираме този пример, ще видим следния изход:
Простият кодов фрагмент просто предоставя основна идея за това как можем да изградим модел на регресия. Но все пак трябва да направим още няколко стъпки, за да завършим модела, който изградихме:
- Трябва да направим модела си самообучим, за да може да произвежда продукция за всеки даден вход
- Трябва да проверим резултата, предоставен от модела, като го сравним с очаквания резултат за дадения x
Функция на загуба и валидиране на модела
За да потвърдим модела, трябва да имаме мярка за това колко е отклоненият токов изход от очаквания изход. Има различни функции за загуби, които могат да се използват тук за валидиране, но ние ще разгледаме един от най-често срещаните методи, Сума от квадратни грешки или SSE.
Уравнението за SSE е дадено като:
E = 1/2 * (t - y) 2Тук:
- E = средна квадратична грешка
- t = Получена продукция
- y = очаквана продукция
- t - y = Грешка
Сега нека напишем кодов фрагмент непрекъснато до последния фрагмент, за да отразим стойността на загубата:
y = tf.заместител (tf.float32)грешка = линеен_модел - у
квадратни_грешки = tf.квадрат (грешка)
загуба = tf.намаляване_сума (квадратни_грешки)
печат (сесия.бягане (загуба, x: [2, 5, 7, 9], y: [2, 4, 6, 8]))
Когато стартираме този пример, ще видим следния изход:
Ясно е, че стойността на загубата е много ниска за дадения модел на линейна регресия.
Заключение
В този урок разгледахме един от най-популярните пакети за дълбоко обучение и машинно обучение, TensorFlow. Направихме и модел на линейна регресия, който имаше много висока точност.
