Grundlæggende om TensorFlow: Tensor, form, type, sessioner & Operatører

Hvad er en Tensor?

Tensorflow's navn er direkte afledt af dets kerneramme: Tensor. I Tensorflow involverer alle beregninger tensorer. En tensor er en vektor eller matrix med n-dimensioner, der repræsenterer alle typer data. Alle værdier i en tensor har identisk datatype med en kendt (eller delvis kendt) form. Datas form er matrixens eller matrixens dimensionalitet.

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

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

I maskinindlæring fødes modeller med en liste over objekter kaldet funktionsvektorer. En funktionsvektor kan være af enhver datatype. Funktionsvektoren vil normalt være den primære input til at udfylde en tensor. Disse værdier flyder 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.

I denne vejledning lærer du TensorFlow basics som -

• Hvad er en Tensor?
• Repræsentation af en Tensor
• Typer af Tensor
• Opret en tensor af n-dimension
• Form af tensor
• Type data
• Opretter operatør
• Nogle nyttige TensorFlow-operatører
• Variabler
• Pladsholder
• Session
• Kurve

Repræsentation af en Tensor

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

Repræsentation af en Tensor

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 repræsenteres med en skalar eller kan have en form på mere end tre dimensioner. Det er bare mere kompliceret at visualisere højere dimension.

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 vil 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 denne vejledning lærer du, hvordan du opretter en tf.constant og en tf.Variable.

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

For MacOS-brugere:

source activate hello-tf 

For Windows-brugere:

activate hello-tf 

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

# Import tfimport tensorflow as tf 

Opret en tensor af n-dimension

Du begynder med oprettelsen af ​​en tensor med en dimension, nemlig en skalar.

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

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 af dimension 0 skal du køre følgende kode

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

Produktion

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

# Named my_scalarr2 = 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 datatyper TensorFlow (dtype).

Du kan definere en tensor med decimalværdier eller med en streng ved at ændre datatypen.

# Decimalr1_decimal = tf.constant(1.12345, tf.float32)print(r1_decimal)# Stringr1_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 af 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 oprette en matrix med 2 tensordimensioner skal du lukke parenteserne efter hver række. Tjek eksemplet på Keras Tensor-form nedenfor

## Rank 2r2_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 konstrueres ved at tilføje et andet niveau med parenteserne.

## Rank 3r3_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 billedet to.

Form af tensor

Når du udskriver tensor, gætter TensorFlow formen. Du kan dog få formen af ​​tensoren med egenskaben TensorFlow-form.

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

# Shape of tensorm_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 oprette en vektor eller en matrix fyldt med 0 eller 1. Hvis du f.eks. Vil oprette en 1-D tensor med en bestemt form på 10, fyldt med 0, kan du køre koden nedenfor:

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

Produktion

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

Ejendommen fungerer også til matrix. Her opretter du en 10x10 matrix fyldt med 1

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

Produktion

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

Du kan bruge formen på en given matrix til at lave en vektor af dem. Matrixen m_shape er 3x2 dimensioner. Du kan oprette en tensor med 3 rækker udfyldt med en med følgende kode:

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

Produktion

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

Hvis du sender værdien 1 i parentes, kan du konstruere en vektor af dem, der svarer til antallet af kolonner i matrixen m_shape.

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

Produktion

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

Endelig kan du oprette en matrix 3x2 med kun en

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 datatypen. En tensor kan kun have en type data ad gangen. En tensor kan kun have en type data. Du kan returnere typen med egenskaben dtype.

print(m_shape.dtype) 

Produktion

I nogle tilfælde vil du ændre datatypen. I TensorFlow er det muligt med tf.cast-metoden.

Eksempel

Nedenfor konverteres en float tensor til heltal ved hjælp af metoden 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) 

Produktion

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

Opretter 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 bruger TensorFlow-metoden til at beregne kvadratet af et tal. Denne operation er ligetil, fordi der kun kræves et 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 den egentlige evaluering af operationen. I det næste afsnit lærer du, hvordan TensorFlow fungerer for at udføre 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.substrakt (a, b)
• tf. flere gange (a, b)
• tf.div (a, b)
• tf.pow (a, b)
• tf.exp (a)
• tf.sqrt (a)

Eksempel

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

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 tilføjer begge tensorer.

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

# Multiplytensor_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 klassen Variabel. Det repræsenterer en knude, hvor værdierne altid ændres.

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

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. 

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 valuesvar = 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 indledende værdier for at beregne vægten af ​​funktionerne. Nedenfor indstiller 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 for 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 for variablen er 10, 20, 30 og 40. Den nye tensor har en form på 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) 

Produktion

(2, 2) 

Pladsholder

En pladsholder har til formål at fodre tensoren. Pladsholder bruges til at initialisere dataene til at flyde inden i tensorerne. For at levere en pladsholder skal du bruge metoden feed_dict. Pladsholderen fodres kun 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 den faktiske tensorværdi.

Syntaksen 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. Optionaldata_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")print(data_placeholder_a) 

Produktion

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

Session

TensorFlow fungerer omkring 3 hovedkomponenter:

• Kurve
• Tensor
• Session

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

Grafer og sessioner er uafhængige. Du kan køre en session og få værdierne til at blive brugt 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 sessionx = tf.constant([2])y = tf.constant([4]) 

Trin 2) Du opretter operatøren ved at gange x og y

## Create operatormultiply = 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 codesess = tf.Session()result_1 = sess.run(multiply)print(result_1)sess.close() 

Produktion

[8] 

Kode forklaring

• tf.Session (): Åbn en session. Alle operationer flyder inden for sessionerne
• kør (multiplicer): udfør den operation, 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 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æselig.

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

## Check the tensors created beforesess = 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 at du opretter en tensor. Du skal initialisere variablen, hvis du vil bruge variablen. Objektet tf.global_variables_initializer () skal kaldes for at initialisere værdierne for en variabel. Dette objekt initialiserer eksplicit alle variabler. Dette er nyttigt, før du træner en model.

Du kan kontrollere værdierne for 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 føje den med den faktiske værdi. Du skal videregive dataene til metoden feed_dict.

For eksempel vil du tage magten i 2 af pladsholderens data_pladsholder_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. 

Kode Forklaring

• importer numpy som np: Importer numpy-bibliotek for at oprette dataene
• tf.pow (data_placeholder_a, 2): Opret ops
• np.random.rand (1, 10): Opret et tilfældigt array af data
• feed_dict = {data_placeholder_a: data}: Feed pladsholderen med data

Produktion

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

Kurve

TensorFlow afhænger af en genial tilgang til at gengive handlingen. Alle beregninger er repræsenteret med et dataflowskema. Dataflytningsgrafen er udviklet til at sikre, at data afhænger mellem individuel operation. Matematisk formel eller algoritme er lavet af en række successive operationer. En graf er en bekvem måde at visualisere, hvordan beregningerne koordineres.

Grafen viser en knude og en kant . Noden er repræsentationen af ​​en operation, dvs. beregningsenheden. Kanten er tensoren, den kan producere en ny tensor eller forbruge inputdataene. Det afhænger af afhængighederne mellem den enkelte operation.

Grafens struktur forbinder operationerne (dvs. knudepunkterne), og hvordan disse fungerer, fødes. Bemærk, at grafen ikke viser output fra operationerne, det hjælper kun med at visualisere forbindelsen mellem individuelle operationer.

Lad os se et eksempel.

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

TensorFlow opretter en graf til udførelse af funktionen. Grafen ser sådan ud:

Eksempel på TensorFlow-graf

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

For eksempel kan du se, at operationen tilføjelse ikke kan udføres før og. Grafen forklarer, at den vil:

1. beregne og:
2. tilføj 1) sammen
3. tilføj til 2)
4. tilføj 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
• firkant: Initialiser en konstant tensor kaldet firkant med en konstant værdi på 2
• f: Konstruer operatøren

I dette eksempel vælger vi at holde værdierne for variablerne faste. Vi oprettede 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 til strømmen i operatøren tf.pow (). Det er ikke nødvendigt. Vi gjorde det, så du kan se navnet på tensoren i grafen. Det er cirklen kaldet firkantet.

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

Koden nedenfor evaluerer funktionen i en session.

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) 

Produktion

[66] 

Resumé

TensorFlow fungerer omkring:

• Graf : Beregningsmiljø, der indeholder operationer og tensorer
• Tensorer : repræsenterer de data (eller værdi), der flyder i grafen. Det er kanten i grafen
• Sessioner : Tillad udførelse 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	Objekt
a + b	tf.add (a, b)
a * b	tf. flere gange (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: