Какво е тензор в TensorFlow? Форма, тип и Operaтори

Какво е тензор?

Името TensorFlow се извлича директно от основния си обект: тензора. В TensorFlow всяко изчисление включва тензори. Тензорът е вектор или матрица с n измерения, която представлява всички типове данни. Всички стойности в тензора съдържат идентичен тип данни с известна (или частично известна) форма, а формата на данните е размерността на матрицата или масива.

Тензорът може да произлиза от входните данни или от резултата от изчисление. В TensorFlow всички операции се извършват в граф. Графът е набор от изчисления, които се извършват последователно. Всяка операция се нарича възел op, а възлите са свързани помежду си.

Графиката очертава операциите и връзките между възлите. Тя обаче не показва стойностите. Ръбът между възлите е тензорът, т.е. начин за попълване на операцията с данни.

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

Представяне на тензор

В 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.Variable
• tf.constant
• tf.placeholder
• tf.SparseTensor

В този урок ще научите как да създадете tf.constant и tf.Variable.

Едно нещо, което трябва да имате предвид, преди да изпълните кода: този урок следва оригиналния TensorFlow 1.x API, където първо се изгражда графика и се изпълнява по-късно в рамките на сесия. TensorFlow 2 работи бързо по подразбиране, така че няколко от символите по-долу бяха преместени или премахнати. Всеки един от тях все още е достъпен чрез tf.compat.v1 пространство от имена, а таблицата съпоставя всяко със съвременния му еквивалент.

Преди да преминете през урока, уверете се, че сте активирали 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)

Трите части на този изход се съпоставят с трите свойства на тензора, както става ясно от анотираната версия по-долу.

Можете също така да дадете на тензора свое собствено име с name аргумент.

# 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 1
r1_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. shape Имот.

По-долу конструирате матрица, запълнена с числата от 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-D тензор със специфична форма 10, запълнена с 0, можете да изпълните кода по-долу:

# 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: &#x27;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: &#x27;float32'>
<dtype: &#x27;int32'>

TensorFlow избира типа данни автоматично, когато аргументът не е зададен по време на създаването на тензора. TensorFlow отгатва най-вероятния тип данни: ако например подадете текст, той заключава, че е низ.

Създаване OperaTor

Някои полезни TensorFlow Operaтори

Знаете как да създадете тензор с 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.subtract(a, b)
• tf.multiply(a, b)
• tf.divide(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)

Code Обяснение

Създайте два тензора:

• един тензор с 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 matrix
tensor_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)

Сесия

TensorFlow работи около 3 основни компонента:

• Крива
• Тензор
• Сесия

Графиките и сесиите са независими. Можете да стартирате сесия и да запазите стойностите за по-нататъшни изчисления по-късно.

В примера по-долу ще:

• Създайте два тензора
• Създайте операция
• Отворете сесия
• Отпечатайте резултата

Стъпка 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]

Code обяснение

• 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.

Code Обяснение

• import numpy as 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 рендира всяка операция със схема на потока от данни. Графиката на потока от данни е проектирана да показва зависимостите на данните между отделните операции. Математическата формула или алгоритъм е съставен от редица последователни операции, а графиката е удобен начин за визуализиране на това как тези изчисления са координирани.

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

Структурата на графиката свързва операциите (т.е. възлите) заедно и показва как всяка една от тях се захранва. Обърнете внимание, че графиката не показва резултата от операциите; тя само помага за визуализиране на връзките между тях.

Нека видим пример. Представете си, че искате да оцените следната функция:

TensorFlow изгражда графика за изпълнение на функцията. Графиката изглежда така:

Можете лесно да видите пътя, по който тензорите ще стигнат до крайната дестинация.

Например, add възелът не може да се изпълни преди и двата Mul намлява Pow са дали своите резултати. Графиката показва, че TensorFlow ще:

1. изчислете x·z в Mul възел и x² в Pow възел
2. добавете тези два резултата заедно в add възел
3. добавете z към тази сума в add_1 възел
4. добавете константата 5 в add_2 възел

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

Code Обяснение

• x: Инициализирайте променлива, наречена x, с постоянна стойност 5
• z: Инициализирайте променлива, наречена z, с постоянна стойност 6
• c: Инициализирайте постоянен тензор, наречен c, с постоянна стойност 5
• квадрат: Инициализирайте постоянен тензор, наречен квадрат с постоянна стойност 2
• f: Конструирайте оператора

В този пример стойностите на променливите се поддържат фиксирани. Константният тензор c е константният параметър във функцията f и приема фиксирана стойност от 5; на графиката можете да видите този параметър в тензора, наречен константа.

Създаден е и постоянен тензор за степента в оператора tf.pow()Не е необходимо, но означава, че експонентата се появява в графиката като кръг, наречен квадрат.

От графиката можете да проследите какво се случва с тензорите и защо функцията връща 66: 5 × 6 плюс 5² плюс 6 плюс 5 е равно на 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

Четирите таблици по-долу събират всяка команда, използвана в този урок, така че можете да потърсите някоя от тях, без да превъртате назад през примерите.

Създайте постоянен тензор

Създайте оператор

Създайте променлив тензор

Отворете сесия

Въпроси и Отговори