TensorFlow Basics: Tensor, form, typ, sessioner & Operatörer

Vad är en Tensor?

Tensorflows namn härrör direkt från dess kärnramverk: Tensor. I Tensorflow involverar alla beräkningar tensorer. En tensor är en vektor eller matris med n-dimensioner som representerar alla typer av data. Alla värden i en tensor har identisk datatyp med en känd (eller delvis känd) form. Datan har formen på matrisen eller matrisen.

En tensor kan härröra från ingångsdata eller resultatet av en beräkning. I TensorFlow utförs alla operationer i ett diagram. Grafen är en uppsättning beräkningar som sker successivt. Varje operation kallas en op-nod och är ansluten till varandra.

Grafen beskriver ops och anslutningar mellan noder. Värdena visas dock inte. Kanten på noderna är tensorn, dvs ett sätt att fylla operationen med data.

I maskininlärning matas modeller med en lista med objekt som kallas funktionsvektorer. En funktionsvektor kan vara av vilken datatyp som helst. Funktionsvektorn är vanligtvis den primära ingången för att fylla en tensor. Dessa värden kommer att strömma in i en op-nod genom tensorn och resultatet av denna operation / beräkning kommer att skapa en ny tensor som i sin tur kommer att användas i en ny operation. Alla dessa operationer kan ses i diagrammet.

I den här handledningen lär du dig grunderna i TensorFlow som-

• Vad är en Tensor?
• Representation av en Tensor
• Typer av Tensor
• Skapa en tensor av n-dimension
• Form av tensor
• Typ av data
• Skapar operatör
• Några användbara TensorFlow-operatörer
• Variabler
• Platshållare
• Session
• Graf

Representation av en Tensor

I TensorFlow är en tensor en samling funktionsvektorer (dvs. array) med n-dimensioner. Till exempel, om vi har en 2x3-matris med värden från 1 till 6, skriver vi:

Representation av en Tensor

TensorFlow representerar denna matris som:

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

Om vi ​​skapar en tredimensionell matris med värden från 1 till 8 har vi:

TensorFlow representerar denna matris som:

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

Obs! En tensor kan representeras med en skalär eller kan ha en form på mer än tre dimensioner. Det är bara mer komplicerat att visualisera högre dimension.

Typer av Tensor

I TensorFlow passerar alla beräkningar genom en eller flera tensorer. En tf.tensor är ett objekt med tre egenskaper:

• En unik etikett (namn)
• En dimension (form)
• En datatyp (dtype)

Varje operation du kommer att göra med TensorFlow innebär manipulation av en tensor. Det finns fyra huvudtensortyper som du kan skapa:

• tf. variabel
• tf. konstant
• tf. platshållare
• tf.SparseTensor

I den här handledningen lär du dig hur du skapar en tf.constant och en tf.Variable.

Innan vi går igenom självstudien, se till att du aktiverar kondomiljön med TensorFlow. Vi kallade den här miljön hej-tf.

För MacOS-användare:

source activate hello-tf 

För Windows-användare:

activate hello-tf 

När du har gjort det är du redo att importera tensorflow

# Import tfimport tensorflow as tf 

Skapa en tensor av n-dimension

Du börjar med skapandet av en tensor med en dimension, nämligen en skalär.

För att skapa en tensor kan du använda tf.constant () som visas i nedanstående TensorFlow-tensorformsexempel:

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` 

För att skapa en tensor av dimension 0, kör följande kod

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

Varje tensor visas med tensorns namn. Varje tensorobjekt definieras med tensorattribut som en unik etikett (namn), en dimension (form) och TensorFlow-datatyper (dtype).

Du kan definiera en tensor med decimalvärden eller med en sträng genom att ändra 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 av dimension 1 kan skapas enligt följande:

## 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 märka att TensorFlow-formen bara består av en kolumn.

För att skapa en matris med två tensordimensioner måste du stänga parenteserna efter varje rad. Kontrollera exemplet på Keras Tensorform nedan

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

Produktion

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

Matrisen har två rader och 2 kolumner fyllda med värdena 1, 2, 3, 4.

En matris med 3 dimensioner är konstruerad genom att lägga till ytterligare en nivå med parenteserna.

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

Matrisen ser ut som bilden två.

Form av tensor

När du skriver ut tensor, gissar TensorFlow formen. Du kan dock få formen på tensorn med TensorFlow-formegenskapen.

Nedan konstruerar du en matris fylld med ett tal från 10 till 15 och du kontrollerar m_shape-formen

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

Produktion

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

Matrisen har 3 rader och 2 kolumner.

TensorFlow har användbara kommandon för att skapa en vektor eller en matris fylld med 0 eller 1. Om du till exempel vill skapa en 1-D-tensor med en specifik form på 10, fylld med 0, kan du köra koden nedan:

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

Produktion

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

Fastigheten fungerar också för matris. Här skapar du en 10x10 matris fylld med 1

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

Produktion

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

Du kan använda formen på en given matris för att skapa en vektor av en. Matrisen m_shape är 3x2 dimensioner. Du kan skapa en tensor med tre rader fyllda av en med följande kod:

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

Om du skickar värdet 1 till parentesen kan du konstruera en vektor som är lika med antalet kolumner i matrisen 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) 

Slutligen kan du skapa en matris 3x2 med endast en

print(tf.ones(m_shape.shape)) 

Produktion

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

Typ av data

Den andra egenskapen hos en tensor är typen av data. En tensor kan bara ha en typ av data åt gången. En tensor kan bara ha en typ av data. Du kan returnera typen med egenskapen dtype.

print(m_shape.dtype) 

Produktion

Vid vissa tillfällen vill du ändra typ av data. I TensorFlow är det möjligt med tf.cast-metoden.

Exempel

Nedan konverteras en flottortensor till heltal med hjälp av 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äljer automatiskt typen av data när argumentet inte specificeras under skapandet av tensorn. TensorFlow kommer att gissa vad som är de mest sannolika typerna av data. Om du till exempel skickar en text kommer den att gissa att den är en sträng och konvertera den till sträng.

Skapar operatör

Några användbara TensorFlow-operatörer

Du vet hur man skapar en tensor med TensorFlow. Det är dags att lära sig att utföra matematiska operationer.

TensorFlow innehåller alla grundläggande operationer. Du kan börja med en enkel. Du kommer att använda TensorFlow-metoden för att beräkna kvadraten för ett tal. Denna operation är enkel eftersom endast ett argument krävs för att konstruera tensorn.

Kvadratet för ett tal är konstruerat med tf.sqrt (x) med x som ett flytande tal.

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

Produktion

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

Obs! Utgången returnerade ett tensorobjekt och inte resultatet av kvadraten 2. I exemplet skriver du ut definitionen av tensor och inte den faktiska utvärderingen av operationen. I nästa avsnitt lär du dig hur TensorFlow fungerar för att utföra operationerna.

Följande är en lista över vanliga operationer. Idén är densamma. Varje operation kräver ett eller flera argument.

• tf.add (a, b)
• tf.substrakt (a, b)
• tf. multiplicera (a, b)
• tf.div (a, b)
• tf.pow (a, b)
• tf.exp (a)
• tf.sqrt (a)

Exempel

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

Kodförklaring

Skapa två tensorer:

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

Du lägger till båda tensorerna.

Observera : att båda tensorerna måste ha samma form. Du kan utföra en multiplikation över de två tensorerna.

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

Produktion

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

Variabler

Hittills har du bara skapat konstanta tensorer. Det är inte till stor nytta. Data kommer alltid med olika värden, för att fånga detta kan du använda variabelklassen. Det representerar en nod där värdena alltid ändras.

För att skapa en variabel kan du använda 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. 

Till exempel skapar koden nedan en tvådimensionell variabel med två slumpmässiga värden. Som standard returnerar TensorFlow ett slumpmässigt värde. Du heter variabeln var

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

Produktion

(1, 2) 

I det andra exemplet skapar du en variabel med en rad och två kolumner. Du måste använda [1,2] för att skapa dimensionen för variabeln

Initialvärdena för denna tensor är noll. Till exempel när du tränar en modell måste du ha initialvärden för att beräkna vikten på funktionerna. Nedan sätter du dessa initialvärden till noll.

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 skicka värdena för en konstant tensor i en variabel. Du skapar en konstant tensor med metoden tf.constant (). Du använder denna tensor för att initialisera variabeln.

De första värdena för variabeln är 10, 20, 30 och 40. Den nya tensorn har en form av 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) 

Platshållare

En platshållare har till syfte att mata tensorn. Platshållare används för att initialisera data för att flöda inuti tensorerna. För att tillhandahålla en platshållare måste du använda metoden feed_dict. Platshållaren matas bara inom en session.

I nästa exempel ser du hur du skapar en platshållare med metoden tf.placeholder. I nästa session lär du dig att mata en platshållare med verkligt tensorvärde.

Syntaksen är:

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 arbetar med tre huvudkomponenter:

• Graf
• Tensor
• Session

Komponenter	Beskrivning
Graf	Grafen är grundläggande i TensorFlow. Alla matematiska operationer (ops) utförs i ett diagram. Du kan föreställa dig ett diagram som ett projekt där alla operationer utförs. Noderna representerar dessa ops, de kan absorbera eller skapa nya tensorer.
Tensor	En tensor representerar data som går mellan operationer. Du såg tidigare hur man initierar en tensor. Skillnaden mellan en konstant och en variabel är att de ursprungliga värdena för en variabel kommer att förändras över tiden.
Session	En session kommer att utföra operationen från diagrammet. För att mata grafen med värdena på en tensor måste du öppna en session. Inuti en session måste du köra en operatör för att skapa en utdata.

Grafer och sessioner är oberoende. Du kan köra en session och få värdena att använda senare för ytterligare beräkningar.

I exemplet nedan kommer du att:

• Skapa två tensorer
• Skapa en operation
• Öppna en session
• Skriv ut resultatet

Steg 1) Du skapar två tensorer x och y

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

Steg 2) Du skapar operatören genom att multiplicera x och y

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

Steg 3) Du öppnar en session. Alla beräkningar kommer att ske under sessionen. När du är klar måste du stänga sessionen.

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

Produktion

[8] 

Kodförklaring

• tf.Session (): Öppna en session. Alla operationer kommer att flöda inom sessionerna
• kör (multiplicera): kör den operation som skapades i steg 2.
• print (result_1): Slutligen kan du skriva ut resultatet
• stäng (): Stäng sessionen

Resultatet visar 8, vilket är multiplikationen av x och y.

Ett annat sätt att skapa en session är i ett block. Fördelen är att den automatiskt stänger sessionen.

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

Produktion

[8] 

I ett sammanhang av sessionen kan du använda metoden eval () för att utföra operationen. Det motsvarar run (). Det gör koden mer läsbar.

Du kan skapa en session och se värdena i tensorerna du hittills skapat.

## 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 är tomma som standard även efter att du skapat en tensor. Du måste initialisera variabeln om du vill använda variabeln. Objektet tf.global_variables_initializer () måste anropas för att initialisera värdena för en variabel. Detta objekt initialiserar uttryckligen alla variabler. Detta är till hjälp innan du tränar en modell.

Du kan kontrollera värdena på variablerna du skapade tidigare. Observera att du måste använda run för att utvärdera tensorn

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 använda platshållaren du skapade tidigare och mata den med verkligt värde. Du måste skicka data till metoden feed_dict.

Till exempel tar du makten i 2 av platshållarens data_platshållare_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. 

Kodförklaring

• importera numpy som np: Importera numpy-bibliotek för att skapa data
• tf.pow (data_placeholder_a, 2): Skapa ops
• np.random.rand (1, 10): Skapa en slumpmässig uppsättning data
• feed_dict = {data_placeholder_a: data}: Mata platshållaren 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 beror på ett genialt tillvägagångssätt för att göra operationen. Alla beräkningar representeras med ett dataflödesschema. Dataflödesdiagrammet har utvecklats för att se till databeroenden mellan enskild operation. Matematisk formel eller algoritm består av ett antal på varandra följande operationer. En graf är ett bekvämt sätt att visualisera hur beräkningarna koordineras.

Diagrammet visar en nod och en kant . Noden är en representation av en operation, dvs beräkningsenheten. Kanten är tensor, den kan producera en ny tensor eller konsumera indata. Det beror på beroendet mellan individuell operation.

Grafens struktur förbinder operationerna (dvs. noderna) och hur de fungerar matas. Observera att diagrammet inte visar resultatet av operationerna, det hjälper bara till att visualisera sambandet mellan enskilda operationer.

Låt oss se ett exempel.

Tänk dig att du vill utvärdera följande funktion:

TensorFlow skapar en graf för att utföra funktionen. Grafen ser ut så här:

Exempel på TensorFlow-graf

Du kan enkelt se den väg som tensorerna tar för att nå slutdestinationen.

Du kan till exempel se att operationen kan inte göras före och. Grafen förklarar att den kommer att:

1. beräkna och:
2. lägg till 1) tillsammans
3. lägg till 2)
4. lägg till 3) till

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 

Kodförklaring

• x: Initiera en variabel som heter x med ett konstant värde på 5
• z: Initiera en variabel som kallas z med ett konstant värde på 6
• c: Initiera en konstant tensor som kallas c med ett konstant värde på 5
• kvadrat: Initiera en konstant tensor som kallas kvadrat med ett konstant värde på 2
• f: Konstruera operatören

I det här exemplet väljer vi att hålla värdena på variablerna fasta. Vi skapade också en konstant tensor kallad c som är den konstanta parametern i funktionen f. Det tar ett fast värde på 5. I diagrammet kan du se denna parameter i den tensor som kallas konstant.

Vi konstruerade också en konstant tensor för kraften i operatören tf.pow (). Det är inte nödvändigt. Vi gjorde det så att du kan se namnet på tensorn i diagrammet. Det är cirkeln som kallas kvadrat.

Från diagrammet kan du förstå vad som kommer att hända med tensorerna och hur det kan ge en effekt på 66.

Koden nedan utvärderar 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] 

Sammanfattning

TensorFlow fungerar:

• Diagram : Beräkningsmiljö som innehåller operationer och tensorer
• Tensorer : Representerar data (eller värde) som kommer att flöda i diagrammet. Det är kanten i diagrammet
• Sessioner : Tillåt utförandet av operationerna

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

Skapa en operatör

Skapa en operatör	Objekt
a + b	tf.add (a, b)
a * b	tf. multiplicera (a, b)

Skapa en variabel tensor

Skapa en variabel	objekt
slumpmässigt värde	tf.get_variable ("var", [1, 2])
initialiserat första värdet	tf.get_variable ("var_init_2", dtype = tf.int32, initializer = [[1, 2], [3, 4]])

Öppna en session

Session	objekt
Skapa en session	tf.Session ()
Kör en session	tf.Session.run ()
Utvärdera en tensor	variable_name.eval ()
Stäng en session	sess.close ()
Session för block	med tf.Session () som sess: