Основы TensorFlow: тензор, форма, тип, сеансы и OperaTORs

Что такое Тензор?

Название 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.константа
  • tf.placeholder
  • tf.SparseTensor

В этом уроке вы узнаете, как создать tf.constant и tf.Variable.

Прежде чем мы пройдемся по руководству, убедитесь, что вы активировали среду conda с помощью TensorFlow. Мы назвали эту среду hello-tf.

Для пользователя MacOS:

source activate hello-tf

Что касается Windows Пользователь:

activate hello-tf

После того, как вы это сделаете, вы готовы импортировать тензорный поток.

# 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)

Создайте тензор n-мерности

# 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 столбца.

Чтобы создать массив из двух тензорных измерений, необходимо закрывать скобки после каждой строки. Посмотрите пример формы Keras Tensor ниже.

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

Матрица с тремя измерениями строится путем добавления еще одного уровня со скобками.

## 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. Вы можете создать тензор с тремя строками, заполненными единицами, с помощью следующего кода:

# 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(а, б)
  • tf.substract(а, б)
  • tf.multiply(а, б)
  • tf.div(а, б)
  • tf.pow(а, б)
  • tf.exp(а)
  • tf.sqrt(а)

Пример

# 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)

Сессия

TensorFlow работает вокруг трех основных компонентов:

  • График
  • тензор
  • Сессия
Компоненты Descritption
График Граф является фундаментальным в TensorFlow. Все математические операции (ops) выполняются внутри графа. Вы можете представить граф как проект, в котором выполняются все операции. Узлы представляют эти операции, они могут поглощать или создавать новые тензоры.
тензор Тензор представляет данные, которые перемещаются между операциями. Ранее вы видели, как инициализировать тензор. Разница между константой и переменной заключается в том, что начальные значения переменной со временем меняются.
Сессия Сеанс выполнит операцию из графа. Чтобы заполнить график значениями тензора, вам необходимо открыть сеанс. Внутри сеанса вы должны запустить оператор для создания вывода.

Графики и сессии независимы. Вы можете запустить сеанс и получить значения, которые можно использовать позже для дальнейших вычислений.

В примере ниже вы:

  • Создайте два тензора
  • Создать операцию
  • Открыть сеанс
  • Распечатать результат

Шаг 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 зависит от гениального подхода к рендерингу операции. Все вычисления представлены схемой потока данных. Граф потока данных был разработан для отслеживания зависимостей данных между отдельными операциями. Математическая формула или алгоритм состоят из ряда последовательных операций. График — это удобный способ визуализировать координацию вычислений.

На графике показано узел и край. Узел является представлением операции, т.е. единицей вычислений. Край — это тензор, он может создавать новый тензор или потреблять входные данные. Это зависит от зависимостей между отдельными операциями.

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

Посмотрим на пример.

Представьте, что вы хотите оценить следующую функцию:

График

TensorFlow создаст график для выполнения функции. График выглядит следующим образом:

Пример графика TensorFlow

Пример графика TensorFlow

Вы можете легко увидеть путь, по которому тензоры пройдут, чтобы достичь конечного пункта назначения.

Например, вы можете видеть, что операция добавления не может быть выполнена раньше и . График поясняет, что это будет:

  1. вычислить и:
  2. добавить 1) вместе
  3. добавить к 2)
  4. добавить 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.
  • Square: инициализировать постоянный тензор, называемый Square, с постоянным значением 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)

Создать оператор

Создать оператор объект
а + б tf.add(а, б)
а * б tf.multiply(а, б)

Создайте переменный тензор

Создать переменную объект
рандомизированное значение tf.get_variable("вар", [1, 2])
инициализировано первое значение tf.get_variable("var_init_2", dtype=tf.int32, инициализатор=[ [1, 2], [3, 4]])

Открыть сеанс

Сессия объект
Создать сеанс tf.Сессия()
Запустить сеанс tf.Session.run()
Оценка тензора имя_переменной.eval()
Закрыть сеанс сесс.закрыть()
Сессия по блоку с tf.Session() как sess: