TensorFlow-basisprincipes: tensor, vorm, type, sessies en Operaverdraaid

Wat is een tensor?

De naam Tensorflow is rechtstreeks afgeleid van het kernframework: Tensor. In Tensorflow zijn bij alle berekeningen tensoren betrokken. 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 uitgevoerd in een grafiek. De grafiek is een set berekeningen die achtereenvolgens plaatsvinden. Elke bewerking wordt een op-knooppunt genoemd en is met elkaar verbonden.

De grafiek schetst de ops en verbindingen tussen de nodes. De waarden worden echter niet weergegeven. De rand van de nodes is de tensor, oftewel een manier om de operatie te vullen met data.

In Machine Learning worden modellen gevoed met een lijst met objecten die feature vectors worden genoemd. Een feature vector kan van elk gegevenstype zijn. De feature vector is doorgaans de primaire invoer om een ​​tensor te vullen. Deze waarden stromen via de tensor naar een op-node en het resultaat van deze bewerking/berekening creëert een nieuwe tensor die op zijn beurt wordt gebruikt in een nieuwe bewerking. Al deze bewerkingen kunnen worden bekeken in de grafiek.

Weergave van een tensor

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

TensorFlow vertegenwoordigt deze matrix als:

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

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

TensorFlow vertegenwoordigt deze matrix 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 passeren alle berekeningen een of meer tensoren. Een tf.tensor is een object met drie eigenschappen:

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

Elke bewerking die u met TensorFlow uitvoert, omvat de manipulatie van een tensor. Er zijn vier hoofdtypen tensors die u kunt maken:

• tf.Variabele
• tf.constante
• tf.placeholder
• tf.SparseTensor

In deze tutorial leert u hoe u een tf.constant en een tf.Variable maakt.

Voordat we de tutorial doornemen, zorg ervoor dat je de Conda-omgeving activeert met TensorFlow. We hebben deze omgeving hello-tf genoemd.

Voor MacOS-gebruikers:

source activate hello-tf

Voor Windows gebruiker:

activate hello-tf

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

# Import tf
import tensorflow as tf

Creëer een tensor met 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`

Om een ​​tensor van dimensie 0 te maken, 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)

# 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 door de tensornaam. 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 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 met 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)

uitgang

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

U ziet dat de TensorFlow-vorm slechts uit één kolom bestaat.

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

## 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, 4.

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

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

De matrix ziet eruit als afbeelding twee.

Vorm van tensor

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

Hieronder construeer je een matrix gevuld met een getal van 10 tot 15 en controleer je de vorm van 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)

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

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

uitgang

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

U kunt de vorm van een gegeven matrix gebruiken om een ​​vector van enen te maken. De matrix m_shape is een 3×2 dimensie. U kunt een tensor maken met 3 rijen gevuld met enen met de volgende code:

# 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 u de waarde 1 tussen haakjes plaatst, kunt u een vector construeren van enen die gelijk zijn 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 kunt u een matrix van 3×2 maken met slechts één

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 type gegevens. Een tensor kan slechts één type gegevens tegelijk bevatten. Een tensor kan slechts één type gegevens hebben. Je kunt het type retourneren met de eigenschap dtype.

print(m_shape.dtype)

uitgang

<dtype: 'int32'>

In sommige gevallen wilt u het type gegevens wijzigen. In TensorFlow is dit 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 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: 'float32'>
<dtype: 'int32'>

TensorFlow kiest automatisch het type gegevens als het argument niet is opgegeven tijdens het maken van de tensor. TensorFlow raadt wat de meest waarschijnlijke soorten gegevens zijn. Als u bijvoorbeeld een tekst doorgeeft, zal deze raden dat het een string is en deze naar een string converteren.

Operator maken

Enkele nuttige TensorFlow-operatoren

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

TensorFlow bevat alle basisbewerkingen. U kunt beginnen met een eenvoudige. 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 zwevend getal.

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 het resultaat van het kwadraat van 2. In het voorbeeld drukt u de definitie van de tensor af en niet de werkelijke 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(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.

Opmerken: dat beide tensoren dezelfde vorm moeten hebben. Je kunt een vermenigvuldiging uitvoeren over 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 tensoren gecreëerd. Het heeft niet veel nut. Gegevens komen altijd met verschillende waarden binnen. Om dit vast te leggen, kunt u de klasse Variabel 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. 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 noemt de variabele var

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

uitgang

(1, 2)

In het tweede voorbeeld maakt u een variabele met één rij en twee kolommen. U moet [1,2] gebruiken om de dimensie van de variabele te creëren

De initialenwaarden van deze tensor zijn nul. Wanneer u bijvoorbeeld een model traint, moet u over beginwaarden beschikken om het gewicht van de kenmerken 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)

uitgang

(1, 2)

U kunt de waarden van een constante tensor in een variabele doorgeven. Een constante tensor creëer je 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 zal de vorm hebben van 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)

uitgang

(2, 2)

Placeholder

Een tijdelijke aanduiding heeft tot doel de tensor te voeden. Tijdelijke aanduiding wordt gebruikt om de gegevens te initialiseren zodat deze binnen de tensoren stromen. Om een ​​placeholder aan te leveren, moet je de methode feed_dict gebruiken. De tijdelijke aanduiding wordt alleen binnen een sessie ingevoerd.

In het volgende voorbeeld ziet u hoe u een tijdelijke aanduiding maakt met de methode tf.placeholder. In de volgende sessie leert u een tijdelijke aanduiding te voorzien van 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. 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

Componenten	Beschrijving
Diagram	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 ops, ze kunnen nieuwe tensoren absorberen of creëren.
strekspier	Een tensor vertegenwoordigt de gegevens die tussen bewerkingen verlopen. U zag eerder hoe u een tensor initialiseert. Het verschil tussen een constante en een variabele is dat de beginwaarden van een variabele in de loop van de tijd veranderen.
Sessie	Een sessie voert de bewerking uit vanuit de grafiek. Om de grafiek te voeden met de waarden van een tensor, moet u 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 ophalen om later te gebruiken voor verdere berekeningen.

In het onderstaande voorbeeld doet u het volgende:

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

Stap 1) Je creëert twee tensoren x en y

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

Stap 2) Je creëert de operator door x en y te vermenigvuldigen

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

Stap 3) U opent een sessie. Alle berekeningen zullen tijdens de sessie plaatsvinden. Als u klaar bent, moet u de sessie 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 zullen binnen de sessies stromen
• run(multiply): voer de bewerking uit die in stap 2 is gemaakt.
• print(result_1): Ten slotte 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 blok. Het voordeel is dat de sessie automatisch wordt afgesloten.

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

uitgang

[8]

In een context van de sessie kunt u de eval()-methode gebruiken om de bewerking uit te voeren. Het is equivalent aan run(). Het 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 u een tensor hebt gemaakt. Als u de variabele wilt gebruiken, moet u de variabele initialiseren. Het object tf.global_variables_initializer() moet worden aangeroepen om de waarden van een variabele te initialiseren. Dit object initialiseert expliciet alle variabelen. Dit is handig voordat u een model traint.

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

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

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

• numpy importeren als np: Importeren numpige bibliotheek om de gegevens te creëren
• tf.pow(data_placeholder_a, 2): Creëer de ops
• np.random.rand(1, 10): Creëer een willekeurige array met gegevens
• feed_dict={data_placeholder_a: data}: Voed de tijdelijke aanduiding 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 is afhankelijk van een geniale aanpak om de bewerking te renderen. Alle berekeningen worden weergegeven met een dataflowschema. De dataflowgrafiek is ontwikkeld om data-afhankelijkheden tussen individuele bewerkingen te zien. Wiskundige formules of algoritmen zijn gemaakt van een aantal opeenvolgende bewerkingen. Een grafiek is een handige manier om te visualiseren hoe de berekeningen worden gecoördineerd.

De grafiek toont een knooppunt en een rand. De node is de representatie van een operatie, d.w.z. de eenheid van berekening. De edge is de tensor, deze kan een nieuwe tensor produceren of de invoergegevens consumeren. Het hangt af van de afhankelijkheden tussen individuele operaties.

De structuur van de grafiek verbindt de bewerkingen (d.w.z. de knooppunten) en hoe deze bewerkingen worden gevoed. Let op dat de grafiek niet de uitvoer van de bewerkingen weergeeft, het helpt alleen om de verbinding tussen individuele bewerkingen te visualiseren.

Laten we een voorbeeld bekijken.

Stel dat u de volgende functie wilt evalueren:

TensorFlow maakt 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.

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

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

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 kiezen we ervoor om de waarden van de variabelen vast te houden. We hebben ook een constante tensor gemaakt, genaamd c, die de constante parameter is 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 de macht in de operator tf.pow(). Dat is niet nodig. We hebben het gedaan zodat u de naam van de tensor in de grafiek kunt zien. Het is de cirkel genaamd vierkant.

Uit de grafiek kun je begrijpen wat er met de tensoren zal gebeuren en hoe deze een uitvoer van 66 kunnen retourneren.

De onderstaande code evalueert de functie in 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]

Samenvatting

TensorFlow werkt rond:

• Diagram: Computationele omgeving die de bewerkingen en tensoren bevat
• Tensoren: vertegenwoordigt de gegevens (of waarde) die in de grafiek zullen verschijnen. Het is de rand in de grafiek
• Sessions: De uitvoering van de bewerkingen toestaan

Creëer een constante tensor

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

Een operator aanmaken

Een operator aanmaken	Object
a + b	tf.add(a, b)
een * b	tf.vermenigvuldigen(a, b)

Maak een variabele tensor

Maak een variabele	object
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	object
Creëer een sessie	tf.Sessie()
Voer een sessie uit	tf.Session.run()
Evalueer een tensor	variabele_naam.eval()
Sluit een sessie	ses.close()
Sessie per blok	met tf.Session() als sess: