O que é um Tensor no TensorFlow? Forma, Tipo e Operatoros

O que é um tensor?

O nome TensorFlow é derivado diretamente de seu objeto central: o tensor. No TensorFlow, toda computação envolve tensores. Um tensor é um vetor ou matriz de n dimensões que representa todos os tipos de dados. Todos os valores em um tensor possuem um tipo de dado idêntico com uma forma conhecida (ou parcialmente conhecida), e a forma dos dados é a dimensionalidade da matriz ou do vetor.

Um tensor pode ter origem nos dados de entrada ou no resultado de um cálculo. No TensorFlow, todas as operações são realizadas dentro de um grafo. O grafo é um conjunto de cálculos que ocorrem sucessivamente. Cada operação é chamada de nó de operação (op node), e os nós são conectados entre si.

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

Em aprendizado de máquina, os modelos são alimentados com uma lista de objetos chamados vetores de características. Um vetor de características pode ser de qualquer tipo de dado e geralmente é a entrada principal que preenche um tensor. Esses valores fluem para um nó de operação através do tensor, e o resultado dessa operação cria um novo tensor, que por sua vez é usado em uma nova operação. Todas essas operações podem ser visualizadas no grafo.

Representação de um Tensor

Em TensorFlow, um tensor é uma coleção de vetores de características (ou seja, uma matriz) de n dimensões. Por exemplo, se tivermos uma matriz 2×3 com valores de 1 a 6, podemos escrevê-la como a matriz mostrada abaixo:

O TensorFlow representa esta matriz como:

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

Se criarmos uma matriz tridimensional com valores de 1 a 8, os mesmos dados serão representados como uma caixa com duas faces sobrepostas:

O TensorFlow representa esta matriz como:

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

Nota: Um tensor pode ser representado por um escalar ou pode ter uma forma com mais de três dimensões. É simplesmente mais difícil visualizar os níveis de dimensão mais elevados.

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 realizada com o TensorFlow envolve a manipulação de um tensor. Existem quatro tipos principais de tensores que você pode criar:

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

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

Um ponto importante a ter em mente antes de executar o código: este tutorial segue a API original do TensorFlow 1.x, onde um grafo é construído primeiro e executado posteriormente dentro de uma sessão. O TensorFlow 2 é executado imediatamente por padrão, portanto, vários dos símbolos abaixo foram movidos ou removidos. Todos eles ainda são acessíveis através do tf.compat.v1 namespace, e a tabela mapeia cada um para sua contraparte moderna.

Antes de prosseguir com o tutorial, certifique-se de ativar o ambiente conda que possui o TensorFlow instalado. Este ambiente se chama hello-tf.

Para macOS Comercial:

source activate hello-tf

Para Windows Comercial:

activate hello-tf

Depois de fazer isso, você estará pronto para importar o TensorFlow.

# Import tf
import tensorflow as tf

Crie um tensor de n dimensão

Você começa criando um tensor com uma dimensão, ou seja, um escalar.

Para criar um tensor, você pode usar tf.constant() Conforme mostrado no exemplo de formato 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 name
r1 = tf.constant(1, tf.int16) 
print(r1)			

saída

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

As três partes dessa saída correspondem às três propriedades do tensor, como a versão anotada abaixo deixa claro.

Você também pode dar um nome personalizado ao tensor com o name argumento.

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

saída

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

Cada tensor é exibido pelo seu nome. Cada objeto tensor é definido com atributos como um rótulo único (nome), uma dimensão (formato) e um tipo de dados do TensorFlow (dtype).

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

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

saída

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

saída

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 por apenas 1 coluna.

Para criar uma matriz de tensores com 2 dimensões, você precisa fechar os colchetes após cada linha. Veja o exemplo de formato de tensor abaixo.

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

saída

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

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

Uma matriz com 3 dimensões é construída adicionando-se mais um nível de colchetes.

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

saída

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

O resultado corresponde ao diagrama de caixa tridimensional mostrado anteriormente neste tutorial.

Forma do Tensor

Ao imprimir um tensor, o TensorFlow infere o formato. No entanto, você pode ler o formato diretamente com o TensorFlow. shape propriedade.

A seguir, você constrói uma matriz preenchida com os números de 10 a 15 e verifica o formato de m_shape.

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

saída

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

A matriz possui 3 linhas e 2 colunas.

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

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

saída

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

A propriedade também funciona para uma matriz. Aqui, você cria uma matriz 10×10 preenchida com 1.

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

saída

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

Você pode usar o formato de uma matriz dada para criar um vetor de uns. A matriz m_shape Possui dimensões 3×2, portanto, o código a seguir cria um tensor com 3 linhas preenchidas com uns:

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

saída

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

Se você passar o valor 1 para os parênteses, você constrói um vetor de uns igual ao número de colunas da matriz. m_shape.

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

saída

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

Por fim, você pode criar uma matriz 3×2 preenchida inteiramente com uns.

print(tf.ones(m_shape.shape))

saída

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

Tipo de dados

A segunda propriedade de um tensor é o tipo de dados. Um tensor pode armazenar apenas um tipo de dado por vez, e você pode ler esse tipo com o dtype propriedade.

print(m_shape.dtype)

saída

<dtype: &#x27;int32'>

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

Exemplo

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

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

saída

<dtype: &#x27;float32'>
<dtype: &#x27;int32'>

O TensorFlow escolhe automaticamente o tipo de dados quando o argumento não é especificado durante a criação do tensor. O TensorFlow tenta adivinhar o tipo de dados mais provável: se você passar um texto, por exemplo, ele infere que se trata de uma string.

Criar Operator

Algumas funcionalidades úteis do TensorFlow Operatoros

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

O TensorFlow contém todas as operações básicas. Você pode começar com uma operação simples e usar um método do TensorFlow para calcular a raiz quadrada de um número. Essa operação é direta, pois requer apenas um argumento para construir o tensor.

A raiz quadrada de um número é construída com tf.sqrt(x), onde x é um número de ponto flutuante.

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

saída

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

Observação: A saída retornou um objeto tensor e não a raiz quadrada de 2. Neste exemplo, você imprime a definição do tensor e não a avaliação real da operação. Na seção Sessão abaixo, você aprenderá como o TensorFlow executa as operações.

Segue abaixo uma lista de operações comumente usadas. A ideia é a mesma: cada operação requer um ou mais argumentos.

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

Exemplo

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

saída

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

Code Explicação

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 o mesmo formato. Você também pode realizar uma multiplicação entre os dois tensores.

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

saída

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

Variáveis

Até agora, você só criou tensores constantes, o que, por si só, tem utilidade limitada. Os dados sempre chegam com valores diferentes, e para capturar isso você pode usar a classe Variable. Uma variável representa um nó cujos valores mudam ao longo do tempo.

Para criar uma variável, você pode usar o tf.get_variable() método.

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.

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 como var.

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

saída

(1, 2)

Neste exemplo, você cria uma variável com uma linha e duas colunas, então você passa [1, 2] como a dimensão da variável.

Os valores iniciais de um tensor também podem ser zero. Ao treinar um modelo, por exemplo, você precisa de valores iniciais antes de calcular o peso das características. 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)

saída

(1, 2)

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

Os primeiros valores da variável são 10, 20, 30 e 40. O novo tensor tem uma forma de 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)

saída

(2, 2)

espaço reservado

Um marcador de posição tem a função de alimentar o tensor. Ele inicializa os dados que serão inseridos nos tensores. Para fornecer um marcador de posição, você usa o feed_dict argumento, e o marcador de posição é inserido apenas dentro de uma sessão.

No próximo exemplo, você verá como criar um espaço reservado com o método. tf.placeholderNa seção Sessão, você aprenderá a inserir um valor tensorial real em um espaço reservado.

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

saída

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

em Nova York

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

• Gráfico
• tensor
• em Nova York

Os gráficos e as sessões são independentes. Você pode executar uma sessão e manter os valores para cálculos posteriores.

No exemplo abaixo, você irá:

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

Passo 1) Você cria dois tensores x e y.

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

Passo 2) Você cria o operador multiplicando x e y.

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

Passo 3) Você abre uma sessão. Todos os cálculos acontecem dentro da sessão e, quando terminar, você precisa fechá-la.

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

saída

[8]

Code explicação

• tf.Session()Abra uma sessão. Todas as operações ocorrem dentro da sessão.
• run(multiply): execute a operação criada na etapa 2
• print(result_1)Finalmente, você pode imprimir o resultado.
• close(): Encerrar a sessão

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

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

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

saída

[8]

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

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

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

saída

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

As variáveis ​​estão vazias por padrão, mesmo depois de você criar o tensor. Você precisa inicializar uma variável antes de poder usá-la. O objeto tf.global_variables_initializer() é chamada para inicializar os valores de todas as variáveis ​​de uma só vez, o que é útil antes de treinar um modelo.

Você pode verificar os valores das variáveis ​​que criou anteriormente. Observe que é necessário usar o comando `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))

saída

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

Você pode usar o marcador que criou anteriormente e inserir um valor real nele. Você precisa passar os dados para o feed_dict argumento.

Por exemplo, você assumirá a potência de 2 do espaço reservado 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 Explicação

• import numpy as np: Importar o NumPy biblioteca para criar os dados
• tf.pow(data_placeholder_a, 2)Criar as operações
• np.random.rand(1, 10)Criar uma matriz de dados aleatórios
• feed_dict={data_placeholder_a: data}: Insira dados no espaço reservado

saída

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

Gráfico

O TensorFlow representa cada operação com um esquema de fluxo de dados. O grafo de fluxo de dados foi projetado para expor as dependências de dados entre operações individuais. Uma fórmula matemática ou um algoritmo é composto por uma série de operações sucessivas, e um grafo é uma maneira conveniente de visualizar como esses cálculos são coordenados.

O gráfico mostra nós e arestas. Um nó representa uma operação, ou seja, a unidade de computação. Uma aresta representa um tensor: ela pode gerar um novo tensor ou consumir os dados de entrada, dependendo das relações entre as operações individuais.

A estrutura do grafo conecta as operações (ou seja, os nós) entre si e mostra como cada uma é alimentada. Observe que o grafo não exibe a saída das operações; ele apenas ajuda a visualizar as conexões entre elas.

Vejamos um exemplo. Imagine que você queira avaliar a seguinte função:

O TensorFlow constrói um grafo para executar a função. O grafo tem a seguinte aparência:

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

Por exemplo, a add O nó não pode ser executado antes de ambos. Mul e Pow produziram seus resultados. O gráfico mostra que o TensorFlow irá:

1. calcular x·z no Mul nó e x² no Pow nó
2. some esses dois resultados no add nó
3. adicione z a essa soma no add_1 nó
4. adicione a constante 5 no add_2 nó

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 Explicação

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

Neste exemplo, os valores das variáveis ​​são mantidos fixos. O tensor constante c é o parâmetro constante na função f e assume um valor fixo de 5; no gráfico, você pode ver esse parâmetro no tensor chamado constante.

Um tensor constante também foi criado para a potência no operador. tf.pow()Não é necessário, mas significa que o expoente aparece no gráfico como o círculo chamado quadrado.

A partir do gráfico, você pode acompanhar o que acontece com os tensores e por que a função retorna 66: 5 × 6 mais 5² mais 6 mais 5 é igual a 66.

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

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)

saída

[66]

Guia rápido de conceitos básicos do TensorFlow

As quatro tabelas abaixo reúnem todos os comandos usados ​​neste tutorial, para que você possa procurar um deles sem precisar rolar a página para trás e para frente nos exemplos.

Crie um tensor constante

Crie um operador

Crie um tensor variável

Abra uma sessão

Perguntas Frequentes