TensorFlow Grunderna: Tensor, Form, Typ, Sessioner och Operatorer
Evelyn Clarke
Vad är en Tensor?
Tensorflows namn är direkt härlett från dess kärnramverk: Tensor. I Tensorflow involverar alla beräkningar tensorer. En tensor är en vektor eller matris av 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. Formen på data är dimensionaliteten hos matrisen eller matrisen.
En tensor kan härröra från indata eller resultatet av en beräkning. I TensorFlow utförs alla operationer i en graf. Grafen är en uppsättning beräkningar som sker successivt. Varje operation kallas en op-nod och är kopplade till varandra.
Grafen visar operationerna och kopplingarna mellan noderna. Den visar dock inte värdena. Kanten på noderna är tensorn, dvs ett sätt att fylla operationen med data.
I maskininlärning matas modeller med en lista över objekt som kallas funktionsvektorer. En egenskapsvektor kan vara av vilken datatyp som helst. Funktionsvektorn kommer vanligtvis att vara den primära ingången för att fylla en tensor. Dessa värden kommer att flöda 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 grafen.
Representation av en tensor
I TensorFlow är en tensor en samling funktionsvektorer (dvs. array) med n-dimensioner. Till exempel, om vi har en 2×3-matris med värden från 1 till 6, skriver vi:
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 av mer än tre dimensioner. Det är bara mer komplicerat att visualisera högre dimensionsnivå.
Typer av Tensor
I TensorFlow går 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 involverar manipulering av en tensor. Det finns fyra huvudtensortyper du kan skapa:
- tf.Variabel
- tf.konstant
- tf.platshållare
- tf.SparseTensor
I den här handledningen kommer du att lära dig hur du skapar en tf.constant och en tf.Variable.
Innan vi går igenom handledningen, se till att du aktiverar conda-miljön med TensorFlow. Vi döpte den här miljön till hello-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 tf import tensorflow as tf
Skapa en tensor av n-dimension
Du börjar med att skapa 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 exemplet nedan för 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`
För att skapa en tensor med dimension 0, kör följande kod
## 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)
Varje tensor visas med tensornamnet. 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 typen av 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 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 endast består av en kolumn.
För att skapa en array med 2 tensordimensioner måste du stänga parenteserna efter varje rad. Kontrollera Keras Tensor-formexemplet nedan
## 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)
Matrisen har 2 rader och 2 kolumner fyllda med värdena 1, 2, 3, 4.
En matris med 3 dimensioner konstrueras genom att lägga till ytterligare en nivå med fästena.
## 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)
Matrisen ser ut som på bild två.
Tensorens form
När du skriver ut tensor gissar TensorFlow formen. Du kan dock få formen på tensorn med egenskapen TensorFlow shape.
Nedan konstruerar du en matris fylld med ett tal från 10 till 15 och du kontrollerar formen på m_shape
# Shape of tensor
m_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 0 print(tf.zeros(10))
Produktion
Tensor("zeros:0", shape=(10,), dtype=float32)
Egenskapen fungerar även för matris. Här skapar du en 10×10-matris fylld med 1
# Create a vector of 1 print(tf.ones([10, 10]))
Produktion
Tensor("ones:0", shape=(10, 10), dtype=float32)
Du kan använda formen av en given matris för att göra en vektor av ettor. Matrisen m_shape är en 3×2 dimensioner. Du kan skapa en tensor med 3 rader fyllda med en med följande kod:
# 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)
Om du skickar värdet 1 i parentes kan du konstruera en vektor av ettor som är lika med antalet kolumner i matrisen 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)
Slutligen kan du skapa en matris 3×2 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
<dtype: 'int32'>
I vissa tillfällen vill du ändra typen av data. I TensorFlow är det möjligt med tf.cast-metoden.
Exempelvis
Nedan konverteras en flyttensor till heltal med hjälp av 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äljer typ av data automatiskt när argumentet inte anges under skapandet av tensorn. TensorFlow kommer att gissa vad som är den mest sannolika typen av data. Om du till exempel skickar en text kommer den att gissa att det är en sträng och konvertera den till en sträng.
Skapar operatör
Några användbara TensorFlow-operatorer
Du vet hur man skapar en tensor med TensorFlow. Det är dags att lära sig hur man utför matematiska operationer.
TensorFlow innehåller alla grundläggande funktioner. Du kan börja med en enkel. Du kommer att använda TensorFlow-metoden för att beräkna kvadraten på ett tal. Denna operation är enkel eftersom endast ett argument krävs för att konstruera tensorn.
Kvadraten på ett tal konstrueras 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: Utdatan returnerade ett tensorobjekt och inte resultatet av kvadraten på 2. I exemplet skriver du ut definitionen av tensorn och inte den faktiska utvärderingen av operationen. I nästa avsnitt kommer du att lära dig hur TensorFlow fungerar för att utföra operationerna.
Följande är en lista över vanliga operationer. Tanken är densamma. Varje operation kräver ett eller flera argument.
- 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)
Exempelvis
# 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)
Kodförklaring
Skapa två tensorer:
- en tensor med 1 och 2
- en tensor med 3 och 4
Du lägger ihop båda tensorerna.
meddelande : att båda tensorerna måste ha samma form. Du kan utföra en multiplikation över de två tensorerna.
# Multiply tensor_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 klassen Variable. Det kommer att representera 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. Optional If 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 namnger variabeln var
# Create a Variable
## Create 2 Randomized values
var = 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 initiala värden för att beräkna vikten av funktionerna. Nedan ställer du in dessa initiala vä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 initiera variabeln.
De första värdena på variabeln är 10, 20, 30 och 40. Den nya tensorn kommer att ha formen 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)
platshållare
En platshållare har till syfte att mata tensorn. Platshållare används för att initiera data att flöda inuti tensorerna. För att ange en platshållare måste du använda metoden feed_dict. Platshållaren matas endast under en session.
I nästa exempel kommer du att se hur du skapar en platshållare med metoden tf.placeholder. I nästa session kommer du att lära dig att mata en platshållare med verkligt tensorvärde.
Syntaxen ä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. 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 Test
TensorFlow fungerar runt tre huvudkomponenter:
- Diagrammet
- tensor
- Session Test
| Komponenter | Beskrivning |
|---|---|
| Diagrammet | Grafen är grundläggande i TensorFlow. Alla matematiska operationer (ops) utförs i en graf. Du kan föreställa dig en graf som ett projekt där varje operation görs. Noderna representerar dessa operationer, de kan absorbera eller skapa nya tensorer. |
| tensor | En tensor representerar data som framskrider mellan operationer. Du såg tidigare hur man initierar en tensor. Skillnaden mellan en konstant och variabel är att de initiala värdena för en variabel kommer att förändras över tiden. |
| Session Test | En session kommer att utföra operationen från grafen. För att mata grafen med värdena för 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:
- 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 session x = tf.constant([2]) y = tf.constant([4])
Steg 2) Du skapar operatorn genom att multiplicera x och y
## Create operator multiply = 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 code sess = 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 flyta under sessionerna
- kör (multiplicera): kör operationen som skapades i steg 2.
- print(result_1): Slutligen kan du skriva ut resultatet
- close(): Stäng sessionen
Resultatet visar 8, vilket är multiplikationen av x och y.
Ett annat sätt att skapa en session är inuti ett block. Fördelen är att sessionen stänger automatiskt.
with tf.Session() as sess: result_2 = multiply.eval() print(result_2)
Produktion
[8]
I en sessionskontext 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 inuti tensorerna du skapat hittills.
## 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 är tomma som standard, även efter att du har skapat en tensor. Du måste initiera variabeln om du vill använda variabeln. Objektet tf.global_variables_initializer() måste anropas för att initiera värdena för en variabel. Detta objekt kommer explicit att initialisera alla variabler. Detta är användbart innan du tränar en modell.
Du kan kontrollera värdena för de variabler du skapade tidigare. Observera att du måste använda kör 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 kommer du att ta kraften av 2 av platshållaren 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.
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 array av 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 ]]
Diagrammet
TensorFlow är beroende av en genial metod för att göra operationen. Alla beräkningar representeras med ett dataflödesschema. Dataflödesgrafen har utvecklats för att se till databeroende mellan individuell drift. 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 är koordinerade.
Grafen visar a nod och en kanten. Noden är representationen av en operation, dvs beräkningsenheten. Kanten är tensorn, den kan producera en ny tensor eller konsumera indata. Det beror på beroenden mellan individuell drift.
Strukturen på grafen kopplar samman operationerna (dvs. noderna) och hur de är operationer. Observera att grafen inte visar resultatet av operationerna, det hjälper bara att visualisera sambandet mellan enskilda operationer.
Låt oss se ett exempel.
Föreställ dig att du vill utvärdera följande funktion:
TensorFlow kommer att skapa en graf för att utföra funktionen. Grafen ser ut så här:
Du kan enkelt se vägen som tensorerna tar för att nå slutdestinationen.
Du kan till exempel se att operationen add inte kan göras innan och . Grafen förklarar att det kommer att:
- beräkna och:
- lägg till 1) tillsammans
- lägg till 2)
- 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 heter 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 behålla variablernas värden fasta. Vi skapade också en konstant tensor som heter c som är konstantparametern i funktionen f. Det tar ett fast värde på 5. I grafen kan du se denna parameter i tensorn som kallas konstant.
Vi konstruerade också en konstant tensor för kraften i operatorn tf.pow(). Det är inte nödvändigt. Vi gjorde det så att du kan se namnet på tensorn i grafen. Det är cirkeln som kallas kvadrat.
Från grafen kan du förstå vad som kommer att hända med tensorerna och hur det kan returnera en utdata på 66.
Koden nedan utvärderar 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]
Sammanfattning
TensorFlow arbetar kring:
- Diagrammet: Beräkningsmiljö som innehåller operationerna och tensorerna
- tensorer: Representerar data (eller värde) som kommer att flöda i grafen. Det är kanten i grafen
- sessioner: Tillåt utförande av operationerna
Skapa en konstant tensor
| konstant | objektet |
|---|---|
| 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 | Ändamålet |
|---|---|
| a + b | tf.add(a, b) |
| a * b | tf.multiply(a, b) |
Skapa en variabel tensor
| Skapa en variabel | objektet |
|---|---|
| randomiserat värde | tf.get_variable(“var”, [1, 2]) |
| initierat första värde | tf.get_variable(“var_init_2”, dtype=tf.int32, initializer=[ [1, 2], [3, 4] ]) |
Öppna en session
| Session Test | objektet |
|---|---|
| Skapa en session | tf.Session() |
| Kör en session | tf.Session.run() |
| Utvärdera en tensor | variabelnamn.eval() |
| Stäng en session | sess.close() |
| Session för block | med tf.Session() som sess: |
