Wat is een tensor in TensorFlow? Vorm, type & Operaverdraaid

Wat is een tensor?

De naam TensorFlow is rechtstreeks afgeleid van het kernobject: de tensor. In TensorFlow is elke berekening gebaseerd op tensors. Een tensor is een vector of matrix van n dimensies die alle soorten data vertegenwoordigt. Alle waarden in een tensor hebben hetzelfde gegevenstype met een bekende (of gedeeltelijk bekende) vorm, en de vorm van de data is de dimensionaliteit van de matrix of array.

Een tensor kan afkomstig zijn van de invoergegevens of van het resultaat van een berekening. In TensorFlow worden alle bewerkingen uitgevoerd binnen een graaf. De graaf is een verzameling berekeningen die achter elkaar plaatsvinden. Elke bewerking wordt een op-node genoemd en de nodes zijn met elkaar verbonden.

De grafiek schetst de bewerkingen en de verbindingen tussen de knooppunten. De waarden worden echter niet weergegeven. De verbinding tussen de knooppunten is de tensor, oftewel een manier om de bewerking met gegevens te vullen.

In machine learning worden modellen gevoed met een lijst van objecten die featurevectoren worden genoemd. Een featurevector kan elk gegevenstype hebben en is meestal de primaire invoer waarmee een tensor wordt gevuld. Deze waarden stromen via de tensor naar een bewerkingsknooppunt (op-node), en het resultaat van die bewerking creëert een nieuwe tensor, die op zijn beurt wordt gebruikt in een nieuwe bewerking. Al deze bewerkingen kunnen in de grafiek worden weergegeven.

Weergave van een tensor

In TensorFlow is een tensor een verzameling van featurevectoren (oftewel een array) met n dimensies. Als we bijvoorbeeld een 2×3 matrix hebben met waarden van 1 tot en met 6, schrijven we die als de matrix die hieronder wordt weergegeven:

TensorFlow vertegenwoordigt deze matrix als:

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

Als we een driedimensionale matrix maken met waarden van 1 tot en met 8, worden dezelfde gegevens weergegeven als een rechthoek met twee op elkaar gestapelde vlakken:

TensorFlow vertegenwoordigt deze matrix als:

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

Opmerking: Een tensor kan worden weergegeven met een scalaire waarde of kan een vorm hebben met meer dan drie dimensies. Het is simpelweg lastiger om de hogere dimensies te visualiseren.

Soorten Tensor

In TensorFlow verlopen alle berekeningen via een of meer tensors. Een tf.Tensor is een object met drie eigenschappen:

• Een uniek label (naam)
• Een dimensie (vorm)
• Een gegevenstype (dtype)

Elke bewerking die je met TensorFlow uitvoert, omvat het manipuleren van een tensor. Er zijn vier hoofdtypen tensors die je kunt maken:

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

In deze handleiding leer je hoe je een tf.constant en tf.Variable.

Een belangrijk punt om in gedachten te houden voordat u de code uitvoert: deze handleiding volgt de originele TensorFlow 1.x API, waarbij eerst een grafiek wordt opgebouwd en later binnen een sessie wordt uitgevoerd. TensorFlow 2 wordt standaard 'eagerly' uitgevoerd, waardoor verschillende symbolen hieronder zijn verplaatst of verwijderd. Ze zijn echter allemaal nog steeds bereikbaar via de API. tf.compat.v1 naamruimte, en de tabel koppelt elk ervan aan zijn moderne tegenhanger.

Voordat je met de tutorial begint, moet je ervoor zorgen dat je de conda-omgeving activeert waarin TensorFlow is geïnstalleerd. Deze omgeving heet hello-tf.

Bij macOS gebruikers:

source activate hello-tf

Bij Windows gebruikers:

activate hello-tf

Nadat je dat hebt gedaan, ben je klaar om TensorFlow te importeren.

# Import tf
import tensorflow as tf

Maak een tensor van n-dimensie

Je begint met het creëren van een tensor met één dimensie, namelijk een scalair.

Om een ​​tensor te maken, kun je gebruikmaken van tf.constant() zoals weergegeven in het onderstaande voorbeeld van de vorm van een TensorFlow-tensor:

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`

Om een ​​tensor van dimensie 0 te creëren, voert u de volgende code uit.

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

uitgang

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

De drie onderdelen van die uitvoer corresponderen met de drie tensor-eigenschappen, zoals de onderstaande geannoteerde versie duidelijk maakt.

Je kunt de tensor ook een eigen naam geven met de name argument.

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

uitgang

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

Elke tensor wordt weergegeven met zijn tensornaam. Elk tensorobject is gedefinieerd met attributen zoals een uniek label (naam), een dimensie (vorm) en een TensorFlow-datatype (dtype).

U kunt een tensor definiëren met decimale waarden of met een tekenreeks door het gegevenstype te wijzigen.

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

uitgang

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

Een tensor van dimensie 1 kan als volgt worden gecreëerd:

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

uitgang

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

Je kunt zien dat de TensorFlow-vorm uit slechts één kolom bestaat.

Om een ​​array van 2 tensordimensies te maken, moet je de haakjes na elke rij sluiten. Bekijk het onderstaande voorbeeld van een tensorvorm.

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

uitgang

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

De matrix heeft 2 rijen en 2 kolommen gevuld met de waarden 1, 2, 3 en 4.

Een matrix met 3 dimensies wordt geconstrueerd door een extra laag haakjes toe te voegen.

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

uitgang

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

Het resultaat komt overeen met het driedimensionale boxdiagram dat eerder in deze handleiding is getoond.

Vorm van de tensor

Wanneer je een tensor afdrukt, leidt TensorFlow de vorm af. Je kunt de vorm echter ook rechtstreeks uitlezen met TensorFlow. shape eigendom.

Hieronder construeer je een matrix gevuld met de getallen van 10 tot en met 15 en controleer je de vorm van de matrix. m_shape.

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

uitgang

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

De matrix heeft 3 rijen en 2 kolommen.

TensorFlow heeft handige opdrachten om een ​​vector of een matrix gevuld met 0 of 1 te maken. Als u bijvoorbeeld een 1D-tensor wilt maken met een specifieke vorm van 10, gevuld met 0, kunt u de onderstaande code uitvoeren:

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

uitgang

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

Deze eigenschap werkt ook voor een matrix. Hier maak je een 10×10 matrix gevuld met 1'en.

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

uitgang

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

Je kunt de vorm van een gegeven matrix gebruiken om een ​​vector van enen te maken. De matrix m_shape De tensor heeft 3×2 dimensies, dus de volgende code creëert een tensor met 3 rijen gevuld met enen:

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

uitgang

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

Als je de waarde 1 in de haakjes invoert, construeer je een vector van enen gelijk aan het aantal kolommen in de matrix. m_shape.

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

uitgang

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

Ten slotte kun je een 3×2 matrix maken die volledig gevuld is met enen.

print(tf.ones(m_shape.shape))

uitgang

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

Type gegevens

De tweede eigenschap van een tensor is het gegevenstype. Een tensor kan slechts één gegevenstype tegelijk bevatten, en je kunt dat type lezen met de dtype eigendom.

print(m_shape.dtype)

uitgang

<dtype: &#x27;int32'>

Soms wil je het gegevenstype wijzigen. In TensorFlow is dat mogelijk met de tf.cast methode.

Voorbeeld

Hieronder wordt een float-tensor omgezet naar een integer met behulp van de cast methode.

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

uitgang

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

TensorFlow kiest automatisch het gegevenstype wanneer dit niet is gespecificeerd tijdens het aanmaken van de tensor. TensorFlow raadt het meest waarschijnlijke gegevenstype: als je bijvoorbeeld 'text' doorgeeft, gaat het uit van een tekenreeks.

Wij creëren Operator

Enkele nuttige TensorFlow-functies Operaverdraaid

Je weet hoe je een tensor maakt met TensorFlow. Het is tijd om te leren hoe je wiskundige bewerkingen uitvoert.

TensorFlow bevat alle basisbewerkingen. Je kunt beginnen met een eenvoudige en een TensorFlow-methode gebruiken om de vierkantswortel van een getal te berekenen. Deze bewerking is eenvoudig omdat er slechts één argument nodig is om de tensor te construeren.

De vierkantswortel van een getal wordt geconstrueerd met tf.sqrt(x), waarbij x een drijvende-komma getal is.

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

uitgang

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

Opmerking: De uitvoer retourneerde een tensorobject en niet de wortel van 2. In dit voorbeeld print u de definitie van de tensor en niet de daadwerkelijke evaluatie van de bewerking. In het onderstaande gedeelte 'Sessie' leert u hoe TensorFlow de bewerkingen uitvoert.

Hieronder volgt een lijst met veelgebruikte bewerkingen. Het principe is hetzelfde: elke bewerking vereist een of meer argumenten.

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

Voorbeeld

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

uitgang

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

Code Uitleg

Maak twee tensoren:

• één tensor met 1 en 2
• één tensor met 3 en 4

Je telt beide tensoren bij elkaar op.

Merk op dat beide tensoren dezelfde vorm moeten hebben. Je kunt ook een vermenigvuldiging uitvoeren op de twee tensoren.

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

uitgang

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

Variabelen

Tot nu toe heb je alleen constante tensors gemaakt, wat op zichzelf beperkt bruikbaar is. Data komt altijd binnen met verschillende waarden, en om dat vast te leggen kun je de Variable-klasse gebruiken. Een variabele vertegenwoordigt een knooppunt waarvan de waarden in de loop van de tijd veranderen.

Om een ​​variabele te creëren, kunt u de volgende methode gebruiken: tf.get_variable() methode.

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.

De onderstaande code creëert bijvoorbeeld een tweedimensionale variabele met twee willekeurige waarden. Standaard retourneert TensorFlow een willekeurige waarde. Je geeft de variabele de naam `var`.

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

uitgang

(1, 2)

In dit voorbeeld maak je een variabele aan met één rij en twee kolommen, dus geef je [1, 2] door als de dimensie van de variabele.

De beginwaarden van een tensor kunnen ook nul zijn. Wanneer je bijvoorbeeld een model traint, heb je beginwaarden nodig voordat je de gewichten van de kenmerken berekent. Hieronder stel je die beginwaarden in op nul.

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

uitgang

(1, 2)

Je kunt de waarden van een constante tensor ook aan een variabele doorgeven. Je maakt een constante tensor aan met de methode tf.constant() en gebruik die tensor om de variabele te initialiseren.

De eerste waarden van de variabele zijn 10, 20, 30 en 40. De nieuwe tensor heeft een vorm van 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)

uitgang

(2, 2)

Placeholder

Een placeholder heeft als doel de tensor te vullen. Een placeholder initialiseert de data die in de tensor terechtkomt. Om een ​​placeholder te gebruiken, gebruikt u de feed_dict argument, en de placeholder wordt alleen binnen een sessie ingevuld.

In het volgende voorbeeld ziet u hoe u een placeholder kunt maken met behulp van de methode. tf.placeholderIn het onderdeel 'Sessie' leer je hoe je een placeholder kunt vullen met een daadwerkelijke tensorwaarde.

De syntaxis is:

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)

uitgang

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

Sessie

TensorFlow werkt rond 3 hoofdcomponenten:

• Diagram
• strekspier
• Sessie

Grafieken en sessies zijn onafhankelijk van elkaar. Je kunt een sessie uitvoeren en de waarden bewaren voor latere berekeningen.

In het onderstaande voorbeeld doet u het volgende:

• Maak twee tensoren
• Een bewerking maken
• Open een sessie
• Print het resultaat

Stap 1) Je maakt twee tensors x en y aan.

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

Stap 2) Je maakt de operator door x en y met elkaar te vermenigvuldigen.

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

Stap 3) Je opent een sessie. Alle berekeningen vinden plaats binnen de sessie en wanneer je klaar bent, moet je deze sluiten.

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

uitgang

[8]

Code uitleg

• tf.Session(): Open een sessie. Alle bewerkingen verlopen binnen de sessie.
• run(multiply): voer de in stap 2 gemaakte bewerking uit
• print(result_1)Tot slot kunt u het resultaat afdrukken.
• close(): Sluit de sessie

Het resultaat toont 8, wat de vermenigvuldiging is van x en y.

Een andere manier om een ​​sessie te creëren is binnen een codeblok. Het voordeel hiervan is dat de sessie automatisch wordt gesloten.

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

uitgang

[8]

Binnen een sessie kunt u gebruikmaken van de eval() methode om de bewerking uit te voeren. Het is equivalent aan run() en maakt de code leesbaarder.

U kunt een sessie maken en de waarden bekijken binnen de tensoren die u tot nu toe hebt gemaakt.

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

uitgang

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

Variabelen zijn standaard leeg, zelfs nadat je de tensor hebt aangemaakt. Je moet een variabele initialiseren voordat je deze kunt gebruiken. Het object tf.global_variables_initializer() Deze functie wordt aangeroepen om de waarden van alle variabelen in één keer te initialiseren, wat handig is voordat je een model traint.

Je kunt de waarden van de variabelen die je eerder hebt aangemaakt controleren. Houd er rekening mee dat je `run` moet gebruiken om de tensor te evalueren.

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

uitgang

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

Je kunt de eerder gemaakte placeholder gebruiken en deze vullen met een daadwerkelijke waarde. Je moet de gegevens doorgeven aan de feed_dict argument.

U neemt bijvoorbeeld de macht van 2 van de tijdelijke aanduiding 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 Uitleg

• import numpy as np: Importeer de NumPy bibliotheek om de gegevens te creëren
• tf.pow(data_placeholder_a, 2): Maak de bewerkingen aan
• np.random.rand(1, 10): Maak een willekeurige reeks gegevens aan
• feed_dict={data_placeholder_a: data}: Vul de placeholder met gegevens

uitgang

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

Diagram

TensorFlow visualiseert elke bewerking met een dataflow-schema. De dataflow-grafiek is ontworpen om de data-afhankelijkheden tussen individuele bewerkingen weer te geven. Een wiskundige formule of een algoritme bestaat uit een aantal opeenvolgende bewerkingen, en een grafiek is een handige manier om te visualiseren hoe die berekeningen op elkaar zijn afgestemd.

De grafiek toont knooppunten en verbindingen. Een knooppunt is de representatie van een bewerking, oftewel de rekeneenheid. Een verbinding is de tensor: deze kan een nieuwe tensor produceren of de invoergegevens verbruiken, afhankelijk van de onderlinge afhankelijkheden tussen de afzonderlijke bewerkingen.

De structuur van de grafiek verbindt de bewerkingen (oftewel de knooppunten) met elkaar en laat zien hoe elke bewerking wordt gevoed. Merk op dat de grafiek niet de output van de bewerkingen weergeeft; hij helpt alleen om de verbanden ertussen te visualiseren.

Laten we een voorbeeld bekijken. Stel dat u de volgende functie wilt evalueren:

TensorFlow bouwt een grafiek om de functie uit te voeren. De grafiek ziet er als volgt uit:

Je kunt gemakkelijk zien welk pad de tensoren zullen volgen om de eindbestemming te bereiken.

Bijvoorbeeld, de add Het knooppunt kan niet worden uitgevoerd voordat beide Mul en Pow hebben hun resultaten opgeleverd. De grafiek laat zien dat TensorFlow het volgende zal doen:

1. bereken x·z in de Mul knooppunt en x² in de Pow knooppunt
2. tel die twee resultaten bij elkaar op in de add knooppunt
3. tel z bij die som op in de add_1 knooppunt
4. tel de constante 5 erbij op in de add_2 knooppunt

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 Uitleg

• x: Initialiseer een variabele genaamd x met een constante waarde van 5
• z: Initialiseer een variabele genaamd z met een constante waarde van 6
• c: Initialiseer een constante tensor genaamd c met een constante waarde van 5
• vierkant: Initialiseer een constante tensor genaamd vierkant met een constante waarde van 2
• f: Construeer de operator

In dit voorbeeld worden de waarden van de variabelen vastgehouden. De constante tensor c is de constante parameter in de functie f en heeft een vaste waarde van 5; in de grafiek is deze parameter te zien in de tensor met de naam 'constant'.

Er werd ook een constante tensor gecreëerd voor de macht in de operator. tf.pow()Het is niet noodzakelijk, maar het betekent dat de exponent in de grafiek wordt weergegeven als een cirkel, een zogenaamd vierkant.

Aan de hand van de grafiek kun je zien wat er met de tensoren gebeurt en waarom de functie 66 teruggeeft: 5 × 6 plus 5² plus 6 plus 5 is gelijk aan 66.

De onderstaande code evalueert de functie binnen een sessie.

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)

uitgang

[66]

Beknopte basisinformatie over TensorFlow

De vier onderstaande tabellen bevatten alle commando's die in deze handleiding worden gebruikt, zodat u er een kunt opzoeken zonder door de voorbeelden te hoeven scrollen.

Creëer een constante tensor

Een operator aanmaken

Maak een variabele tensor

Open een sessie

Veelgestelde vragen