TensorFlow Grundlæggende: Tensor, Form, Type, Sessioner og Operatorer

Hvad er en Tensor?

Tensorflows navn er direkte afledt af dets kerneramme: Tensor. I Tensorflow involverer alle beregninger tensorer. En tensor er en vektor eller matrix af n-dimensioner, der repræsenterer alle typer data. Alle værdier i en tensor har identisk datatype med en kendt (eller delvist kendt) form. Formen af ​​data er dimensionaliteten af ​​matrixen eller arrayet.

En tensor kan stamme fra inputdata eller resultatet af en beregning. I TensorFlow udføres alle operationer inde i en graf. Grafen er et sæt af beregninger, der finder sted successivt. Hver operation kaldes en opnode og er forbundet med hinanden.

Grafen skitserer operationerne og forbindelserne mellem noderne. Den viser dog ikke værdierne. Kanten af ​​noderne er tensoren, dvs. en måde at udfylde operationen med data.

I Machine Learning feeds modeller med en liste over objekter kaldet feature vektorer. En funktionsvektor kan være af enhver datatype. Featurevektoren vil normalt være det primære input til at udfylde en tensor. Disse værdier vil flyde ind i en op-node gennem tensoren, og resultatet af denne operation/beregning vil skabe en ny tensor, som igen vil blive brugt i en ny operation. Alle disse operationer kan ses i grafen.

Repræsentation af en tensor

I TensorFlow er en tensor en samling af trækvektorer (dvs. matrix) af n-dimensioner. For eksempel, hvis vi har en 2×3 matrix med værdier fra 1 til 6, skriver vi:

TensorFlow repræsenterer denne matrix som:

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

Hvis vi opretter en tredimensionel matrix med værdier fra 1 til 8, har vi:

TensorFlow repræsenterer denne matrix som:

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

Bemærk: En tensor kan være repræsenteret med en skalar eller kan have en form på mere end tre dimensioner. Det er bare mere kompliceret at visualisere højere dimensionsniveau.

Typer af Tensor

I TensorFlow passerer alle beregningerne gennem en eller flere tensorer. En tf.tensor er et objekt med tre egenskaber:

• En unik etiket (navn)
• En dimension (form)
• En datatype (dtype)

Hver operation, du skal udføre med TensorFlow, involverer manipulation af en tensor. Der er fire hovedtensortyper, du kan oprette:

• tf.Variabel
• tf.konstant
• tf.pladsholder
• tf.SparseTensor

I dette selvstudie lærer du, hvordan du opretter en tf.constant og en tf.Variable.

Før vi gennemgår selvstudiet, skal du sørge for at aktivere conda-miljøet med TensorFlow. Vi kaldte dette miljø hello-tf.

For MacOS-brugere:

source activate hello-tf

Til Windows bruger:

activate hello-tf

Når du har gjort det, er du klar til at importere tensorflow

# Import tf
import tensorflow as tf

Opret en tensor af n-dimension

Du begynder med skabelsen af ​​en tensor med én dimension, nemlig en skalar.

For at oprette en tensor, kan du bruge tf.constant() som vist i nedenstående TensorFlow tensor form eksempel:

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`

For at oprette en tensor med dimension 0 skal du køre følgende kode

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

Produktion

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

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

Produktion

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

Hver tensor vises med tensornavnet. Hvert tensorobjekt er defineret med tensorattributter som en unik etiket (navn), en dimension (form) og TensorFlow-datatyper (dtype).

Du kan definere en tensor med decimalværdier eller med en streng ved at ændre typen af ​​data.

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

Produktion

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

En tensor med dimension 1 kan oprettes som følger:

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

Produktion

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

Du kan bemærke, at TensorFlow-formen kun består af 1 kolonne.

For at skabe et array med 2 tensordimensioner skal du lukke parenteserne efter hver række. Tjek Keras Tensor-formeksemplet nedenfor

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

Produktion

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

Matrixen har 2 rækker og 2 kolonner fyldt med værdierne 1, 2, 3, 4.

En matrix med 3 dimensioner er konstrueret ved at tilføje endnu et niveau med beslagene.

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

Produktion

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

Matrixen ligner billede to.

Tensorens form

Når du udskriver tensor, gætter TensorFlow formen. Du kan dog få formen på tensoren med TensorFlow-formegenskaben.

Nedenfor konstruerer du en matrix fyldt med et tal fra 10 til 15, og du tjekker formen af ​​m_shape

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

Produktion

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

Matrixen har 3 rækker og 2 kolonner.

TensorFlow har nyttige kommandoer til at skabe en vektor eller en matrix fyldt med 0 eller 1. For eksempel, hvis du vil oprette en 1-D tensor med en specifik form på 10, fyldt med 0, kan du køre koden nedenfor:

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

Produktion

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

Egenskaben fungerer også for matrix. Her opretter du en 10×10 matrix fyldt med 1

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

Produktion

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

Du kan bruge formen af ​​en given matrix til at lave en vektor af dem. Matrixen m_shape er en 3×2 dimensioner. Du kan oprette en tensor med 3 rækker fyldt med én med følgende kode:

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

Produktion

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

Hvis du sender værdien 1 ind i parentesen, kan du konstruere en vektor af ener svarende til antallet af kolonner i matrixen m_shape.

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

Produktion

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

Endelig kan du oprette en matrix 3×2 med kun ens

print(tf.ones(m_shape.shape))

Produktion

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

Type data

Den anden egenskab ved en tensor er typen af ​​data. En tensor kan kun have én type data ad gangen. En tensor kan kun have én type data. Du kan returnere typen med egenskaben dtype.

print(m_shape.dtype)

Produktion

<dtype: 'int32'>

I nogle tilfælde ønsker du at ændre typen af ​​data. I TensorFlow er det muligt med tf.cast metode.

Eksempel

Nedenfor konverteres en flydende tensor til heltal ved at bruge metoden 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)

Produktion

<dtype: 'float32'>
<dtype: 'int32'>

TensorFlow vælger automatisk typen af ​​data, når argumentet ikke er angivet under oprettelsen af ​​tensoren. TensorFlow vil gætte, hvad der er de mest sandsynlige typer data. For eksempel, hvis du sender en tekst, vil den gætte på, at det er en streng og konvertere den til streng.

Oprettelse af operatør

Nogle nyttige TensorFlow-operatører

Du ved, hvordan man opretter en tensor med TensorFlow. Det er tid til at lære at udføre matematiske operationer.

TensorFlow indeholder alle de grundlæggende operationer. Du kan begynde med en simpel. Du vil bruge TensorFlow-metoden til at beregne kvadratet af et tal. Denne operation er ligetil, fordi der kun kræves ét argument for at konstruere tensoren.

Kvadratet af et tal er konstrueret med tf.sqrt(x) med x som et flydende tal.

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

Produktion

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

Bemærk: Outputtet returnerede et tensorobjekt og ikke resultatet af kvadratet på 2. I eksemplet udskriver du definitionen af ​​tensoren og ikke selve evalueringen af ​​operationen. I det næste afsnit vil du lære, hvordan TensorFlow arbejder for at udføre operationerne.

Følgende er en liste over almindeligt anvendte operationer. Tanken er den samme. Hver operation kræver et eller flere argumenter.

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

Eksempel

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

Produktion

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

Kode Forklaring

Opret to tensorer:

• en tensor med 1 og 2
• en tensor med 3 og 4

Du lægger begge tensorer sammen.

Varsel: at begge tensorer skal have samme form. Du kan udføre en multiplikation over de to tensorer.

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

Produktion

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

Variabler

Indtil videre har du kun skabt konstante tensorer. Det er ikke til stor nytte. Data ankommer altid med forskellige værdier, for at fange dette kan du bruge Variable-klassen. Det vil repræsentere en node, hvor værdierne altid ændres.

For at oprette en variabel kan du bruge tf.get_variable() metoden

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.

For eksempel opretter koden nedenfor en todimensionel variabel med to tilfældige værdier. Som standard returnerer TensorFlow en tilfældig værdi. Du navngiver variablen var

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

Produktion

(1, 2)

I det andet eksempel opretter du en variabel med en række og to kolonner. Du skal bruge [1,2] til at oprette dimensionen af ​​variablen

Initialværdierne for denne tensor er nul. For eksempel, når du træner en model, skal du have startværdier for at beregne vægten af ​​funktionerne. Nedenfor sætter du disse startværdier til nul.

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

Produktion

(1, 2)

Du kan overføre værdierne af en konstant tensor i en variabel. Du opretter en konstant tensor med metoden tf.constant(). Du bruger denne tensor til at initialisere variablen.

De første værdier af variablen er 10, 20, 30 og 40. Den nye tensor vil have en form på 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)

Produktion

(2, 2)

Pladsholder

En pladsholder har til formål at fodre tensoren. Pladsholder bruges til at initialisere dataene til at flyde inde i tensorerne. For at angive en pladsholder skal du bruge metoden feed_dict. Pladsholderen vil kun blive fodret inden for en session.

I det næste eksempel vil du se, hvordan du opretter en pladsholder med metoden tf.placeholder. I den næste session lærer du at fodre en pladsholder med faktisk tensorværdi.

Syntaxen er:

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)

Produktion

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

Session

TensorFlow arbejder omkring 3 hovedkomponenter:

• Graf
• tensor
• Session

komponenter	Beskrivelse
Graf	Grafen er grundlæggende i TensorFlow. Alle de matematiske operationer (ops) udføres inde i en graf. Du kan forestille dig en graf som et projekt, hvor alle operationer udføres. Noderne repræsenterer disse ops, de kan absorbere eller skabe nye tensorer.
tensor	En tensor repræsenterer de data, der skrider frem mellem operationer. Du så tidligere, hvordan man initialiserer en tensor. Forskellen mellem en konstant og variabel er, at de indledende værdier af en variabel vil ændre sig over tid.
Session	En session vil udføre operationen fra grafen. For at fodre grafen med værdierne af en tensor, skal du åbne en session. Inde i en session skal du køre en operatør for at oprette et output.

Grafer og sessioner er uafhængige. Du kan køre en session og få værdierne til at bruge senere til yderligere beregninger.

I eksemplet nedenfor vil du:

• Opret to tensorer
• Opret en operation
• Åbn en session
• Udskriv resultatet

Trin 1) Du opretter to tensorer x og y

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

Trin 2) Du opretter operatoren ved at gange x og y

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

Trin 3) Du åbner en session. Alle beregninger vil ske inden for sessionen. Når du er færdig, skal du lukke sessionen.

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

Produktion

[8]

Kode forklaring

• tf.Session(): Åbn en session. Alle operationer vil flyde inden for sessionerne
• kør (multiplicer): udfør operationen oprettet i trin 2.
• print(result_1): Endelig kan du udskrive resultatet
• close(): Luk sessionen

Resultatet viser 8, som er multiplikationen af ​​x og y.

En anden måde at oprette en session på er inde i en blok. Fordelen er, at den automatisk lukker sessionen.

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

Produktion

[8]

I en kontekst af sessionen kan du bruge metoden eval() til at udføre operationen. Det svarer til run(). Det gør koden mere læsbar.

Du kan oprette en session og se værdierne inde i de tensorer, du har oprettet indtil videre.

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

Produktion

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

Variabler er tomme som standard, selv efter du har oprettet en tensor. Du skal initialisere variablen, hvis du vil bruge variablen. Objektet tf.global_variables_initializer() skal kaldes for at initialisere værdierne af en variabel. Dette objekt vil eksplicit initialisere alle variablerne. Dette er nyttigt, før du træner en model.

Du kan kontrollere værdierne for de variabler, du har oprettet før. Bemærk, at du skal bruge kørsel til at evaluere tensoren

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

Produktion

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

Du kan bruge den pladsholder, du oprettede før, og fodre den med faktisk værdi. Du skal overføre dataene til metoden feed_dict.

For eksempel vil du tage magten af ​​2 af pladsholderen 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.

Kode Forklaring

• import numpy som np: Importer numpy bibliotek at oprette dataene
• tf.pow(data_placeholder_a, 2): Opret ops
• np.random.rand(1, 10): Opret en tilfældig række af data
• feed_dict={data_placeholder_a: data}: Foder pladsholderen med data

Produktion

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

Graf

TensorFlow afhænger af en genial tilgang til at udføre operationen. Alle beregningerne er repræsenteret med et dataflowskema. Dataflow-grafen er udviklet til at se dataafhængigheder mellem individuel drift. Matematisk formel eller algoritme er lavet af en række på hinanden følgende operationer. En graf er en bekvem måde at visualisere, hvordan beregningerne er koordineret.

Grafen viser en node og en kant. Noden er repræsentationen af ​​en operation, dvs. beregningsenheden. Kanten er tensoren, den kan producere en ny tensor eller forbruge inputdata. Det afhænger af afhængigheden mellem individuel drift.

Strukturen af ​​grafen forbinder operationerne (dvs. knudepunkterne) og hvordan disse operationer er feed. Bemærk at grafen ikke viser output af operationerne, den hjælper kun med at visualisere sammenhængen mellem individuelle operationer.

Lad os se et eksempel.

Forestil dig, at du vil evaluere følgende funktion:

TensorFlow vil oprette en graf for at udføre funktionen. Grafen ser således ud:

Du kan nemt se den vej, som tensorerne vil tage for at nå den endelige destination.

For eksempel kan du se, at handlingen tilføje ikke kan udføres før og . Grafen forklarer, at det vil:

1. beregne og:
2. lægge 1) sammen
3. tilføje til 2)
4. tilføje 3) til

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

Kode Forklaring

• x: Initialiser en variabel kaldet x med en konstant værdi på 5
• z: Initialiser en variabel kaldet z med en konstant værdi på 6
• c: Initialiser en konstant tensor kaldet c med en konstant værdi på 5
• kvadrat: Initialiser en konstant tensor kaldet kvadrat med en konstant værdi på 2
• f: Konstruer operatøren

I dette eksempel vælger vi at holde værdierne af variablerne faste. Vi lavede også en konstant tensor kaldet c, som er den konstante parameter i funktionen f. Det tager en fast værdi på 5. I grafen kan du se denne parameter i tensoren kaldet konstant.

Vi konstruerede også en konstant tensor for kraften i operatoren tf.pow(). Det er ikke nødvendigt. Vi gjorde det, så du kan se navnet på tensoren i grafen. Det er cirklen kaldet firkant.

Fra grafen kan du forstå, hvad der vil ske med tensorerne, og hvordan det kan returnere et output på 66.

Koden nedenfor evaluerer funktionen i en session.

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)

Produktion

[66]

Resumé

TensorFlow arbejder omkring:

• Graf: Beregningsmiljø, der indeholder operationerne og tensorerne
• tensorer: Repræsenterer de data (eller værdier), der vil flyde i grafen. Det er kanten i grafen
• Sessions: Tillad udførelsen af ​​operationerne

Opret en konstant tensor

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

Opret en operatør

Opret en operatør	Object
a + b	tf.add(a, b)
a * b	tf.multiply(a, b)

Opret en variabel tensor

Opret en variabel	objekt
randomiseret værdi	tf.get_variable(“var”, [1, 2])
initialiseret første værdi	tf.get_variable(“var_init_2”, dtype=tf.int32, initializer=[ [1, 2], [3, 4] ])

Åbn en session

Session	objekt
Opret en session	tf.Session()
Kør en session	tf.Session.run()
Evaluer en tensor	variabel_navn.eval()
Luk en session	sess.close()
Session for blok	med tf.Session() som sess: