Основи TensorFlow: тензор, форма, тип, сеанси та Operaторс
Евелін Кларк
Що таке тензор?
Назва Tensorflow безпосередньо походить від його основної структури: Tensor. У Tensorflow усі обчислення використовують тензори. Тензор — це вектор або матриця n-вимірності, яка представляє всі типи даних. Усі значення в тензорі містять ідентичний тип даних із відомою (або частково відомою) формою. Форма даних - це розмірність матриці або масиву.
Тензор може бути створений із вхідних даних або результату обчислення. У TensorFlow усі операції виконуються всередині графа. Графік — це набір обчислень, які виконуються послідовно. Кожна операція називається операційним вузлом і пов’язана одна з одною.
На графіку показано операції та зв’язки між вузлами. Однак він не відображає значення. Краєм вузлів є тензор, тобто спосіб заповнення операції даними.
У машинному навчанні моделі є каналом зі списком об’єктів, які називаються векторами ознак. Вектор ознак може мати будь-який тип даних. Вектор ознак зазвичай буде основним входом для заповнення тензора. Ці значення надходитимуть до операційного вузла через тензор, а результат цієї операції/обчислення створить новий тензор, який, у свою чергу, буде використано в новій операції. Усі ці операції можна переглянути на графіку.
Представлення тензора
У TensorFlow тензор — це набір векторів ознак (тобто масив) n-вимірів. Наприклад, якщо у нас є матриця 2×3 зі значеннями від 1 до 6, ми пишемо:
TensorFlow представляє цю матрицю як:
[[1, 2, 3], [4, 5, 6]]
Якщо створити тривимірну матрицю зі значеннями від 1 до 8, ми матимемо:
TensorFlow представляє цю матрицю як:
[ [[1, 2],
[[3, 4],
[[5, 6],
[[7,8] ]
Примітка: Тензор може бути представлений за допомогою скаляра або може мати форму більш ніж трьох вимірів. Просто візуалізувати вищий рівень розмірності складніше.
Типи тензора
У TensorFlow усі обчислення проходять через один або декілька тензорів. tf.tensor — це об’єкт із трьома властивостями:
- Унікальна мітка (назва)
- Розмір (форма)
- Тип даних (dtype)
Кожна операція, яку ви виконуватимете з TensorFlow, передбачає маніпулювання тензором. Ви можете створити чотири основні типи тензорів:
- tf.Змінна
- tf.constant
- tf.placeholder
- tf.SparseTensor
У цьому посібнику ви дізнаєтеся, як створити tf.constant і tf.Variable.
Перш ніж ми пройдемо підручник, переконайтеся, що ви активували середовище conda за допомогою TensorFlow. Ми назвали це середовище hello-tf.
Для користувача MacOS:
source activate hello-tf
для Windows користувач:
activate hello-tf
Після цього ви готові імпортувати tensorflow
# Import tf import tensorflow as tf
Створіть тензор n-вимірності
Ви починаєте зі створення тензора з одним виміром, а саме скаляра.
Щоб створити тензор, ви можете використовувати tf.constant(), як показано в наведеному нижче прикладі форми тензора TensorFlow:
tf.constant(value, dtype, name = "")
arguments
- `value`: Value of n dimension to define the tensor. Optional
- `dtype`: Define the type of data:
- `tf.string`: String variable
- `tf.float32`: Float variable
- `tf.int16`: Integer variable
- "name": Name of the tensor. Optional. By default, `Const_1:0`
Щоб створити тензор розмірності 0, запустіть наступний код
## rank 0 # Default name r1 = tf.constant(1, tf.int16) print(r1)
Вихід
Tensor("Const:0", shape=(), dtype=int16)
# Named my_scalar r2 = tf.constant(1, tf.int16, name = "my_scalar") print(r2)
Вихід
Tensor("my_scalar:0", shape=(), dtype=int16)
Кожен тензор відображається за назвою тензора. Кожен об’єкт тензора визначається такими атрибутами тензора, як унікальна мітка (ім’я), розмір (форма) і типи даних TensorFlow (dtype).
Ви можете визначити тензор з десятковими значеннями або з рядком, змінивши тип даних.
# Decimal
r1_decimal = tf.constant(1.12345, tf.float32)
print(r1_decimal)
# String
r1_string = tf.constant("Guru99", tf.string)
print(r1_string)
Вихід
Tensor("Const_1:0", shape=(), dtype=float32)
Tensor("Const_2:0", shape=(), dtype=string)
Тензор розмірності 1 можна створити так:
## Rank 1r1_vector = tf.constant([1,3,5], tf.int16) print(r1_vector) r2_boolean = tf.constant([True, True, False], tf.bool) print(r2_boolean)
Вихід
Tensor("Const_3:0", shape=(3,), dtype=int16)
Tensor("Const_4:0", shape=(3,), dtype=bool)
Ви можете помітити, що форма TensorFlow складається лише з 1 стовпця.
Щоб створити масив із 2 вимірів тензора, вам потрібно закрити дужки після кожного рядка. Перегляньте приклад форми тензора Кераса нижче
## Rank 2
r2_matrix = tf.constant([ [1, 2],
[3, 4] ],tf.int16)
print(r2_matrix)
Вихід
Tensor("Const_5:0", shape=(2, 2), dtype=int16)
Матриця має 2 рядки та 2 стовпці, заповнені значеннями 1, 2, 3, 4.
Матриця з 3 вимірами будується шляхом додавання ще одного рівня за допомогою дужок.
## Rank 3
r3_matrix = tf.constant([ [[1, 2],
[3, 4],
[5, 6]] ], tf.int16)
print(r3_matrix)
Вихід
Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16)
Матриця виглядає як на малюнку два.
Форма тензора
Коли ви друкуєте тензор, TensorFlow вгадує форму. Однак ви можете отримати форму тензора за допомогою властивості форми TensorFlow.
Нижче ви будуєте матрицю, заповнену числом від 10 до 15, і перевіряєте форму m_shape
# Shape of tensor
m_shape = tf.constant([ [10, 11],
[12, 13],
[14, 15] ]
)
m_shape.shape
Вихід
TensorShape([Dimension(3), Dimension(2)])
Матриця має 3 рядки і 2 стовпці.
У TensorFlow є корисні команди для створення вектора або матриці, заповненої 0 або 1. Наприклад, якщо ви хочете створити одновимірний тензор із певною формою 1, заповненою 10, ви можете запустити код нижче:
# Create a vector of 0 print(tf.zeros(10))
Вихід
Tensor("zeros:0", shape=(10,), dtype=float32)
Властивість також працює для матриці. Тут ви створюєте матрицю 10×10 із заповненням 1
# Create a vector of 1 print(tf.ones([10, 10]))
Вихід
Tensor("ones:0", shape=(10, 10), dtype=float32)
Ви можете використовувати форму даної матриці, щоб створити вектор одиниць. Матриця m_shape має розміри 3×2. Ви можете створити тензор із 3 рядками, заповненими одиницею, за допомогою такого коду:
# Create a vector of ones with the same number of rows as m_shape print(tf.ones(m_shape.shape[0]))
Вихід
Tensor("ones_1:0", shape=(3,), dtype=float32)
Якщо передати значення 1 у квадратні дужки, можна побудувати вектор одиниць, що дорівнює кількості стовпців у матриці m_shape.
# Create a vector of ones with the same number of column as m_shape print(tf.ones(m_shape.shape[1]))
Вихід
Tensor("ones_2:0", shape=(2,), dtype=float32)
Нарешті, ви можете створити матрицю 3×2 лише з одиницями
print(tf.ones(m_shape.shape))
Вихід
Tensor("ones_3:0", shape=(3, 2), dtype=float32)
Тип даних
Другою властивістю тензора є тип даних. Тензор може мати лише один тип даних одночасно. Тензор може мати лише один тип даних. Ви можете повернути тип за допомогою властивості dtype.
print(m_shape.dtype)
Вихід
<dtype: 'int32'>
У деяких випадках потрібно змінити тип даних. У TensorFlow це можливо за допомогою методу tf.cast.
Приклад
Нижче тензор з плаваючою точкою перетворюється на ціле за допомогою використання методу cast.
# Change type of data type_float = tf.constant(3.123456789, tf.float32) type_int = tf.cast(type_float, dtype=tf.int32) print(type_float.dtype) print(type_int.dtype)
Вихід
<dtype: 'float32'> <dtype: 'int32'>
TensorFlow автоматично вибирає тип даних, якщо аргумент не вказано під час створення тензора. TensorFlow вгадає, які типи даних є найбільш імовірними. Наприклад, якщо ви передаєте текст, він вгадає, що це рядок, і перетворить його на рядок.
Оператор створення
Деякі корисні оператори TensorFlow
Ви знаєте, як створити тензор за допомогою TensorFlow. Настав час навчитися виконувати математичні дії.
TensorFlow містить усі основні операції. Можна почати з простого. Ви будете використовувати метод TensorFlow для обчислення квадрата числа. Ця операція є простою, оскільки для побудови тензора потрібен лише один аргумент.
Квадрат числа будується за допомогою tf.sqrt(x), де x є плаваючим числом.
x = tf.constant([2.0], dtype = tf.float32) print(tf.sqrt(x))
Вихід
Tensor("Sqrt:0", shape=(1,), dtype=float32)
Примітка: Вихідні дані повернули об’єкт тензора, а не результат квадрату 2. У прикладі ви друкуєте визначення тензора, а не фактичну оцінку операції. У наступному розділі ви дізнаєтесь, як працює TensorFlow для виконання операцій.
Нижче наведено список операцій, які зазвичай використовуються. Ідея та сама. Кожна операція вимагає одного або кількох аргументів.
- tf.add(a, b)
- tf.substract(a, b)
- tf.multiply(a, b)
- tf.div(a, b)
- tf.pow(a, b)
- tf.exp(a)
- tf.sqrt(a)
Приклад
# Add tensor_a = tf.constant([[1,2]], dtype = tf.int32) tensor_b = tf.constant([[3, 4]], dtype = tf.int32) tensor_add = tf.add(tensor_a, tensor_b)print(tensor_add)
Вихід
Tensor("Add:0", shape=(1, 2), dtype=int32)
Пояснення коду
Створіть два тензори:
- один тензор з 1 і 2
- один тензор з 3 і 4
Ви складаєте обидва тензори.
повідомлення: обидва тензори повинні мати однакову форму. Ви можете виконати множення над двома тензорами.
# Multiply tensor_multiply = tf.multiply(tensor_a, tensor_b) print(tensor_multiply)
Вихід
Tensor("Mul:0", shape=(1, 2), dtype=int32)
Змінні
Поки що ви створили лише постійні тензори. Це не приносить великої користі. Дані завжди надходять з різними значеннями, щоб зафіксувати це, ви можете використовувати клас Variable. Він представлятиме вузол, де значення завжди змінюються.
Щоб створити змінну, ви можете використовувати метод tf.get_variable().
tf.get_variable(name = "", values, dtype, initializer) argument - `name = ""`: Name of the variable - `values`: Dimension of the tensor - `dtype`: Type of data. Optional - `initializer`: How to initialize the tensor. Optional If initializer is specified, there is no need to include the `values` as the shape of `initializer` is used.
Наприклад, наведений нижче код створює двовимірну змінну з двома випадковими значеннями. За замовчуванням TensorFlow повертає випадкове значення. Ви називаєте змінну var
# Create a Variable
## Create 2 Randomized values
var = tf.get_variable("var", [1, 2])
print(var.shape)
Вихід
(1, 2)
У другому прикладі ви створюєте змінну з одним рядком і двома стовпцями. Вам потрібно використовувати [1,2], щоб створити розмірність змінної
Початкові значення цього тензора дорівнюють нулю. Наприклад, коли ви навчаєте модель, вам потрібно мати початкові значення, щоб обчислити вагу функцій. Нижче ви встановлюєте ці початкові значення на нуль.
var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32, initializer=tf.zeros_initializer)
print(var_init_1.shape)
Вихід
(1, 2)
Ви можете передати значення постійного тензора в змінну. Ви створюєте постійний тензор за допомогою методу tf.constant(). Ви використовуєте цей тензор для ініціалізації змінної.
Перші значення змінної — 10, 20, 30 і 40. Новий тензор матиме форму 2×2.
# Create a 2x2 matrixtensor_const = tf.constant([[10, 20],
[30, 40]])
# Initialize the first value of the tensor equals to tensor_const
var_init_2 = tf.get_variable("var_init_2", dtype=tf.int32, initializer=tensor_const)
print(var_init_2.shape)
Вихід
(2, 2)
Заповнювач
Заповнювач призначений для живлення тензора. Заповнювач використовується для ініціалізації потоку даних усередині тензорів. Щоб поставити заповнювач, потрібно використати метод feed_dict. Заповнювач буде подано лише протягом сеансу.
У наступному прикладі ви побачите, як створити заповнювач за допомогою методу tf.placeholder. У наступному занятті ви навчитеся заповнювати заповнювач фактичним значенням тензора.
Синтаксис:
tf.placeholder(dtype,shape=None,name=None ) arguments: - `dtype`: Type of data - `shape`: dimension of the placeholder. Optional. By default, shape of the data - `name`: Name of the placeholder. Optional data_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a") print(data_placeholder_a)
Вихід
Tensor("data_placeholder_a:0", dtype=float32)
Session
TensorFlow працює навколо 3 основних компонентів:
- Графік
- Тензор
- Session
| компоненти | Опис |
|---|---|
| Графік | Графік є фундаментальним у TensorFlow. Усі математичні операції (ops) виконуються всередині графа. Ви можете уявити собі графік як проект, у якому виконуються всі операції. Вузли представляють ці операції, вони можуть поглинати або створювати нові тензори. |
| Тензор | Тензор представляє дані, які переходять між операціями. Раніше ви бачили, як ініціалізувати тензор. Різниця між константою та змінною полягає в тому, що початкові значення змінної змінюватимуться з часом. |
| Session | Сеанс виконає операцію з графіка. Щоб наповнити графік значеннями тензора, потрібно відкрити сеанс. Усередині сеансу ви повинні запустити оператор, щоб створити вихід. |
Графіки та сесії незалежні. Ви можете запустити сеанс і отримати значення для подальших обчислень.
У прикладі нижче ви:
- Створіть два тензори
- Створіть операцію
- Відкрийте сеанс
- Роздрукуйте результат
Крок 1) Ви створюєте два тензори x і y
## Create, run and evaluate a session x = tf.constant([2]) y = tf.constant([4])
Крок 2) Ви створюєте оператор шляхом множення x і y
## Create operator multiply = tf.multiply(x, y)
Крок 3) Ви відкриваєте сеанс. Усі обчислення відбуватимуться протягом сесії. Коли ви закінчите, вам потрібно закрити сеанс.
## Create a session to run the code sess = tf.Session()result_1 = sess.run(multiply) print(result_1) sess.close()
Вихід
[8]
Пояснення коду
- tf.Session(): відкрити сеанс. Усі операції відбуватимуться в межах сеансів
- run(multiply): виконати операцію, створену на кроці 2.
- print(result_1): Нарешті, ви можете надрукувати результат
- close(): Закрити сеанс
Результат показує 8, що є множенням x і y.
Ще один спосіб створити сеанс – усередині блоку. Перевагою є автоматичне закриття сесії.
with tf.Session() as sess: result_2 = multiply.eval() print(result_2)
Вихід
[8]
У контексті сеансу ви можете використовувати метод eval() для виконання операції. Це еквівалентно run(). Це робить код більш читабельним.
Ви можете створити сеанс і побачити значення всередині тензорів, які ви створили на даний момент.
## Check the tensors created before sess = tf.Session() print(sess.run(r1)) print(sess.run(r2_matrix)) print(sess.run(r3_matrix))
Вихід
1 [[1 2] [3 4]] [[[1 2] [3 4] [5 6]]]
За замовчуванням змінні порожні, навіть після того, як ви створили тензор. Вам потрібно ініціалізувати змінну, якщо ви хочете використовувати змінну. Для ініціалізації значень змінної необхідно викликати об’єкт tf.global_variables_initializer(). Цей об’єкт явно ініціалізує всі змінні. Це корисно перед навчанням моделі.
Ви можете перевірити значення змінних, які ви створили раніше. Зверніть увагу, що вам потрібно використовувати run для оцінки тензора
sess.run(tf.global_variables_initializer()) print(sess.run(var)) print(sess.run(var_init_1)) print(sess.run(var_init_2))
Вихід
[[-0.05356491 0.75867283]] [[0 0]] [[10 20] [30 40]]
Ви можете використати заповнювач, який ви створили раніше, і додати йому фактичне значення. Вам потрібно передати дані в метод feed_dict.
Наприклад, ви візьмете ступінь 2 заповнювача data_placeholder_a.
import numpy as np
power_a = tf.pow(data_placeholder_a, 2)
with tf.Session() as sess:
data = np.random.rand(1, 10)
print(sess.run(power_a, feed_dict={data_placeholder_a: data})) # Will succeed.
Пояснення коду
- імпортувати numpy як np: імпортувати бібліотека numpy щоб створити дані
- tf.pow(data_placeholder_a, 2): Створення операцій
- np.random.rand(1, 10): Створити випадковий масив даних
- feed_dict={data_placeholder_a: data}: Заповнити заповнювач даними
Вихід
[[0.05478134 0.27213147 0.8803037 0.0398424 0.21172127 0.01444725 0.02584014 0.3763949 0.66022706 0.7565559 ]]
Графік
TensorFlow залежить від геніального підходу до візуалізації операції. Усі обчислення представлені схемою потоку даних. Графік потоку даних було розроблено, щоб побачити залежності даних між окремими операціями. Математична формула або алгоритм складаються з ряду послідовних операцій. Графік — це зручний спосіб візуалізації координації обчислень.
Графік показує a вузол і край. Вузол є представленням операції, тобто одиницею обчислення. Ребро є тензором, воно може створити новий тензор або споживати вхідні дані. Це залежить від залежності між окремими операціями.
Структура графа з’єднує операції (тобто вузли) і те, як ці операції подаються. Зауважте, що графік не відображає результати операцій, він лише допомагає візуалізувати зв’язок між окремими операціями.
Подивимось приклад.
Уявіть, що ви хочете оцінити таку функцію:
TensorFlow створить графік для виконання функції. Графік виглядає так:
Ви можете легко побачити шлях, яким тензори пройдуть до кінцевого пункту призначення.
Наприклад, ви бачите, що операція add не може бути виконана раніше і . Графік пояснює, що це:
- обчислити і:
- додати 1) разом
- додати до 2)
- додати 3) до
x = tf.get_variable("x", dtype=tf.int32, initializer=tf.constant([5]))
z = tf.get_variable("z", dtype=tf.int32, initializer=tf.constant([6]))
c = tf.constant([5], name = "constant")square = tf.constant([2], name = "square")
f = tf.multiply(x, z) + tf.pow(x, square) + z + c
Пояснення коду
- x: Ініціалізація змінної під назвою x постійним значенням 5
- z: Ініціалізація змінної під назвою z постійним значенням 6
- c: ініціалізувати постійний тензор під назвою c постійним значенням 5
- квадрат: ініціалізуйте постійний тензор під назвою квадрат із постійним значенням 2
- f: Побудуйте оператор
У цьому прикладі ми вирішили залишити значення змінних фіксованими. Ми також створили постійний тензор c, який є постійним параметром у функції f. Він приймає фіксоване значення 5. На графіку ви можете побачити цей параметр у тензорі, що називається константою.
Ми також побудували постійний тензор для степеня в операторі tf.pow(). Це не обов'язково. Ми зробили це для того, щоб ви могли бачити назву тензора на графіку. Це коло, яке називають квадратом.
З графіка ви можете зрозуміти, що станеться з тензорами та як вони можуть повернути результат 66.
Наведений нижче код оцінює функцію під час сеансу.
init = tf.global_variables_initializer() # prepare to initialize all variables
with tf.Session() as sess:
init.run() # Initialize x and y
function_result = f.eval()
print(function_result)
Вихід
[66]
Підсумки
TensorFlow працює навколо:
- Графік: обчислювальне середовище, що містить операції та тензори
- Тензори: представляє дані (або значення), які відображатимуться на графіку. Це ребро на графіку
- Сеанси: Дозволити виконання операцій
Створіть постійний тензор
| постійна | об'єкт |
|---|---|
| D0 | tf.constant(1, tf.int16) |
| D1 | tf.constant([1,3,5], tf.int16) |
| D2 | tf.constant([ [1, 2], [3, 4] ],tf.int16) |
| D3 | tf.constant([ [[1, 2],[3, 4], [5, 6]] ], tf.int16) |
Створіть оператор
| Створіть оператор | Об'єкт |
|---|---|
| a + b | tf.add(a, b) |
| a * b | tf.multiply(a, b) |
Створіть тензор змінної
| Створіть змінну | об'єкт |
|---|---|
| рандомізоване значення | tf.get_variable(“перемінна”, [1, 2]) |
| ініціалізоване перше значення | tf.get_variable(“var_init_2”, dtype=tf.int32, initializer=[ [1, 2], [3, 4] ]) |
Відкрийте сеанс
| Session | об'єкт |
|---|---|
| Створити сеанс | tf.Session () |
| Запустити сеанс | tf.Session.run() |
| Оцініть тензор | variable_name.eval() |
| Закрити сеанс | sess.close() |
| Сеанс за блоком | з tf.Session() як sess: |
