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

by moiseevrus

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

Название 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 столбца.

Чтобы создать массив из 2-х тензорных измерений, нужно закрывать скобки после каждой строки. Проверьте пример формы 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.

Матрица с 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. Например, если вы хотите создать одномерный тензор с определенной формой 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: '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.добавить (а, б)
  • tf.substract (а, б)
  • tf.умножить (а, б)
  • tf.div(a, b)
  • tf.pow(a, b)
  • tf.exp(a)
  • 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 работает вокруг трех основных компонентов:

  • График
  • Тензор
  • Сессия
Составные части Описание
График Граф является фундаментальным в 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(): открыть сеанс. Все операции будут выполняться в рамках сессий
  • запустить (умножить): выполнить операцию, созданную на шаге 2.
  • print(result_1): Наконец, вы можете распечатать результат
  • close(): закрыть сеанс

Результат показывает 8, что является произведением x и y.

Другой способ создать сеанс — внутри блока. Преимущество в том, что он автоматически закрывает сеанс.

with tf.Session() as sess:    
result_2 = multiply.eval()
print(result_2)

Выход

1
[[1 2]
 [3 4]]
[[[1 2]  
  [3 4]  
  [5 6]]]

Переменные по умолчанию пусты, даже после создания тензора. Вам нужно инициализировать переменную, если вы хотите использовать переменную. Объект tf.global_variables_initializer() необходимо вызывать для инициализации значений переменной. Этот объект будет явно инициализировать все переменные. Это полезно перед обучением модели.

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

## Check the tensors created before
sess = tf.Session()
print(sess.run(r1))
print(sess.run(r2_matrix))
print(sess.run(r3_matrix))

Выход

[[-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

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

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

  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
  • квадрат: Инициализируйте постоянный тензор, называемый квадратом, с постоянным значением 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 работает:

  • График : вычислительная среда, содержащая операции и тензоры.
  • Тензоры : представляют данные (или значения), которые будут отображаться на графике. Это ребро в графе
  • Сеансы : разрешить выполнение операций

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

постоянный объект
Д0 tf.constant(1, tf.int16)
Д1 tf.constant([1,3,5], tf.int16)
Д2 tf.constant([[1, 2], [3, 4]], tf.int16)
Д3 tf.constant([[[1, 2],[3, 4], [5, 6]] ], tf.int16)

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

Создать оператора Объект
а+б tf.добавить (а, б)
а*б tf.умножить (а, б)

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

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

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

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


			
            
			        

You may also like

Leave a Comment