Технология
Първи стъпки с TensorFlow: Урок за машинно обучение
TensorFlow е софтуерна библиотека с отворен код, създадена от Google, която се използва за внедряване на машинно обучение и системи за дълбоко обучение. Тези две имена съдържат поредица от мощни алгоритми, които споделят общо предизвикателство - да позволят на компютъра да се научи как автоматично да разпознава сложни модели и / или да взема най-добрите възможни решения.
Ако се интересувате от подробности за тези системи, можете да научите повече от публикациите в блога на ApeeScape на машинно обучение и дълбоко обучение .
TensorFlow, в основата си, е библиотека за програмиране на потока от данни. Той използва различни техники за оптимизация, за да направи изчисляването на математическите изрази по-лесно и по-ефективно.
Някои от основните характеристики на TensorFlow са:
- Ефективно работи с математически изрази, включващи многомерни масиви
- Добра поддръжка на дълбоки невронни мрежи и концепции за машинно обучение
- GPU / CPU изчисления, при които един и същ код може да бъде изпълнен и на двете архитектури
- Висока скалируемост на изчисленията в различни машини и огромни масиви от данни
Заедно тези функции правят TensorFlow перфектната рамка за машинен интелект в производствен мащаб.
В този урок за TensorFlow ще научите как можете да използвате прости, но мощни методи за машинно обучение в TensorFlow и как можете да използвате някои от помощните му библиотеки за отстраняване на грешки, визуализиране и ощипване на моделите, създадени с него.
Инсталиране на TensorFlow
Ще използваме API на TensorFlow Python, който работи с Python 2.7 и Python 3.3+. Версията на GPU (само за Linux) изисква Cuda Toolkit 7.0+ и cuDNN v2 +.
Ще използваме системата за управление на зависимостта на пакета Conda, за да инсталираме TensorFlow. Conda ни позволява да отделяме множество среди на машина. Можете да научите как да инсталирате Conda тук .
След инсталирането на Conda можем да създадем средата, която ще използваме за инсталиране и използване на TensorFlow. Следващата команда ще създаде нашата среда с някои допълнителни библиотеки като NumPy , което е много полезно, след като започнем да използваме TensorFlow.
Версията на Python, инсталирана в тази среда, е 2.7 и ще използваме тази версия в тази статия.
conda create --name TensorflowEnv biopython За да улесним нещата, ние инсталираме тук биопитон, вместо само NumPy. Това включва NumPy и няколко други пакета, от които ще се нуждаем. Винаги можете да инсталирате пакетите, колкото са ви необходими, като използвате conda install или pip install команди.
Следващата команда ще активира създадената среда на Conda. Ще можем да използваме пакети, инсталирани в него, без да се смесваме с пакети, които са инсталирани глобално или в някои други среди.
source activate TensorFlowEnv Инструментът за инсталиране на пип е стандартна част от среда на Conda. Ще го използваме за инсталиране на библиотеката TensorFlow. Преди да направите това, добра първа стъпка е актуализирането на pip до най-новата версия, като се използва следната команда:
pip install --upgrade pip Сега сме готови да инсталираме TensorFlow, като стартираме:
pip install tensorflow Изтеглянето и изграждането на TensorFlow може да отнеме няколко минути. По време на писането това инсталира TensorFlow 1.1.0.
Графики на потока от данни
В TensorFlow изчисленията са описани с помощта на графики на потока от данни. Всеки възел на графиката представлява екземпляр на математическа операция (като събиране, разделяне или умножение) и всеки ръб е многоизмерен набор от данни (тензор), върху който се извършват операциите.
Тъй като TensorFlow работи с изчислителни графики, те се управляват, където всеки възел представлява екземпляр на операция, при която всяка операция има нула или повече входове и нула или повече изходи.
Ръбовете в TensorFlow могат да бъдат групирани в две категории: Нормални ръбове прехвърлят структура от данни (тензори), където е възможно изходът на една операция да стане вход за друга операция и специални ръбове, които се използват за контрол на зависимостта между два възела за задаване на ред на работа, при който един възел чака да завърши друг.
Прости изрази
Преди да преминем към обсъждане на елементи на TensorFlow, първо ще направим сесия за работа с TensorFlow, за да добием усещане за това как изглежда програма TensorFlow.
Нека започнем с прости изрази и да приемем, че по някаква причина искаме да оценим функцията y = 5*x + 13 по мода TensorFlow.
В прост код на Python това би изглеждало така:
x = -2.0 y = 5*x + 13 print y което ни дава в този случай резултат от 3.0.
Сега ще преобразуваме горния израз в термини TensorFlow.
Константи
В TensorFlow константи се създават с помощта на константата на функцията, която има подписа constant(value, dtype=None, shape=None, name='Const', verify_shape=False), където value е действителна постоянна стойност, която ще се използва при по-нататъшно изчисление, dtype е параметърът на типа данни (напр. float32 / 64, int8 / 16 и т.н.), shape е по избор размери, name е незадължително име за тензора, а последният параметър е булева стойност, която показва проверка на формата на стойностите.
Ако имате нужда от константи със специфични стойности във вашия модел на обучение, тогава constant обект може да се използва както в следния пример:
z = tf.constant(5.2, name='x', dtype=tf.float32) Променливи
Променливите в TensorFlow са буфери в паметта, съдържащи тензори, които трябва да бъдат изрично инициализирани и използвани в графика за поддържане на състоянието през сесията. Чрез просто извикване на конструктора променливата се добавя в изчислителна графика.
Променливите са особено полезни, след като започнете с обучителни модели и се използват за задържане и актуализиране на параметри. Първоначалната стойност, предадена като аргумент на конструктор, представлява тензор или обект, който може да бъде преобразуван или върнат като тензор. Това означава, че ако искаме да попълним променлива с някои предварително дефинирани или произволни стойности, които да бъдат използвани след това в процеса на обучение и актуализирани по време на итерации, можем да я дефинираме по следния начин:
k = tf.Variable(tf.zeros([1]), name='k') Друг начин за използване на променливи в TensorFlow е при изчисления, при които тази променлива не може да бъде обучена и може да бъде дефинирана по следния начин:
k = tf.Variable(tf.add(a, b), trainable=False) Сесии
За да оценим реално възлите, трябва да изпълним изчислителна графика в рамките на сесия.
Сесията капсулира контрола и състоянието на изпълнението на TensorFlow. Сесия без параметри ще използва графиката по подразбиране, създадена в текущата сесия, в противен случай класът на сесията приема параметър на графиката, който се използва в тази сесия, за да бъде изпълнен.
По-долу е даден кратък кодов фрагмент, който показва как термините, дефинирани по-горе, могат да се използват в TensorFlow за изчисляване на проста линейна функция.
import tensorflow as tf x = tf.constant(-2.0, name='x', dtype=tf.float32) a = tf.constant(5.0, name='a', dtype=tf.float32) b = tf.constant(13.0, name='b', dtype=tf.float32) y = tf.Variable(tf.add(tf.multiply(a, x), b)) init = tf.global_variables_initializer() with tf.Session() as session: session.run(init) print session.run(y) Използване на TensorFlow: Дефиниране на изчислителни графики
Хубавото при работата с графики на потока от данни е, че моделът на изпълнение е отделен от неговото изпълнение (на процесор, графичен процесор или някаква комбинация), където след като бъде внедрен, софтуер в TensorFlow може да се използва на процесора или графичния процесор, където цялата сложност е свързана с код изпълнението е скрито.
Графиката на изчисленията може да бъде изградена в процеса на използване на библиотеката TensorFlow, без да се налага изрично създаване на екземпляр Графика обекти.
Графичен обект в TensorFlow може да бъде създаден в резултат на прост ред код като c = tf.add(a, b). Това ще създаде операционен възел, който отнема два тензора a и b които произвеждат тяхната сума c като изход.
Графиката на изчисленията е вграден процес, който използва библиотеката, без да е необходимо да извиква графика обект директно. Графичен обект в TensorFlow, който съдържа набор от операции и тензори като единици данни, се използва между операциите, което позволява един и същ процес и съдържа повече от една графика, където всяка графика ще бъде присвоена на различна сесия. Например простият ред на кода c = tf.add(a, b) ще създаде операционен възел, който отнема два тензора a и b като вход и произвежда тяхната сума c като изход.
TensorFlow също така осигурява механизъм за подаване за корекция на тензор към всяка операция в графиката, където подаването замества изхода на операция със стойността на тензора. Данните за емисията се предават като аргумент в run() извикване на функция.
Запазеното място е начинът на TensorFlow да позволи на разработчиците да инжектират данни в изчислителната графика чрез заместители, които са обвързани в някои изрази. Подписът на заместителя е:
placeholder(dtype, shape=None, name=None) където dtype е видът на елементите в тензорите и може да осигури както формата на тензорите, които ще се подават, така и името на операцията.
Ако формата не бъде предадена, този тензор може да се подава с всякаква форма. Важна забележка е, че тензорът на заместител трябва да се захранва с данни, в противен случай при изпълнение на сесията и ако тази част липсва, запазеният генерира грешка със следната структура:
InvalidArgumentError (see above for traceback): You must feed a value for placeholder tensor 'y' with dtype float Предимството на запазените места е, че те позволяват на разработчиците да създават операции и изчислителната графика като цяло, без да е необходимо да предоставят данните предварително за това, а данните могат да се добавят по време на изпълнение от външни източници.
Нека вземем прост проблем за умножаване на две цели числа x и y по мода TensorFlow, където ще се използва заместител заедно с механизъм за подаване през сесията run метод.
import tensorflow as tf x = tf.placeholder(tf.float32, name='x') y = tf.placeholder(tf.float32, name='y') z = tf.multiply(x, y, name='z') with tf.Session() as session: print session.run(z, feed_dict={x: 2.1, y: 3.0}) Визуализиране на изчислителната графика с TensorBoard
TensorBoard е инструмент за визуализация за анализ на графики на потока от данни. Това може да бъде полезно за по-добро разбиране на моделите за машинно обучение.
С TensorBoard можете да получите представа за различни видове статистика за параметрите и подробности за частите на изчислителната графика като цяло. Не е необичайно, че дълбоката невронна мрежа има голям брой възли. TensorBoard позволява на разработчиците да получат представа за всеки възел и как се извършва изчислението по време на изпълнение на TensorFlow.
Сега нека се върнем към нашия пример от началото на този урок TensorFlow, където дефинирахме линейна функция с формат y = a*x + b
За да регистрира събития от сесията, които по-късно могат да бъдат използвани в TensorBoard, TensorFlow предоставя FileWriter клас. Може да се използва за създаване на файл на събитие за съхранение обобщения и събития където конструкторът приема шест параметъра и изглежда така:
__init__(logdir, graph=None, max_queue=10, flush_secs=120, graph_def=None, filename_suffix=None) където се изисква параметър logdir, а други имат стойности по подразбиране. Графичният параметър ще бъде предаден от обекта на сесията, създаден в програмата за обучение. Пълният примерен код изглежда така:
import tensorflow as tf x = tf.constant(-2.0, name='x', dtype=tf.float32) a = tf.constant(5.0, name='a', dtype=tf.float32) b = tf.constant(13.0, name='b', dtype=tf.float32) y = tf.Variable(tf.add(tf.multiply(a, x), b)) init = tf.global_variables_initializer() with tf.Session() as session: merged = tf.summary.merge_all() // new writer = tf.summary.FileWriter('logs', session.graph) // new session.run(init) print session.run(y) Добавихме само два нови реда. Обединяваме всички обобщения, събрани в графиката по подразбиране, и FileWriter се използва за изхвърляне на събития във файла, както описахме по-горе, съответно.
След стартиране на програмата имаме файла в регистрите на директориите и последната стъпка е да стартираме tensorboard:
tensorboard --logdir logs/ Сега TensorBoard е стартиран и работи на порта по подразбиране 6006. След отваряне http://localhost:6006 и щраквайки върху елемента от менюто Графики (намиращ се в горната част на страницата), ще можете да видите графиката, като тази на снимката по-долу:
TensorBoard маркира константи и обобщаващи възли специфични символи, които са описани по-долу.
Математика с TensorFlow
Тензорите са основните структури от данни в TensorFlow и представляват свързващите ръбове в графика на потока от данни.
Тензор просто идентифицира многомерен масив или списък. Сензорната структура може да бъде идентифицирана с три параметъра: ранг, форма и тип.
- Ранг: Идентифицира броя на размерите на тензора. Рангът е известен като ред или n-измерения на тензор, където например тензор на ранг 1 е вектор или тензор на ранг 2 е матрица.
- Форма: Формата на тензор е броят на редовете и колоните, които има.
- Тип: Типът данни, присвоен на тензорни елементи.
За да изградим тензор в TensorFlow, можем да изградим n-измерен масив. Това може да стане лесно с помощта на библиотеката NumPy или чрез преобразуване на n-измерния масив на Python в тензор TensorFlow.
За да изградим 1-d тензор, ще използваме масив NumPy, който ще изградим, като предадем вграден списък на Python.
import numpy as np tensor_1d = np.array([1.45, -1, 0.2, 102.1]) Работата с този вид масив е подобна на работата с вграден списък на Python. Основната разлика е, че масивът NumPy съдържа и някои допълнителни свойства, като измерение, форма и тип.
> > print tensor1d [ 1.45 -1. 0.2 102.1 ] > > print tensor1d[0] 1.45 > > print tensor1d[2] 0.2 > > print tensor1d.ndim 1 > > print tensor1d.shape (4,) > > print tensor1d.dtype float64 Масивът NumPy може лесно да бъде преобразуван в тензор TensorFlow с помощната функция convert_to_tensor , което помага на разработчиците да преобразуват Python обекти в тензорни обекти. Тази функция приема тензорни обекти, масиви NumPy, списъци на Python и скалари на Python.
tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64) Сега, ако свържем нашия тензор със сесията TensorFlow, ще можем да видим резултатите от нашата конверсия.
tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64) with tf.Session() as session: print session.run(tensor) print session.run(tensor[0]) print session.run(tensor[1]) Изход:
[ 1.45 -1. 0.2 102.1 ] 1.45 -1.0 Можем да създадем 2-d тензор или матрица по подобен начин:
tensor_2d = np.array(np.random.rand(4, 4), dtype='float32') tensor_2d_1 = np.array(np.random.rand(4, 4), dtype='float32') tensor_2d_2 = np.array(np.random.rand(4, 4), dtype='float32') m1 = tf.convert_to_tensor(tensor_2d) m2 = tf.convert_to_tensor(tensor_2d_1) m3 = tf.convert_to_tensor(tensor_2d_2) mat_product = tf.matmul(m1, m2) mat_sum = tf.add(m2, m3) mat_det = tf.matrix_determinant(m3) with tf.Session() as session: print session.run(mat_product) print session.run(mat_sum) print session.run(mat_det) Тензорни операции
В горния пример въвеждаме няколко операции TensorFlow върху векторите и матриците. Операциите извършват определени изчисления на тензорите. Кои изчисления са това е показано в таблицата по-долу.
| Оператор TensorFlow | Описание |
|---|---|
| tf.add | x + y |
| tf.извадете | х-у |
| tf.умножете | х * у |
| tf.div | x / y |
| tf.mod | x% y |
| tf.abs | | x | |
| tf.отрицателно | -х |
| tf.sign | знак (x) |
| tf.квадрат | x * x |
| tf.round | кръг (x) |
| tf.sqrt | sqrt (x) |
| tf.pow | x ^ y |
| tf.exp | e ^ x |
| tf.log | дневник (x) |
| tf.максимум | макс (x, y) |
| tf.мин | мин (х, у) |
| tf.cos | cos (x) |
| tf.sin | грях (x) |
Операциите TensorFlow, изброени в таблицата по-горе, работят с тензорни обекти и се изпълняват по елементи. Така че, ако искате да изчислите косинуса за вектор x, операцията TensorFlow ще направи изчисления за всеки елемент в преминалия тензор.
tensor_1d = np.array([0, 0, 0]) tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64) with tf.Session() as session: print session.run(tf.cos(tensor)) Изход:
[ 1. 1. 1.] Матрични операции
Матричните операции са много важни за моделите на машинно обучение, като линейна регресия, тъй като те често се използват в тях. TensorFlow поддържа всички най-често срещани матрични операции, като умножение , транспониране , инвестиция , изчислявайки детерминанта , решаване линейни уравнения , и много повече .
След това ще обясним някои от матричните операции. Те са склонни да бъдат важни, когато става въпрос за модели на машинно обучение, като при линейна регресия. Нека напишем код, който ще извършва основни матрични операции като умножение, получаване на транспониране , получаване на детерминанта, умножение, sol и много други.
По-долу са дадени основни примери за извикване на тези операции.
import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) m1 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m2 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m3 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m4 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m5 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m_tranpose = tf.transpose(m1) m_mul = tf.matmul(m1, m2) m_det = tf.matrix_determinant(m3) m_inv = tf.matrix_inverse(m4) m_solve = tf.matrix_solve(m5, [[1], [1], [1], [1]]) with tf.Session() as session: print session.run(m_tranpose) print session.run(m_mul) print session.run(m_inv) print session.run(m_det) print session.run(m_solve) Трансформиране на данни
Намаляване
TensorFlow поддържа различни видове намаляване. Намаляването е операция, която премахва едно или повече измерения от тензор чрез извършване на определени операции в тези измерения. Списък на поддържаните намаления за текущата версия на TensorFlow можете да намерите тук. Ще представим няколко от тях в примера по-долу.
import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) x = convert( np.array( [ (1, 2, 3), (4, 5, 6), (7, 8, 9) ]), tf.int32) bool_tensor = convert([(True, False, True), (False, False, True), (True, False, False)], tf.bool) red_sum_0 = tf.reduce_sum(x) red_sum = tf.reduce_sum(x, axis=1) red_prod_0 = tf.reduce_prod(x) red_prod = tf.reduce_prod(x, axis=1) red_min_0 = tf.reduce_min(x) red_min = tf.reduce_min(x, axis=1) red_max_0 = tf.reduce_max(x) red_max = tf.reduce_max(x, axis=1) red_mean_0 = tf.reduce_mean(x) red_mean = tf.reduce_mean(x, axis=1) red_bool_all_0 = tf.reduce_all(bool_tensor) red_bool_all = tf.reduce_all(bool_tensor, axis=1) red_bool_any_0 = tf.reduce_any(bool_tensor) red_bool_any = tf.reduce_any(bool_tensor, axis=1) with tf.Session() as session: print 'Reduce sum without passed axis parameter: ', session.run(red_sum_0) print 'Reduce sum with passed axis=1: ', session.run(red_sum) print 'Reduce product without passed axis parameter: ', session.run(red_prod_0) print 'Reduce product with passed axis=1: ', session.run(red_prod) print 'Reduce min without passed axis parameter: ', session.run(red_min_0) print 'Reduce min with passed axis=1: ', session.run(red_min) print 'Reduce max without passed axis parameter: ', session.run(red_max_0) print 'Reduce max with passed axis=1: ', session.run(red_max) print 'Reduce mean without passed axis parameter: ', session.run(red_mean_0) print 'Reduce mean with passed axis=1: ', session.run(red_mean) print 'Reduce bool all without passed axis parameter: ', session.run(red_bool_all_0) print 'Reduce bool all with passed axis=1: ', session.run(red_bool_all) print 'Reduce bool any without passed axis parameter: ', session.run(red_bool_any_0) print 'Reduce bool any with passed axis=1: ', session.run(red_bool_any) Изход:
Reduce sum without passed axis parameter: 45 Reduce sum with passed axis=1: [ 6 15 24] Reduce product without passed axis parameter: 362880 Reduce product with passed axis=1: [ 6 120 504] Reduce min without passed axis parameter: 1 Reduce min with passed axis=1: [1 4 7] Reduce max without passed axis parameter: 9 Reduce max with passed axis=1: [3 6 9] Reduce mean without passed axis parameter: 5 Reduce mean with passed axis=1: [2 5 8] Reduce bool all without passed axis parameter: False Reduce bool all with passed axis=1: [False False False] Reduce bool any without passed axis parameter: True Reduce bool any with passed axis=1: [ True True True] Първият параметър на операторите за редукция е тензорът, който искаме да намалим. Вторият параметър са индексите на размерите, по които искаме да извършим намаляването. Този параметър не е задължителен и ако не бъде приет, намаляването ще се извърши по всички измерения.
Можем да разгледаме намаляване_сума операция. Преминаваме 2-d тензор и искаме да го намалим по размер 1.
В нашия случай получената сума ще бъде:
[1 + 2 + 3 = 6, 4 + 5 + 6 = 15, 7 + 8 + 9 = 24] Ако преминем измерение 0, резултатът ще бъде:
[1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 18] Ако не преминем нито една ос, резултатът е само общата сума от:
1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 45 Всички функции за намаляване имат подобен интерфейс и са изброени в TensorFlow документация за намаляване .
Сегментиране
Сегментирането е процес, при който едно от измеренията е процес на картографиране на измерения върху предоставени индекси на сегменти и получените елементи се определят от ред на индекса.
Сегментирането всъщност представлява групиране на елементите под повтарящи се индекси, така че например в нашия случай имаме сегментирани идентификатори [0, 0, 1, 2, 2] приложен върху тензор tens1, което означава, че първият и вторият масив ще бъдат преобразувани след операция по сегментиране (в нашия случай сумиране) и ще получат нов масив, който изглежда като (2, 8, 1, 0) = (2+0, 5+3, 3-2, -5+5) Третият елемент в тензора tens1 е недокоснат, защото не е групиран в нито един повтарящ се индекс, а последните два масива се сумират по същия начин, както беше в случая за първата група. Освен сумирането, TensorFlow поддържа продукт , означава , макс , и мин .
import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) seg_ids = tf.constant([0, 0, 1, 2, 2]) tens1 = convert(np.array([(2, 5, 3, -5), (0, 3, -2, 5), (4, 3, 5, 3), (6, 1, 4, 0), (6, 1, 4, 0)]), tf.int32) tens2 = convert(np.array([1, 2, 3, 4, 5]), tf.int32) seg_sum = tf.segment_sum(tens1, seg_ids) seg_sum_1 = tf.segment_sum(tens2, seg_ids) with tf.Session() as session: print 'Segmentation sum tens1: ', session.run(seg_sum) print 'Segmentation sum tens2: ', session.run(seg_sum_1) Segmentation sum tens1: [[ 2 8 1 0] [ 4 3 5 3] [12 2 8 0]] Segmentation sum tens2: [3 3 9] Помощни програми за последователност
Помощните програми за последователност включват методи като:
- argmin функция, която връща индекса с минимална стойност по осите на входния тензор,
- argmax функция, която връща индекса с максимална стойност по осите на входния тензор,
- setdiff , който изчислява разликата между два списъка с числа или низове,
- където функция, която ще върне елементи или от два предадени елемента x или y, което зависи от предаденото състояние, или
- единствен по рода си функция, която ще върне уникални елементи в 1-D тензор.
Демонстрираме няколко примера за изпълнение по-долу:
import numpy as np import tensorflow as tf def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) x = convert(np.array([ [2, 2, 1, 3], [4, 5, 6, -1], [0, 1, 1, -2], [6, 2, 3, 0] ])) y = convert(np.array([1, 2, 5, 3, 7])) z = convert(np.array([1, 0, 4, 6, 2])) arg_min = tf.argmin(x, 1) arg_max = tf.argmax(x, 1) unique = tf.unique(y) diff = tf.setdiff1d(y, z) with tf.Session() as session: print 'Argmin = ', session.run(arg_min) print 'Argmax = ', session.run(arg_max) print 'Unique_values = ', session.run(unique)[0] print 'Unique_idx = ', session.run(unique)[1] print 'Setdiff_values = ', session.run(diff)[0] print 'Setdiff_idx = ', session.run(diff)[1] print session.run(diff)[1] Изход:
Argmin = [2 3 3 3] Argmax = [3 2 1 0] Unique_values = [ 1. 2. 5. 3. 7.] Unique_idx = [0 1 2 3 4] Setdiff_values = [ 5. 3. 7.] Setdiff_idx = [2 3 4] Машинно обучение с TensorFlow
В този раздел ще представим случай на използване на машинно обучение с TensorFlow. Първият пример ще бъде алгоритъм за класифициране на данни с kNN подход, а вторият ще използва алгоритъм на линейна регресия .
kNN
Първият алгоритъм е k-Най-близките съседи (kNN). Това е контролиран алгоритъм за обучение, който използва показатели за разстояние, например Евклидово разстояние, за класифициране на данните спрямо обучението. Това е един от най-простите алгоритми, но все пак наистина мощен за класифициране на данни. Плюсове на този алгоритъм:
- Дава висока точност, когато тренировъчният модел е достатъчно голям, и
- Обикновено не е чувствителен към отклонения и не е необходимо да имаме каквито и да било предположения относно данните.
Недостатъци на този алгоритъм:
- Изчислително скъпи и
- Изисква много памет, където трябва да се добавят нови класифицирани данни към всички инстанции на първоначално обучение.
Разстоянието, което ще използваме в този примерен код, е евклидово, което определя разстоянието между две точки по следния начин:
В тази формула n е броят на размерите на пространството, x е векторът на данните за обучение и y е нова точка от данни, която искаме да класифицираме.
import os import numpy as np import tensorflow as tf ccf_train_data = 'train_dataset.csv' ccf_test_data = 'test_dataset.csv' dataset_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../datasets')) ccf_train_filepath = os.path.join(dataset_dir, ccf_train_data) ccf_test_filepath = os.path.join(dataset_dir, ccf_test_data) def load_data(filepath): from numpy import genfromtxt csv_data = genfromtxt(filepath, delimiter=',', skip_header=1) data = [] labels = [] for d in csv_data: data.append(d[:-1]) labels.append(d[-1]) return np.array(data), np.array(labels) train_dataset, train_labels = load_data(ccf_train_filepath) test_dataset, test_labels = load_data(ccf_test_filepath) train_pl = tf.placeholder('float', [None, 28]) test_pl = tf.placeholder('float', [28]) knn_prediction = tf.reduce_sum(tf.abs(tf.add(train_pl, tf.negative(test_pl))), axis=1) pred = tf.argmin(knn_prediction, 0) with tf.Session() as tf_session: missed = 0 for i in xrange(len(test_dataset)): knn_index = tf_session.run(pred, feed_dict={train_pl: train_dataset, test_pl: test_dataset[i]}) print 'Predicted class {} -- True class {}'.format(train_labels[knn_index], test_labels[i]) if train_labels[knn_index] != test_labels[i]: missed += 1 tf.summary.FileWriter('../samples/article/logs', tf_session.graph) print 'Missed: {} -- Total: {}'.format(missed, len(test_dataset)) Наборът от данни, който използвахме в горния пример, е такъв, който може да бъде намерен в Набори от данни Kaggle раздел. Използвахме един който съдържа транзакции, извършени от кредитни карти на европейски картодържатели. Използваме данните без никакво почистване или филтриране и според описанието в Kaggle за този набор от данни те са силно небалансирани. Наборът от данни съдържа 31 променливи: Време, V1,…, V28, Количество и Клас. В този примерен код използваме само V1, ..., V28 и Class. Класът обозначава транзакции, които са измамни с 1 и тези, които не са с 0.
Примерът на кода съдържа предимно нещата, които описахме в предишните раздели, с изключение, където въведохме функцията за зареждане на набор от данни. Функцията load_data(filepath) ще вземе CSV файл като аргумент и ще върне кортеж с данни и етикети, дефинирани в CSV.
Точно под тази функция имаме дефинирани резервоари за теста и обучени данни. Обучените данни се използват в модела за прогнозиране, за да се разрешат етикетите за входните данни, които трябва да бъдат класифицирани. В нашия случай kNN използва евклидово разстояние, за да получи най-близкия етикет.
Процентът на грешките може да бъде изчислен чрез просто разделяне с числото, когато класификатор е пропуснат от общия брой примери, който в нашия случай за този набор от данни е 0,2 (т.е. класификаторът ни дава грешен етикет за данни за 20% от тестовите данни).
Линейна регресия
Алгоритъмът на линейна регресия търси линейна връзка между две променливи. Ако обозначим зависимата променлива като y, а независимата променлива като x, тогава се опитваме да изчислим параметрите на функцията y = Wx + b
Линейната регресия е широко използван алгоритъм в областта на приложните науки. Този алгоритъм позволява да се добавят в изпълнение две важни концепции за машинно обучение: Функция на разходите и метод на градиентно спускане за намиране на минимума на функцията.
Алгоритъм за машинно обучение, реализиран с помощта на този метод, трябва да предсказва стойности на y като функция от x където алгоритъмът на линейна регресия ще определи стойности W и b, които всъщност са неизвестни и които се определят в рамките на тренировъчния процес. Избира се функция на разходите и обикновено се използва средната квадратна грешка, когато градиентното спускане е алгоритъмът за оптимизация, използван за намиране на локален минимум на функцията на разходите.
Методът на градиентно спускане е само локален минимум на функцията, но може да се използва при търсене на глобален минимум чрез произволно избиране на нова начална точка, след като е намерил локален минимум и повтаря този процес много пъти. Ако броят на минимумите на функцията е ограничен и има много голям брой опити, тогава има голям шанс в даден момент да бъде забелязан глобалният минимум. Още подробности за тази техника ще оставим за статия които споменахме в уводния раздел.
import tensorflow as tf import numpy as np test_data_size = 2000 iterations = 10000 learn_rate = 0.005 def generate_test_values(): train_x = [] train_y = [] for _ in xrange(test_data_size): x1 = np.random.rand() x2 = np.random.rand() x3 = np.random.rand() y_f = 2 * x1 + 3 * x2 + 7 * x3 + 4 train_x.append([x1, x2, x3]) train_y.append(y_f) return np.array(train_x), np.transpose([train_y]) x = tf.placeholder(tf.float32, [None, 3], name='x') W = tf.Variable(tf.zeros([3, 1]), name='W') b = tf.Variable(tf.zeros([1]), name='b') y = tf.placeholder(tf.float32, [None, 1]) model = tf.add(tf.matmul(x, W), b) cost = tf.reduce_mean(tf.square(y - model)) train = tf.train.GradientDescentOptimizer(learn_rate).minimize(cost) train_dataset, train_values = generate_test_values() init = tf.global_variables_initializer() with tf.Session() as session: session.run(init) for _ in xrange(iterations): session.run(train, feed_dict={ x: train_dataset, y: train_values }) print 'cost = {}'.format(session.run(cost, feed_dict={ x: train_dataset, y: train_values })) print 'W = {}'.format(session.run(W)) print 'b = {}'.format(session.run(b)) Изход:
cost = 3.1083032809e-05 W = [[ 1.99049103] [ 2.9887135 ] [ 6.98754263]] b = [ 4.01742554] В горния пример имаме две нови променливи, които нарекохме cost и train. С тези две променливи дефинирахме оптимизатор, който искаме да използваме в нашия модел на обучение и функцията, която искаме да сведем до минимум.
В края изходните параметри на W и b трябва да са идентични с тези, определени в generate_test_values функция. В ред 17 всъщност дефинирахме функция, която използвахме за генериране на линейни точки от данни за обучение, където w1=2, w2=3, w3=7 и b=4. Линейната регресия от горния пример е многовариантна, където се използват повече от една независима променлива.
Заключение
Както можете да видите от този урок за TensorFlow, TensorFlow е мощна рамка, която прави работата с математически изрази и многомерните масиви бриз - нещо фундаментално необходимо при машинното обучение. Той също така абстрахира сложността при изпълнение на графиките с данни и мащабиране.
С течение на времето TensorFlow нараства популярността си и сега се използва от разработчиците за решаване на проблеми, като се използват методи за дълбоко обучение за разпознаване на изображения, откриване на видео, обработка на текст като анализ на настроенията и др. Както всяка друга библиотека, може да ви е необходимо известно време, за да свикнете към концепциите, върху които е изграден TensorFlow. И след като го направите, с помощта на документация и подкрепа от общността, представянето на проблеми като графики на данни и решаването им с TensorFlow може да направи машинното обучение в мащаб по-малко досаден процес.
Разбиране на основите
Как се създават константите на TensorFlow?
В TensorFlow константите се създават с помощта на константната функция, която приема няколко параметъра: Стойност, dtype (тип данни), форма, име и (verify_shape) проверка на формата.
Какво представлява сесията TensorFlow?
Сесията капсулира контрола и състоянието на изпълнението на TensorFlow. Сесия без параметри ще използва графиката по подразбиране, създадена в текущата сесия, в противен случай класът на сесията приема параметър на графиката, който се използва в тази сесия, за да бъде изпълнен.
Какво е TensorBoard?
TensorBoard е инструмент за визуализация за анализ на графики на потока от данни. Това може да бъде полезно за по-добро разбиране на моделите за машинно обучение.
