Vad är en tensor i TensorFlow? Form, typ och Operatorer
⚡ Smart sammanfattning
Tensorer är de n-dimensionella matriser som varje TensorFlow-beräkning läser och skriver, var och en med ett namn, en form och en datatyp. Denna genomgång bygger konstanter, variabler, platshållare och operatorer och utvärderar dem sedan i en session.
Vad är en Tensor?
Namnet TensorFlow härleds direkt från dess kärnobjekt: tensorn. I TensorFlow involverar varje beräkning tensorer. En tensor är en vektor eller matris med n dimensioner som representerar alla typer av data. Alla värden i en tensor har en identisk datatyp med en känd (eller delvis känd) form, och formen på data är matrisens eller arrayens dimensionalitet.
En tensor kan härröra från indata eller från resultatet av en beräkning. I TensorFlow utförs alla operationer inuti en graf. Grafen är en uppsättning beräkningar som sker successivt. Varje operation kallas en op-nod, och noderna är kopplade till varandra.
Grafen beskriver operationerna och kopplingarna mellan noderna. Den visar dock inte värdena. Kanten mellan 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 funktionsvektor kan vara av vilken datatyp som helst, och det är vanligtvis den primära inmatningen som fyller en tensor. Dessa värden flödar in i en op-nod genom tensorn, och resultatet av den operationen skapar en ny tensor, som i sin tur används i en ny operation. Alla dessa operationer kan ses i grafen.
Representation av en tensor
I TensorFlow är en tensor en samling av funktionsvektorer (dvs. en array) med n dimensioner. Om vi till exempel har en 2×3-matris med värden från 1 till 6, skriver vi den som matrisen som visas nedan:
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, ritas samma data som en ruta med två staplade sidor:
TensorFlow representerar denna matris som:
[ [[1, 2],
[[3, 4],
[[5, 6],
[[7,8] ]
Obs: En tensor kan representeras med en skalär eller ha en form av mer än tre dimensioner. Det är helt enkelt svårare att visualisera de högre dimensionsnivåerna.
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 utför med TensorFlow involverar manipulation av en tensor. Det finns fyra huvudsakliga tensortyper du kan skapa:
tf.Variabletf.constanttf.placeholdertf.SparseTensor
I den här handledningen får du lära dig hur du skapar en tf.constant och en tf.Variable.
En sak att tänka på innan du kör koden: den här handledningen följer det ursprungliga TensorFlow 1.x API:et, där en graf först byggs och körs senare i en session. TensorFlow 2 körs snabbt som standard, så flera av symbolerna nedan har flyttats eller tagits bort. Var och en av dem är fortfarande tillgänglig via tf.compat.v1 namnrymden, och tabellen mappar var och en till sin moderna motsvarighet.
| TensorFlow 1.x-symbol | TensorFlow 2-ekvivalent |
|---|---|
tf.placeholder() |
Inte obligatoriskt. Ivrig utförande accepterar Python eller NumPy-värden direkt, och en tf.function parametern spelar samma roll i grafläge. |
tf.Session() och sess.run() |
Anropa operationen direkt och läs resultatet, eller linda in beräkningen i tf.function. |
tf.get_variable() |
tf.Variable(), med slätt Python objekt trackunga variablerna istället för samlingarna. |
tf.global_variables_initializer() |
Inte obligatoriskt. A tf.Variable initieras i det ögonblick den skapas. |
tf.div() |
tf.divide()Observera också att subentraction op stavas tf.subtract(), Inte tf.substract(). |
Innan du går igenom handledningen, se till att du aktiverar conda-miljön som har TensorFlow installerat. Denna miljö heter 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 på TensorFlow-tensorformen nedan:
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)
De tre delarna av den utdata mappas till de tre tensoregenskaperna, vilket den kommenterade versionen nedan tydliggör.
Du kan också ge tensorn ett eget namn 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)
Varje tensor visas med sitt tensornamn. Varje tensorobjekt definieras med attribut som en unik etikett (namn), en dimension (form) och en TensorFlow-datatyp (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 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 märka att TensorFlow-formen endast består av en kolumn.
För att skapa en array med två tensordimensioner måste du stänga parenteserna efter varje rad. Se exemplet på tensorformen 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 och 4.
En matris med 3 dimensioner konstrueras genom att lägga till ytterligare en nivå av 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 matchar det tredimensionella låddiagrammet som visades tidigare i den här handledningen.
Tensorns form
När du skriver ut en tensor härleder TensorFlow formen. Du kan dock läsa formen direkt med TensorFlow. shape fast egendom.
Nedan konstruerar du en matris fylld med talen från 10 till 15 och 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 en 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 på en given matris för att skapa en vektor av ettor. Matrisen m_shape har 3×2 dimensioner, så följande kod skapar en tensor med 3 rader fyllda med ettor:
# 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 anger värdet 1 i parentesen konstruerar du en vektor av ettor 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 3×2-matris fylld helt med ental.
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 datatypen. En tensor kan bara innehålla en datatyp åt gången, och du kan läsa den typen med dtype fast egendom.
print(m_shape.dtype)
Produktion
<dtype: 'int32'>
Ibland vill man ändra datatypen. I TensorFlow är det möjligt med tf.cast metod.
Exempelvis
Nedan konverteras en flyttalstensor till ett heltal med cast metod.
# 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 datatypen automatiskt när argumentet inte anges när tensorn skapas. TensorFlow gissar den mest sannolika datatypen: om du till exempel skickar text, härleds en sträng.
Skapa Operator
Några användbara TensorFlow-funktioner 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 operationer. Du kan börja med en enkel och använda en TensorFlow-metod för att beräkna kvadratroten ur ett tal. Denna operation är enkel eftersom endast ett argument krävs för att konstruera tensorn.
Kvadratroten ur ett tal konstrueras med tf.sqrt(x), med x som flyttal.
x = tf.constant([2.0], dtype = tf.float32)
print(tf.sqrt(x))
Produktion
Tensor("Sqrt:0", shape=(1,), dtype=float32)
Obs: Utdata returnerade ett tensorobjekt och inte kvadratroten ur 2. I det här exemplet skriver du ut definitionen av tensorn och inte den faktiska utvärderingen av operationen. I avsnittet Session nedan får du lära dig hur TensorFlow utför 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.subtract(a, b)tf.multiply(a, b)tf.divide(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)
Code Förklaring
Skapa två tensorer:
- en tensor med 1 och 2
- en tensor med 3 och 4
Du lägger ihop båda tensorerna.
Observera att båda tensorerna måste ha samma form. Du kan också 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, vilket i sig har begränsad nytta. Data anländer alltid med olika värden, och för att fånga det kan du använda klassen Variable. En variabel representerar en nod vars värden ändras över tid.
För att skapa en variabel kan du använda tf.get_variable() metod.
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 döper variabeln till var.
# Create a Variable ## Create 2 Randomized values var = tf.get_variable("var", [1, 2]) print(var.shape)
Produktion
(1, 2)
I det här exemplet skapar du en variabel med en rad och två kolumner, så du skickar [1, 2] som variabelns dimension.
Initialvärdena för en tensor kan också vara noll. När du tränar en modell behöver du till exempel initialvärden innan du beräknar vikten av funktionerna. Nedan ställer du in 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 också skicka värdena för en konstant tensor till en variabel. Du skapar en konstant tensor med metoden tf.constant() och använd den tensorn för att initiera variabeln.
Variabelns första värden är 10, 20, 30 och 40. Den nya tensorn 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)
platshållare
En platshållare har till syfte att mata tensorn. En platshållare initierar data som kommer att flöda inuti tensorerna. För att tillhandahålla en platshållare använder du feed_dict argument, och platshållaren matas endast inom en session.
I nästa exempel ser du hur du skapar en platshållare med metoden tf.placeholderI sessionsavsnittet lär du dig att mata en platshållare med ett faktiskt 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 (operationer) utförs inuti en graf. Man kan föreställa sig en graf som ett projekt där varje operation utförs. Noderna representerar dessa operationer, och de kan absorbera eller skapa nya tensorer. |
| tensor | En tensor representerar data som fortskrider mellan operationer. Du såg tidigare hur man initierar en tensor. Skillnaden mellan en konstant och en variabel är att initialvärdena för en variabel kommer att ändras över tid. |
| Session Test | En session utför operationerna 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 operator för att skapa en utdata. |
Grafer och sessioner är oberoende av varandra. Du kan köra en session och spara värdena för senare 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 sker inom sessionen, och när du är klar måste du stänga den.
## Create a session to run the code sess = tf.Session() result_1 = sess.run(multiply) print(result_1) sess.close()
Produktion
[8]
Code förklaring
tf.Session()Öppna en session. Alla operationer inom sessionen sker.run(multiply): kör operationen som skapades i steg 2print(result_1)Slutligen kan du skriva ut resultatetclose()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 det stänger sessionen automatiskt.
with tf.Session() as sess: result_2 = multiply.eval() print(result_2)
Produktion
[8]
I samband med en session kan du använda eval() metod för att utföra operationen. Det motsvarar run() och 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 tensorn. Du måste initiera en variabel innan du kan använda den. Objektet tf.global_variables_initializer() anropas för att initiera värdena för varje variabel samtidigt, vilket är användbart innan du tränar en modell.
Du kan kontrollera värdena på variablerna du skapade tidigare. Observera att du behöver 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 ett faktiskt värde. Du måste skicka in data till feed_dict argument.
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.
Code Förklaring
import numpy as np: Importera numpy bibliotek för att skapa datatf.pow(data_placeholder_a, 2)Skapa operationernanp.random.rand(1, 10)Skapa en slumpmässig datamatrisfeed_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 renderar varje operation med ett dataflödesschema. Dataflödesgrafen utformades för att exponera databeroenden mellan enskilda operationer. En matematisk formel eller en algoritm består av ett antal successiva operationer, och en graf är ett bekvämt sätt att visualisera hur dessa beräkningar är koordinerade.
Grafen visar noder och kanter. En nod är representationen av en operation, dvs. beräkningsenheten. En kant är tensorn: den kan producera en ny tensor eller konsumera indata, beroende på beroendena mellan de enskilda operationerna.
Grafens struktur kopplar samman operationerna (dvs. noderna) och visar hur var och en matas. Observera att grafen inte visar resultatet av operationerna; den hjälper bara till att visualisera kopplingarna mellan dem.
Låt oss se ett exempel. Tänk dig att du vill utvärdera följande funktion:
TensorFlow skapar en graf för att exekvera funktionen. Grafen ser ut så här:
Du kan enkelt se vägen som tensorerna tar för att nå slutdestinationen.
Exempelvis add noden kan inte köras före båda Mul och Pow har producerat sina resultat. Diagrammet visar att TensorFlow kommer att:
- beräkna x·z i
Mulnod och x² iPownod - lägg ihop de två resultaten i
addnod - lägg till z till den summan i
add_1nod - addera konstanten 5 i
add_2nod
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 Fö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 hålls variablernas värden fasta. Den konstanta tensorn c är den konstanta parametern i funktionen f och antar ett fast värde på 5; i grafen kan du se denna parameter i tensorn som kallas konstant.
En konstant tensor skapades också för potensen i operatorn tf.pow()Det är inte nödvändigt, men det betyder att exponenten visas i grafen som cirkeln som kallas kvadrat.
Från grafen kan du följa vad som händer med tensorerna och varför funktionen returnerar 66: 5 × 6 plus 5² plus 6 plus 5 är lika med 66.
Koden nedan utvärderar funktionen inuti 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-grunderna – snabbreferens
De fyra tabellerna nedan samlar alla kommandon som används i den här handledningen så att du kan slå upp ett utan att behöva bläddra tillbaka genom exemplen.
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 | variable_name.eval() |
| Stäng en session | sess.close() |
| Session för block | with tf.Session() as sess: |




