TensorFlow Basics: Tensor, Shape, Type, Sessions & Operadores

O que é um tensor?

O nome do Tensorflow é derivado diretamente de sua estrutura principal: Tensor. No Tensorflow, todos os cálculos envolvem tensores. Um tensor é um vetor ou matriz de n-dimensões que representa todos os tipos de dados. Todos os valores em um tensor contêm tipos de dados idênticos com uma forma conhecida (ou parcialmente conhecida). A forma dos dados é a dimensionalidade da matriz ou array.

Um tensor pode ser originado dos dados de entrada ou do resultado de um cálculo. No TensorFlow, todas as operações são conduzidas dentro de um gráfico. O gráfico é um conjunto de cálculos que ocorre sucessivamente. Cada operação é chamada de nó operacional e estão conectadas entre si.

O gráfico descreve as operações e conexões entre os nós. No entanto, ele não exibe os valores. A borda dos nós é o tensor, ou seja, uma forma de preencher a operação com dados.

No aprendizado de máquina, os modelos são alimentados com uma lista de objetos chamados vetores de recursos. Um vetor de recurso pode ser de qualquer tipo de dados. O vetor de recursos geralmente será a entrada principal para preencher um tensor. Esses valores fluirão para um nó op por meio do tensor e o resultado dessa operação / cálculo criará um novo tensor que, por sua vez, será usado em uma nova operação. Todas essas operações podem ser visualizadas no gráfico.

Neste tutorial, você aprenderá noções básicas do TensorFlow como-

• O que é um tensor?
• Representação de um Tensor
• Tipos de tensor
• Crie um tensor de n-dimensão
• Forma do tensor
• Tipo de dados
• Criando operador
• Alguns operadores úteis do TensorFlow
• Variáveis
• Placeholder
• Sessão
• Gráfico

Representação de um Tensor

No TensorFlow, um tensor é uma coleção de vetores de recursos (ou seja, matriz) de n dimensões. Por exemplo, se temos uma matriz 2x3 com valores de 1 a 6, escrevemos:

Representação de um Tensor

TensorFlow representa essa matriz como:

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

Se criarmos uma matriz tridimensional com valores de 1 a 8, temos:

TensorFlow representa essa matriz como:

[ [[1, 2],[[3, 4],[[5, 6],[[7,8] ] 

Nota: Um tensor pode ser representado com um escalar ou pode ter uma forma de mais de três dimensões. É apenas mais complicado visualizar o nível de dimensão superior.

Tipos de tensor

No TensorFlow, todos os cálculos passam por um ou mais tensores. Um tf.tensor é um objeto com três propriedades:

• Um rótulo exclusivo (nome)
• Uma dimensão (forma)
• Um tipo de dados (dtype)

Cada operação que você fará com o TensorFlow envolve a manipulação de um tensor. Existem quatro tipos principais de tensor que você pode criar:

• tf.Variable
• tf.constant
• tf.placeholder
• tf.SparseTensor

Neste tutorial, você aprenderá como criar um tf.constant e um tf.Variable.

Antes de prosseguirmos com o tutorial, certifique-se de ativar o ambiente conda com TensorFlow. Chamamos esse ambiente de hello-tf.

Para usuário MacOS:

source activate hello-tf 

Para usuário do Windows:

activate hello-tf 

Depois de fazer isso, você está pronto para importar tensorflow

# Import tfimport tensorflow as tf 

Crie um tensor de n-dimensão

Você começa com a criação de um tensor com uma dimensão, a saber, um escalar.

Para criar um tensor, você pode usar tf.constant () conforme mostrado no exemplo de forma de tensor do TensorFlow abaixo:

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` 

Para criar um tensor de dimensão 0, execute o seguinte código

## rank 0# Default namer1 = tf.constant(1, tf.int16)print(r1)

Resultado

Tensor("Const:0", shape=(), dtype=int16) 

# Named my_scalarr2 = tf.constant(1, tf.int16, name = "my_scalar")print(r2) 

Resultado

Tensor("my_scalar:0", shape=(), dtype=int16) 

Cada tensor é exibido pelo nome do tensor. Cada objeto tensor é definido com atributos tensor como um rótulo exclusivo (nome), uma dimensão (forma) e tipos de dados TensorFlow (dtype).

Você pode definir um tensor com valores decimais ou com uma string, alterando o tipo de dados.

# Decimalr1_decimal = tf.constant(1.12345, tf.float32)print(r1_decimal)# Stringr1_string = tf.constant("Guru99", tf.string)print(r1_string) 

Resultado

Tensor("Const_1:0", shape=(), dtype=float32)Tensor("Const_2:0", shape=(), dtype=string) 

Um tensor de dimensão 1 pode ser criado da seguinte forma:

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

Resultado

Tensor("Const_3:0", shape=(3,), dtype=int16)Tensor("Const_4:0", shape=(3,), dtype=bool) 

Você pode notar que a forma do TensorFlow é composta apenas por 1 coluna.

Para criar uma matriz de 2 dimensões de tensor, você precisa fechar os colchetes após cada linha. Verifique o exemplo de forma do Tensor Keras abaixo

## Rank 2r2_matrix = tf.constant([ [1, 2],[3, 4] ],tf.int16)print(r2_matrix) 

Resultado

Tensor("Const_5:0", shape=(2, 2), dtype=int16) 

A matriz possui 2 linhas e 2 colunas preenchidas com os valores 1, 2, 3, 4.

Uma matriz com 3 dimensões é construída adicionando outro nível com os colchetes.

## Rank 3r3_matrix = tf.constant([ [[1, 2],[3, 4],[5, 6]] ], tf.int16)print(r3_matrix) 

Resultado

Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16) 

A matriz se parece com a imagem dois.

Forma do tensor

Quando você imprime o tensor, o TensorFlow adivinha a forma. No entanto, você pode obter a forma do tensor com a propriedade de forma do TensorFlow.

Abaixo, você constrói uma matriz preenchida com um número de 10 a 15 e verifica a forma de m_shape

# Shape of tensorm_shape = tf.constant([ [10, 11],[12, 13],[14, 15] ])m_shape.shape 

Resultado

TensorShape([Dimension(3), Dimension(2)]) 

A matriz possui 3 linhas e 2 colunas.

O TensorFlow tem comandos úteis para criar um vetor ou uma matriz preenchida com 0 ou 1. Por exemplo, se você deseja criar um tensor 1-D com uma forma específica de 10, preenchido com 0, você pode executar o código abaixo:

# Create a vector of 0print(tf.zeros(10)) 

Resultado

Tensor("zeros:0", shape=(10,), dtype=float32) 

O imóvel funciona para matriz também. Aqui, você cria uma matriz 10x10 preenchida com 1

# Create a vector of 1print(tf.ones([10, 10])) 

Resultado

Tensor("ones:0", shape=(10, 10), dtype=float32) 

Você pode usar a forma de uma determinada matriz para fazer um vetor de uns. A matriz m_shape é uma dimensão 3x2. Você pode criar um tensor com 3 linhas preenchidas por um com o seguinte código:

# Create a vector of ones with the same number of rows as m_shapeprint(tf.ones(m_shape.shape[0])) 

Resultado

Tensor("ones_1:0", shape=(3,), dtype=float32) 

Se você passar o valor 1 para o colchete, você pode construir um vetor de uns igual ao número de colunas na matriz forma_m.

# Create a vector of ones with the same number of column as m_shapeprint(tf.ones(m_shape.shape[1])) 

Resultado

Tensor("ones_2:0", shape=(2,), dtype=float32) 

Finalmente, você pode criar uma matriz 3x2 com apenas um

print(tf.ones(m_shape.shape)) 

Resultado

Tensor("ones_3:0", shape=(3, 2), dtype=float32) 

Tipo de dados

A segunda propriedade de um tensor é o tipo de dado. Um tensor pode ter apenas um tipo de dados por vez. Um tensor pode ter apenas um tipo de dados. Você pode retornar o tipo com a propriedade dtype.

print(m_shape.dtype) 

Resultado

Em algumas ocasiões, você deseja alterar o tipo de dados. No TensorFlow, isso é possível com o método tf.cast.

Exemplo

Abaixo, um tensor float é convertido em inteiro usando o método cast.

# Change type of datatype_float = tf.constant(3.123456789, tf.float32)type_int = tf.cast(type_float, dtype=tf.int32)print(type_float.dtype)print(type_int.dtype) 

Resultado

O TensorFlow escolhe o tipo de dados automaticamente quando o argumento não é especificado durante a criação do tensor. O TensorFlow adivinhará quais são os tipos de dados mais prováveis. Por exemplo, se você passar um texto, ele adivinhará que é uma string e o converterá em string.

Criando operador

Alguns operadores úteis do TensorFlow

Você sabe como criar um tensor com o TensorFlow. É hora de aprender a realizar operações matemáticas.

TensorFlow contém todas as operações básicas. Você pode começar com um simples. Você usará o método TensorFlow para calcular o quadrado de um número. Esta operação é direta porque apenas um argumento é necessário para construir o tensor.

O quadrado de um número é construído com tf.sqrt (x) com x como um número flutuante.

x = tf.constant([2.0], dtype = tf.float32)print(tf.sqrt(x)) 

Resultado

Tensor("Sqrt:0", shape=(1,), dtype=float32) 

Nota: A saída retornou um objeto tensor e não o resultado do quadrado de 2. No exemplo, você imprime a definição do tensor e não a avaliação real da operação. Na próxima seção, você aprenderá como o TensorFlow funciona para executar as operações.

A seguir está uma lista de operações comumente usadas. A ideia é a mesma. Cada operação requer um ou mais argumentos.

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

Exemplo

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

Resultado

Tensor("Add:0", shape=(1, 2), dtype=int32) 

Explicação do código

Crie dois tensores:

• um tensor com 1 e 2
• um tensor com 3 e 4

Você soma os dois tensores.

Observe : que ambos os tensores precisam ter a mesma forma. Você pode executar uma multiplicação sobre os dois tensores.

# Multiplytensor_multiply = tf.multiply(tensor_a, tensor_b)print(tensor_multiply) 

Resultado

Tensor("Mul:0", shape=(1, 2), dtype=int32) 

Variáveis

Até agora, você criou apenas tensores constantes. Não é de grande utilidade. Os dados sempre chegam com valores diferentes, para capturar isso, você pode usar a classe Variable. Ele representará um nó onde os valores sempre mudam.

Para criar uma variável, você pode usar o método 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. OptionalIf initializer is specified, there is no need to include the `values` as the shape of `initializer` is used. 

Por exemplo, o código abaixo cria uma variável bidimensional com dois valores aleatórios. Por padrão, o TensorFlow retorna um valor aleatório. Você nomeia a variável var

# Create a Variable## Create 2 Randomized valuesvar = tf.get_variable("var", [1, 2])print(var.shape) 

Resultado

(1, 2) 

No segundo exemplo, você cria uma variável com uma linha e duas colunas. Você precisa usar [1,2] para criar a dimensão da variável

Os valores iniciais deste tensor são zero. Por exemplo, ao treinar um modelo, você precisa ter valores iniciais para calcular o peso dos recursos. Abaixo, você define esses valores iniciais como zero.

var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32, initializer=tf.zeros_initializer)print(var_init_1.shape) 

Resultado

(1, 2) 

Você pode passar os valores de um tensor constante em uma variável. Você cria um tensor constante com o método tf.constant (). Você usa esse tensor para inicializar a variável.

Os primeiros valores da variável são 10, 20, 30 e 40. O novo tensor terá a forma de 2x2.

# Create a 2x2 matrixtensor_const = tf.constant([[10, 20],[30, 40]])# Initialize the first value of the tensor equals to tensor_constvar_init_2 = tf.get_variable("var_init_2", dtype=tf.int32, initializer=tensor_const)print(var_init_2.shape) 

Resultado

(2, 2) 

Placeholder

Um placeholder tem como objetivo alimentar o tensor. Placeholder é usado para inicializar os dados para fluir dentro dos tensores. Para fornecer um espaço reservado, você precisa usar o método feed_dict. O espaço reservado será alimentado apenas dentro de uma sessão.

No próximo exemplo, você verá como criar um espaço reservado com o método tf.placeholder. Na próxima sessão, você aprenderá a alimentar um marcador de posição com o valor real do tensor.

A sintaxe é:

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. Optionaldata_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")print(data_placeholder_a) 

Resultado

Tensor("data_placeholder_a:0", dtype=float32) 

Sessão

O TensorFlow funciona em torno de três componentes principais:

• Gráfico
• Tensor
• Sessão

Componentes	Descrição
Gráfico	O gráfico é fundamental no TensorFlow. Todas as operações matemáticas (ops) são realizadas dentro de um gráfico. Você pode imaginar um gráfico como um projeto onde todas as operações são realizadas. Os nós representam essas operações, eles podem absorver ou criar novos tensores.
Tensor	Um tensor representa os dados que progridem entre as operações. Você viu anteriormente como inicializar um tensor. A diferença entre uma constante e variável é que os valores iniciais de uma variável mudam com o tempo.
Sessão	Uma sessão executará a operação do gráfico. Para alimentar o gráfico com os valores de um tensor, você precisa abrir uma sessão. Dentro de uma sessão, você deve executar um operador para criar uma saída.

Gráficos e sessões são independentes. Você pode executar uma sessão e obter os valores a serem usados ​​posteriormente para cálculos adicionais.

No exemplo abaixo, você irá:

• Crie dois tensores
• Crie uma operação
• Abra uma sessão
• Imprima o resultado

Etapa 1) Você cria dois tensores x e y

## Create, run and evaluate a sessionx = tf.constant([2])y = tf.constant([4]) 

Etapa 2) Você cria o operador multiplicando x e y

## Create operatormultiply = tf.multiply(x, y) 

Etapa 3) Você abre uma sessão. Todos os cálculos acontecerão dentro da sessão. Quando terminar, você precisa fechar a sessão.

## Create a session to run the codesess = tf.Session()result_1 = sess.run(multiply)print(result_1)sess.close() 

Resultado

[8] 

Explicação do código

• tf.Session (): Abra uma sessão. Todas as operações fluirão dentro das sessões
• executar (multiplicar): executa a operação criada na etapa 2.
• imprimir (resultado_1): Finalmente, você pode imprimir o resultado
• close (): fecha a sessão

O resultado mostra 8, que é a multiplicação de xe y.

Outra forma de criar uma sessão é dentro de um bloco. A vantagem é que fecha a sessão automaticamente.

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

Resultado

[8] 

Em um contexto de sessão, você pode usar o método eval () para executar a operação. É equivalente a run (). Isso torna o código mais legível.

Você pode criar uma sessão e ver os valores dentro dos tensores que você criou até agora.

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

Resultado

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

As variáveis ​​estão vazias por padrão, mesmo depois de criar um tensor. Você precisa inicializar a variável se quiser usá-la. O objeto tf.global_variables_initializer () precisa ser chamado para inicializar os valores de uma variável. Este objeto irá inicializar explicitamente todas as variáveis. Isso é útil antes de treinar um modelo.

Você pode verificar os valores das variáveis ​​que você criou antes. Observe que você precisa usar run para avaliar o tensor

sess.run(tf.global_variables_initializer())print(sess.run(var))print(sess.run(var_init_1))print(sess.run(var_init_2)) 

Resultado

[[-0.05356491 0.75867283]][[0 0]][[10 20][30 40]] 

Você pode usar o espaço reservado que você criou antes e alimentá-lo com o valor real. Você precisa passar os dados para o método feed_dict.

Por exemplo, você obterá a potência de 2 do espaço reservado data_placeholder_a.

import numpy as nppower_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. 

Explicação do código

• import numpy as np: Importar a biblioteca numpy para criar os dados
• tf.pow (data_placeholder_a, 2): Crie as operações
• np.random.rand (1, 10): Crie uma matriz aleatória de dados
• feed_dict = {data_placeholder_a: data}: Alimente o placeholder com dados

Resultado

[[0.05478134 0.27213147 0.8803037 0.0398424 0.21172127 0.01444725 0.02584014 0.3763949 0.66022706 0.7565559 ]] 

Gráfico

O TensorFlow depende de uma abordagem genial para renderizar a operação. Todos os cálculos são representados com um esquema de fluxo de dados. O gráfico de fluxo de dados foi desenvolvido para verificar as dependências de dados entre as operações individuais. Fórmulas matemáticas ou algoritmos são compostos por várias operações sucessivas. Um gráfico é uma maneira conveniente de visualizar como os cálculos são coordenados.

O gráfico mostra um nó e uma aresta . O nó é a representação de uma operação, ou seja, a unidade de computação. A aresta é o tensor, ela pode produzir um novo tensor ou consumir os dados de entrada. Depende das dependências entre as operações individuais.

A estrutura do gráfico conecta as operações (ou seja, os nós) e como essas operações são alimentadas. Observe que o gráfico não exibe a saída das operações, apenas ajuda a visualizar a conexão entre as operações individuais.

Vamos ver um exemplo.

Imagine que você queira avaliar a seguinte função:

O TensorFlow criará um gráfico para executar a função. O gráfico é parecido com este:

Exemplo de TensorFlow Graph

Você pode ver facilmente o caminho que os tensores farão para chegar ao destino final.

Por exemplo, você pode ver que a operação add não pode ser feita antes de e. O gráfico explica que:

1. calcular e:
2. adicione 1) junto
3. adicionar a 2)
4. adicionar 3) a

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 

Explicação do código

• x: inicializa uma variável chamada x com um valor constante de 5
• z: inicializa uma variável chamada z com um valor constante de 6
• c: inicializa um tensor constante chamado c com um valor constante de 5
• quadrado: inicializa um tensor constante chamado quadrado com um valor constante de 2
• f: Construir o operador

Neste exemplo, optamos por manter os valores das variáveis ​​fixos. Também criamos um tensor constante chamado c, que é o parâmetro constante na função f. Tem um valor fixo de 5. No gráfico, você pode ver este parâmetro no tensor chamado constante.

Também construímos um tensor constante para a potência no operador tf.pow (). Não é necessário. Fizemos isso para que você possa ver o nome do tensor no gráfico. É o círculo chamado quadrado.

No gráfico, você pode entender o que acontecerá com os tensores e como ele pode retornar uma saída de 66.

O código abaixo avalia a função em uma sessão.

init = tf.global_variables_initializer() # prepare to initialize all variableswith tf.Session() as sess:init.run() # Initialize x and yfunction_result = f.eval()print(function_result) 

Resultado

[66] 

Resumo

O TensorFlow funciona em torno de:

• Gráfico : Ambiente computacional contendo as operações e tensores
• Tensores : representa os dados (ou valor) que fluirão no gráfico. É a borda do gráfico
• Sessões : Permitir a execução das operações

Crie um tensor constante

constante	objeto
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)

Crie um operador

Crie um operador	Objeto
a + b	tf.add (a, b)
a * b	tf.multiply (a, b)

Crie um tensor variável

Crie uma variável	objeto
valor aleatório	tf.get_variable ("var", [1, 2])
primeiro valor inicializado	tf.get_variable ("var_init_2", dtype = tf.int32, inicializador = [[1, 2], [3, 4]])

Abra uma sessão

Sessão	objeto
Crie uma sessão	tf.Session ()
Executar uma sessão	tf.Session.run ()
Avalie um tensor	variable_name.eval ()
Fechar uma sessão	sess.close ()
Sessão por bloco	com tf.Session () as sess: