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

Wat is een tensor?

De naam van Tensorflow is rechtstreeks afgeleid van het kernraamwerk: Tensor. In Tensorflow worden bij alle berekeningen tensoren gebruikt. Een tensor is een vector of matrix van n-dimensies die alle soorten gegevens vertegenwoordigt. Alle waarden in een tensor bevatten een identiek gegevenstype met een bekende (of gedeeltelijk bekende) vorm. De vorm van de gegevens is de dimensionaliteit van de matrix of array.

Een tensor kan ontstaan ​​uit de invoergegevens of het resultaat van een berekening. In TensorFlow worden alle bewerkingen in een grafiek uitgevoerd. De grafiek is een reeks berekeningen die achtereenvolgens plaatsvindt. Elke bewerking wordt een op-node genoemd en is met elkaar verbonden.

De grafiek schetst de operaties en verbindingen tussen de knooppunten. De waarden worden echter niet weergegeven. De rand van de knooppunten is de tensor, dwz een manier om de bewerking met gegevens te vullen.

In Machine Learning worden modellen gevoed met een lijst met objecten die feature-vectoren worden genoemd. Een kenmerkvector kan van elk gegevenstype zijn. De kenmerkvector is meestal de primaire invoer om een ​​tensor te vullen. Deze waarden zullen via de tensor in een op-knooppunt stromen en het resultaat van deze bewerking / berekening zal een nieuwe tensor creëren die op zijn beurt zal worden gebruikt in een nieuwe bewerking. Al deze bewerkingen kunnen in de grafiek worden bekeken.

In deze tutorial leert u de basisprincipes van TensorFlow, zoals:

• Wat is een tensor?
• Vertegenwoordiging van een tensor
• Soorten tensor
• Creëer een tensor van n-dimensie
• Vorm van tensor
• Type gegevens
• Operator aanmaken
• Enkele handige TensorFlow-operators
• Variabelen
• Tijdelijke aanduiding
• Sessie
• Grafiek

Vertegenwoordiging van een tensor

In TensorFlow is een tensor een verzameling kenmerkvectoren (dwz array) met n-dimensies. Als we bijvoorbeeld een 2x3-matrix hebben met waarden van 1 tot 6, schrijven we:

Vertegenwoordiging van een tensor

TensorFlow stelt deze matrix voor als:

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

Als we een driedimensionale matrix maken met waarden van 1 tot 8, hebben we:

TensorFlow stelt deze matrix voor als:

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

Opmerking: een tensor kan worden weergegeven met een scalair of kan een vorm hebben van meer dan drie dimensies. Het is gewoon ingewikkelder om een ​​hoger dimensieniveau te visualiseren.

Soorten tensor

In TensorFlow gaan alle berekeningen door een of meer tensoren. Een tf.tensor is een object met drie eigenschappen:

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

Elke bewerking die u met TensorFlow doet, omvat het manipuleren van een tensor. Er zijn vier hoofdtensortypen die u kunt maken:

• tf.Variabele
• tf. constant
• tf. tijdelijke aanduiding
• tf.SparseTensor

In deze tutorial leer je hoe je een tf.constant en een tf.Variable kunt maken.

Voordat we de tutorial doorlopen, moet je ervoor zorgen dat je de conda-omgeving activeert met TensorFlow. We noemden deze omgeving hallo-tf.

Voor MacOS-gebruiker:

source activate hello-tf 

Voor Windows-gebruiker:

activate hello-tf 

Nadat u dat heeft gedaan, bent u klaar om tensorflow te importeren

# Import tfimport tensorflow as tf 

Creëer 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, kunt u tf.constant () gebruiken zoals weergegeven in het onderstaande voorbeeld van de TensorFlow-tensorvorm:

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` 

Voer de volgende code uit om een ​​tensor van dimensie 0 te maken

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

Uitvoer

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

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

Uitvoer

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

Elke tensor wordt weergegeven door de naam van de tensor. Elk tensorobject wordt gedefinieerd met tensorattributen zoals een uniek label (naam), een dimensie (vorm) en TensorFlow-gegevenstypen (dtype).

U kunt een tensor definiëren met decimale waarden of met een string door het type gegevens te wijzigen.

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

Uitvoer

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

Een tensor van dimensie 1 kan als volgt worden gemaakt:

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

Uitvoer

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

Je kunt zien dat de TensorFlow-vorm maar uit 1 kolom bestaat.

Om een ​​array van 2 tensor-dimensies te maken, moet u de haakjes na elke rij sluiten. Bekijk het onderstaande voorbeeld van de Keras Tensor-vorm

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

Uitvoer

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

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

Een matrix met 3 dimensies wordt geconstrueerd door nog een niveau toe te voegen met de haakjes.

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

Uitvoer

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

De matrix lijkt op de afbeelding twee.

Vorm van tensor

Wanneer u tensor afdrukt, raadt TensorFlow de vorm. U kunt de vorm van de tensor echter verkrijgen met de TensorFlow-vormeigenschap.

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

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

Uitvoer

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 1-D tensor wilt maken met een specifieke vorm van 10, gevuld met 0, kunt u de onderstaande code uitvoeren:

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

Uitvoer

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

De eigenschap werkt ook voor matrix. Hier maak je een 10x10 matrix gevuld met 1

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

Uitvoer

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

U kunt de vorm van een gegeven matrix gebruiken om er een vector van te maken. De matrix m_shape is een 3x2 dimensie. Je kunt een tensor maken met 3 rijen gevuld met een met de volgende code:

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

Uitvoer

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

Als je de waarde 1 doorgeeft aan de haak, kun je een vector construeren met enen gelijk aan het aantal kolommen in de matrix m_shape.

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

Uitvoer

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

Ten slotte kunt u een matrix 3x2 maken met alleen één

print(tf.ones(m_shape.shape)) 

Uitvoer

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

Type gegevens

De tweede eigenschap van een tensor is het type gegevens. Een tensor kan slechts één type gegevens tegelijk hebben. Een tensor kan maar één type gegevens hebben. U kunt het type teruggeven met de eigenschap dtype.

print(m_shape.dtype) 

Uitvoer

In sommige gevallen wilt u het type gegevens wijzigen. In TensorFlow is het mogelijk met de tf.cast-methode.

Voorbeeld

Hieronder wordt een float-tensor geconverteerd naar een geheel getal met behulp van de methode 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) 

Uitvoer

TensorFlow kiest automatisch het type gegevens wanneer het argument niet wordt gespecificeerd tijdens het maken van de tensor. TensorFlow zal raden wat de meest waarschijnlijke gegevenstypen zijn. Als u bijvoorbeeld een tekst doorgeeft, zal deze raden dat het een string is en deze in een string omzetten.

Operator aanmaken

Enkele handige TensorFlow-operators

Je weet hoe je een tensor moet maken met TensorFlow. Het is tijd om te leren wiskundige bewerkingen uit te voeren.

TensorFlow bevat alle basisbewerkingen. U kunt met een eenvoudige beginnen. U gebruikt de TensorFlow-methode om het kwadraat van een getal te berekenen. Deze bewerking is eenvoudig omdat er slechts één argument nodig is om de tensor te construeren.

Het kwadraat van een getal wordt geconstrueerd met tf.sqrt (x) met x als een zwevend getal.

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

Uitvoer

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

Opmerking: de uitvoer heeft een tensorobject geretourneerd en niet het resultaat van het kwadraat van 2. In het voorbeeld drukt u de definitie van de tensor af en niet de feitelijke evaluatie van de bewerking. In de volgende sectie leert u hoe TensorFlow werkt om de bewerkingen uit te voeren.

Hieronder volgt een lijst met veelgebruikte bewerkingen. Het idee is hetzelfde. Elke bewerking vereist een of meer argumenten.

• tf.add (a, b)
• tf. aftrekken (a, b)
• tf. vermenigvuldigen (a, b)
• tf.div (a, b)
• tf.pow (a, b)
• tf.exp (een)
• tf.sqrt (een)

Voorbeeld

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

Uitvoer

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

Code Verklaring

Maak twee tensoren:

• een tensor met 1 en 2
• een tensor met 3 en 4

Je telt beide tensoren bij elkaar op.

Let op : beide tensoren moeten dezelfde vorm hebben. U kunt een vermenigvuldiging over de twee tensoren uitvoeren.

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

Uitvoer

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

Variabelen

Tot nu toe heb je alleen constante tensoren gecreëerd. Het is niet erg nuttig. Gegevens komen altijd met verschillende waarden binnen, om dit vast te leggen kunt u de klasse Variabele gebruiken. Het vertegenwoordigt een knooppunt waar de waarden altijd veranderen.

Om een ​​variabele te maken, kunt u de methode tf.get_variable () gebruiken

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. 

De onderstaande code maakt bijvoorbeeld een tweedimensionale variabele met twee willekeurige waarden. TensorFlow retourneert standaard een willekeurige waarde. U noemt de variabele var

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

Uitvoer

(1, 2) 

In het tweede voorbeeld maak je een variabele met één rij en twee kolommen. U moet [1,2] gebruiken om de dimensie van de variabele te maken

De initialen van deze tensor zijn nul. Als u bijvoorbeeld een model traint, heeft u beginwaarden nodig om het gewicht van de functies te berekenen. Hieronder stelt u deze beginwaarde 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) 

Uitvoer

(1, 2) 

U kunt de waarden van een constante tensor in een variabele doorgeven. Je maakt een constante tensor met de methode tf.constant (). U gebruikt deze tensor om de variabele te initialiseren.

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

Uitvoer

(2, 2) 

Tijdelijke aanduiding

Een tijdelijke aanduiding heeft als doel de tensor te voeden. Tijdelijke aanduiding wordt gebruikt om de gegevens te initialiseren om binnen de tensoren te stromen. Om een ​​tijdelijke aanduiding op te geven, moet u de methode feed_dict gebruiken. De tijdelijke aanduiding wordt alleen binnen een sessie ingevoerd.

In het volgende voorbeeld zul je zien hoe je een placeholder maakt met de methode tf.placeholder. In de volgende sessie leer je een tijdelijke aanduiding te voeden met de werkelijke 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. Optionaldata_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")print(data_placeholder_a) 

Uitvoer

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

Sessie

TensorFlow werkt rond 3 hoofdcomponenten:

• Grafiek
• Tensor
• Sessie

Componenten	Beschrijving
Grafiek	De grafiek is fundamenteel in TensorFlow. Alle wiskundige bewerkingen (ops) worden uitgevoerd in een grafiek. U kunt zich een grafiek voorstellen als een project waarin alle bewerkingen worden uitgevoerd. De knooppunten vertegenwoordigen deze operaties, ze kunnen nieuwe tensoren absorberen of creëren.
Tensor	Een tensor vertegenwoordigt de gegevens die tussen bewerkingen doorgaan. Je hebt eerder gezien hoe je een tensor initialiseert. Het verschil tussen een constante en een variabele is dat de beginwaarden van een variabele in de loop van de tijd zullen veranderen.
Sessie	Een sessie voert de bewerking uit vanuit de grafiek. Om de grafiek te voeden met de waarden van een tensor, moet je een sessie openen. Binnen een sessie moet u een operator uitvoeren om een ​​uitvoer te maken.

Grafieken en sessies zijn onafhankelijk. U kunt een sessie uitvoeren en de waarden later gebruiken voor verdere berekeningen.

In het onderstaande voorbeeld:

• Creëer twee tensoren
• Maak een bewerking
• Open een sessie
• Print het resultaat

Stap 1) Je maakt twee tensoren x en y

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

Stap 2) U maakt de operator door x en y te vermenigvuldigen

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

Stap 3) U opent een sessie. Alle berekeningen gebeuren tijdens de sessie. Als u klaar bent, moet u de sessie sluiten.

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

Uitvoer

[8] 

Code uitleg

• tf.Session (): Open een sessie. Alle bewerkingen zullen binnen de sessies verlopen
• run (vermenigvuldigen): voer de bewerking uit die in stap 2 is gemaakt.
• print (resultaat_1): Eindelijk 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 maken, is in een blok. Het voordeel is dat de sessie automatisch wordt afgesloten.

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

Uitvoer

[8] 

In een context van de sessie kunt u de methode eval () gebruiken om de bewerking uit te voeren. Het is gelijk aan run (). Het maakt de code beter leesbaar.

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

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

Uitvoer

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

Variabelen zijn standaard leeg, zelfs nadat u een tensor hebt gemaakt. U moet de variabele initialiseren als u de variabele wilt gebruiken. Het object tf.global_variables_initializer () moet worden aangeroepen om de waarden van een variabele te initialiseren. Dit object zal expliciet alle variabelen initialiseren. Dit is handig voordat u een model gaat trainen.

U kunt de waarden controleren van de variabelen die u eerder heeft gemaakt. Merk op 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)) 

Uitvoer

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

U kunt de tijdelijke aanduiding die u eerder hebt gemaakt, gebruiken en deze voeden met de werkelijke waarde. U moet de gegevens doorgeven aan de methode feed_dict.

U gebruikt bijvoorbeeld de kracht van 2 van de tijdelijke aanduiding 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. 

Code Verklaring

• import numpy als np: importeer numpy-bibliotheek om de gegevens te maken
• tf.pow (data_placeholder_a, 2): Maak de ops
• np.random.rand (1, 10): maak een willekeurige reeks gegevens
• feed_dict = {data_placeholder_a: data}: voed de tijdelijke aanduiding met gegevens

Uitvoer

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

Grafiek

TensorFlow is afhankelijk van een geniale benadering om de operatie weer te geven. Alle berekeningen worden weergegeven met een gegevensstroomschema. De dataflow-grafiek is ontwikkeld om te kijken naar gegevensafhankelijkheden tussen individuele bewerkingen. Wiskundige formule of algoritme bestaat uit een aantal opeenvolgende bewerkingen. Een grafiek is een handige manier om te visualiseren hoe de berekeningen worden gecoördineerd.

De grafiek toont een knoop en een rand . Het knooppunt is de weergave van een bewerking, dwz de rekeneenheid. De rand is de tensor, hij kan een nieuwe tensor produceren of de invoergegevens consumeren. Het hangt af van de afhankelijkheden tussen individuele bewerkingen.

De structuur van de grafiek verbindt de operaties (dwz de knooppunten) met elkaar en hoe deze operaties worden gevoed. Merk op dat de grafiek niet de output van de bewerkingen weergeeft, het helpt alleen om het verband tussen individuele bewerkingen te visualiseren.

Laten we een voorbeeld bekijken.

Stel je voor dat je de volgende functie wilt evalueren:

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

TensorFlow Graph-voorbeeld

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

U kunt bijvoorbeeld zien dat de bewerking add niet eerder kan worden uitgevoerd en. De grafiek legt uit dat het:

1. berekenen en:
2. tel 1) bij elkaar op
3. toevoegen aan 2)
4. voeg 3) toe aan

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 Verklaring

• x: Initialiseer een variabele met de naam 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
• kwadraat: Initialiseer een constante tensor genaamd kwadraat met een constante waarde van 2
• f: Construeer de operator

In dit voorbeeld kiezen we ervoor om de waarden van de variabelen vast te houden. We hebben ook een constante tensor gemaakt met de naam c, de constante parameter in de functie f. Er is een vaste waarde van 5 voor nodig. In de grafiek kun je deze parameter zien in de tensor die constant wordt genoemd.

We hebben ook een constante tensor geconstrueerd voor het vermogen in de operator tf.pow (). Het is niet noodzakelijk. We hebben het gedaan zodat je de naam van de tensor in de grafiek kunt zien. Het is de cirkel die vierkant wordt genoemd.

Uit de grafiek kunt u begrijpen wat er met de tensoren zal gebeuren en hoe deze een uitvoer van 66 kan retourneren.

De onderstaande code evalueert de functie in een sessie.

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) 

Uitvoer

[66] 

Overzicht

TensorFlow werkt rond:

• Grafiek : computeromgeving met de bewerkingen en tensoren
• Tensoren : vertegenwoordigt de gegevens (of waarde) die in de grafiek zullen stromen. Het is de rand in de grafiek
• Sessies : laat de uitvoering van de bewerkingen toe

Creëer een constante tensor

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

Maak een operator

Maak een operator	Voorwerp
a + b	tf.add (a, b)
een * b	tf. vermenigvuldigen (a, b)

Creëer een variabele tensor

Maak een variabele	voorwerp
gerandomiseerde waarde	tf.get_variable ("var", [1, 2])
geïnitialiseerde eerste waarde	tf.get_variable ("var_init_2", dtype = tf.int32, initializer = [[1, 2], [3, 4]])

Open een sessie

Sessie	voorwerp
Maak een sessie	tf.Session ()
Voer een sessie uit	tf.Session.run ()
Evalueer een tensor	variabele_naam.eval ()
Sluit een sessie	sess.close ()
Sessie per blok	met tf.Session () als sess: