Hvad er en tensor i TensorFlow? Form, type & Operatorer

Hvad er en Tensor?

Navnet TensorFlow er afledt direkte fra dens kerneobjekt: tensoren. I TensorFlow involverer enhver beregning tensorer. En tensor er en vektor eller matrix med n dimensioner, der repræsenterer alle typer data. Alle værdier i en tensor har en identisk datatype med en kendt (eller delvist kendt) form, og formen af ​​dataene er dimensionaliteten af ​​matricen eller arrayet.

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

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

I maskinlæring fodres modeller med en liste over objekter kaldet featurevektorer. En featurevektor kan være af en hvilken som helst datatype, og det er normalt det primære input, der udfylder en tensor. Disse værdier flyder ind i en operationsnode gennem tensoren, og resultatet af denne operation opretter en ny tensor, som igen bruges i en ny operation. Alle disse operationer kan ses i grafen.

Repræsentation af en tensor

I TensorFlow er en tensor en samling af featurevektorer (dvs. et array) med n dimensioner. Hvis vi for eksempel har en 2×3-matrix med værdier fra 1 til 6, skriver vi den som matrixen vist nedenfor:

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, tegnes de samme data som en boks med to stablede flader:

TensorFlow repræsenterer denne matrix som:

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

Bemærk: En tensor kan repræsenteres med en skalar eller kan have en form på mere end tre dimensioner. Det er simpelthen sværere at visualisere de højere dimensionsniveauer.

Typer af Tensor

I TensorFlow går alle beregninger 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 udfører med TensorFlow, involverer manipulation af en tensor. Der er fire hovedtensortyper, du kan oprette:

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

I denne vejledning lærer du, hvordan du opretter en tf.constant og en tf.Variable.

En ting du skal huske på, før du kører koden: denne vejledning følger den originale TensorFlow 1.x API, hvor en graf først bygges og udføres senere i en session. TensorFlow 2 kører som standard ivrigt, så flere af symbolerne nedenfor blev flyttet eller fjernet. Hver og en af ​​dem er stadig tilgængelig via tf.compat.v1 navnerummet, og tabellen knytter hver til dets moderne modstykke.

Før du går igennem vejledningen, skal du sørge for at aktivere conda-miljøet, hvor TensorFlow er installeret. Dette miljø hedder hello-tf.

Til macOS brugere:

source activate hello-tf

Til Windows brugere:

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 eksemplet på TensorFlow-tensorformen nedenfor:

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, kør følgende kode.

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

Produktion

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

De tre dele af det output afbildes på de tre tensoregenskaber, som den kommenterede version nedenfor tydeligt viser.

Du kan også give tensoren dit eget navn med name argument.

# 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 sit tensornavn. Hvert tensorobjekt er defineret med attributter såsom en unik etiket (navn), en dimension (form) og en TensorFlow-datatype (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 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)

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 én kolonne.

For at oprette et array med 2 tensordimensioner skal du lukke parenteserne efter hver række. Se eksemplet på tensorformen 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)

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

En matrix med 3 dimensioner konstrueres ved at tilføje et ekstra niveau af parenteser.

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

Resultatet matcher det tredimensionelle boksdiagram, der er vist tidligere i denne vejledning.

Tensorens form

Når du udskriver en tensor, udleder TensorFlow formen. Du kan dog læse formen direkte med TensorFlow. shape ejendom.

Nedenfor konstruerer du en matrix fyldt med tallene fra 10 til 15, og du kontrollerer 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 en 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 enere. Matricen m_shape har 3×2 dimensioner, så følgende kode opretter en tensor med 3 rækker fyldt med enere:

# 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 skriver værdien 1 ind i parentesen, konstruerer du en vektor af enere lig med antallet af kolonner i matricen. 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 3×2-matrix fyldt udelukkende med enere.

print(tf.ones(m_shape.shape))

Produktion

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

Datatype

Den anden egenskab ved en tensor er datatypen. En tensor kan kun indeholde én datatype ad gangen, og du kan læse den type med dtype ejendom.

print(m_shape.dtype)

Produktion

<dtype: &#x27;int32'>

I nogle tilfælde ønsker du at ændre datatypen. I TensorFlow er det muligt med tf.cast fremgangsmåde.

Eksempel

Nedenfor konverteres en flydende tensor til et heltal med cast fremgangsmåde.

# 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: &#x27;float32'>
<dtype: &#x27;int32'>

TensorFlow vælger automatisk datatypen, når argumentet ikke er angivet under oprettelsen af ​​tensoren. TensorFlow gætter den mest sandsynlige datatype: hvis du f.eks. sender tekst, udleder den en streng.

Oprettelse af OperaTor

Nogle nyttige TensorFlow-programmer Operatorer

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 starte med en simpel en og bruge en TensorFlow-metode til at beregne kvadratroden af ​​et tal. Denne operation er ligetil, fordi kun ét argument er nødvendigt for at konstruere tensoren.

Kvadratroden af ​​et tal konstrueres 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 kvadratroden af ​​2. I dette eksempel udskriver du definitionen af ​​tensoren og ikke den faktiske evaluering af operationen. I afsnittet Session nedenfor lærer du, hvordan TensorFlow udfører operationerne.

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

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

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)

Code Forklaring

Opret to tensorer:

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

Du lægger begge tensorer sammen.

Bemærk at begge tensorer skal have samme form. Du kan også 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 oprettet konstante tensorer, hvilket i sig selv er af begrænset nytte. Data ankommer altid med forskellige værdier, og for at registrere det kan du bruge Variable-klassen. En variabel repræsenterer en node, hvis værdier ændrer sig over tid.

For at oprette en variabel kan du bruge tf.get_variable() fremgangsmåde.

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 dette eksempel opretter du en variabel med én række og to kolonner, så du bruger [1, 2] som variablens dimension.

Startværdierne for en tensor kan også være nul. Når du træner en model, skal du for eksempel bruge startværdier, før du beregner 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 også overføre værdierne af en konstant tensor til en variabel. Du opretter en konstant tensor med metoden tf.constant() og brug denne tensor til at initialisere variablen.

De første værdier af variablen er 10, 20, 30 og 40. Den nye tensor har formen 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)

Produktion

(2, 2)

Pladsholder

En pladsholder har til formål at forsyne tensoren. En pladsholder initialiserer de data, der vil flyde inden i tensorerne. For at forsyne en pladsholder bruger du feed_dict argument, og pladsholderen indtastes kun i en session.

I det næste eksempel vil du se, hvordan du opretter en pladsholder med metoden tf.placeholderI sessionsafsnittet lærer du at indsætte en pladsholder med en 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

Grafer og sessioner er uafhængige. Du kan køre en session og gemme værdierne til senere 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 beregningerne sker i sessionen, og når du er færdig, skal du lukke den.

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

Produktion

[8]

Code forklaring

• tf.Session()Åbn en session. Alle handlinger foregår i sessionen.
• run(multiply)udfør den handling, der blev 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 inden for en blok. Fordelen er, at det lukker sessionen automatisk.

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

Produktion

[8]

I forbindelse med en session kan du bruge eval() metode til at udføre operationen. Det svarer til run() og 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 som standard tomme, selv efter du har oprettet tensoren. Du skal initialisere en variabel, før du kan bruge den. Objektet tf.global_variables_initializer() kaldes for at initialisere værdierne for hver variabel på én gang, hvilket er nyttigt, før du træner en model.

Du kan kontrollere værdierne af de variabler, du oprettede før. Bemærk, at du skal bruge `run` 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 indtaste en faktisk værdi i den. Du skal sende dataene til feed_dict argument.

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.

Code Forklaring

• import numpy as np: Importer nusset biblioteket til at oprette dataene
• tf.pow(data_placeholder_a, 2)Opret operationerne
• np.random.rand(1, 10)Opret et tilfældigt dataarray
• feed_dict={data_placeholder_a: data}: Fod 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 gengiver hver operation med et dataflowskema. Dataflowgrafen er designet til at vise dataafhængighederne mellem individuelle operationer. En matematisk formel eller en algoritme er lavet af et antal successive operationer, og en graf er en bekvem måde at visualisere, hvordan disse beregninger er koordineret.

Grafen viser knuder og kanter. En knude er repræsentationen af ​​en operation, dvs. beregningsenheden. En kant er tensoren: den kan producere en ny tensor eller forbruge inputdataene, afhængigt af afhængighederne mellem de enkelte operationer.

Grafens struktur forbinder operationerne (dvs. noderne) sammen og viser, hvordan hver enkelt tilføres. Bemærk, at grafen ikke viser outputtet af operationerne; den hjælper kun med at visualisere forbindelserne mellem dem.

Lad os se et eksempel. Forestil dig, at du vil evaluere følgende funktion:

TensorFlow opbygger en graf for at udføre funktionen. Grafen ser sådan ud:

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

For eksempel er den add Noden kan ikke køre før begge Mul og Pow har produceret deres resultater. Grafen viser, at TensorFlow vil:

1. beregn x·z i Mul knude og x² i Pow node
2. læg disse to resultater sammen i add node
3. Læg z til den sum i add_1 node
4. Læg konstanten 5 til i add_2 node

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 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 holdes værdierne af variablerne faste. Den konstante tensor c er den konstante parameter i funktionen f og antager en fast værdi på 5; i grafen kan du se denne parameter i tensoren kaldet konstanten.

En konstant tensor blev også skabt for potensen i operatoren tf.pow()Det er ikke nødvendigt, men det betyder, at eksponenten vises i grafen som den cirkel, der kaldes kvadratet.

Ud fra grafen kan du følge, hvad der sker med tensorerne, og hvorfor funktionen returnerer 66: 5 × 6 plus 5² plus 6 plus 5 er lig med 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]

TensorFlow Grundlæggende Hurtigreference

De fire tabeller nedenfor samler alle kommandoer, der bruges i denne vejledning, så du kan slå en op uden at skulle rulle tilbage gennem eksemplerne.

Opret en konstant tensor

Opret en operatør

Opret en variabel tensor

Åbn en session

Ofte Stillede Spørgsmål