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.

  • 🔘 Tre egenskaper: Varje tf.Tensor-objekt exponerar ett unikt namn, en form och en dtype.
  • ☑️ Fyra tensortyper: tf.constant, tf.Variable, tf.placeholder och tf.SparseTensor täcker det klassiska API:et.
  • ✅ Rang är lika med kapsling: Varje extra par parenteser lägger till en dimension till formtupeln.
  • 🧪 Uppskjuten utvärdering: Om en operation skrivs ut visas dess definition, inte dess värde, förrän en session kör den.
  • 🛠️ Diagram och session: Grafen lagrar operationerna medan sessionen utför dem och returnerar resultat.
  • ⚠️ Versionsnotering: Sessioner och platshållare tillhör TensorFlow 1.x och finns idag under tf.compat.v1.

Grunderna i TensorFlow: Tensor, form, typ, sessioner och Operatorer

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:

Två gånger tre matris som håller värdena ett till sex inom parentesnotation

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:

Tredimensionell tensor ritad som en ruta med värdena ett till åtta på två staplade ytor

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.Variable
  • tf.constant
  • tf.placeholder
  • tf.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.

Tensorutdata kommenterad med callouts som markerar namn, form och datatyp

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: &#x27;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: &#x27;float32'>
<dtype: &#x27;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 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 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 data
  • tf.pow(data_placeholder_a, 2)Skapa operationerna
  • np.random.rand(1, 10)Skapa en slumpmässig datamatris
  • 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 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:

Formel f för x och z är lika med x gånger z plus x i kvadrat plus z plus fem

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

TensorFlow-graf med X- och Z-variabla noder som matar Mul-, Pow- och tre additionsoperationer

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:

  1. beräkna x·z i Mul nod och x² i Pow nod
  2. lägg ihop de två resultaten i add nod
  3. lägg till z till den summan i add_1 nod
  4. addera konstanten 5 i add_2 nod
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:

Vanliga frågor

Suffixet är utdataindexet för den operation som producerade tensorn. Const:0 betyder den första utdatan från operationen med namnet Const. Operationer med flera utdata är numrerade :0, :1 och så vidare.

Under eager execution, anropa tensorns numpy()-metod, eller skicka den till np.array(). I graf-och-session-stilen som visas här är värdet som returneras av sess.run() redan ett numpy array.array.

En ragged tensor innehåller rader av olika längder, vilket en normal tensor inte kan. Den skapas med tf.ragged.constant och passar data med variabel längd, såsom meningar, där utfyllnad av varje rad till en bredd skulle slösa minne.

TensorFlow tillämpar broadcasting: den jämför formerna från den efterföljande dimensionen bakåt och sträcker ut valfri axel med en längd som matchar. Former som inte kan justeras på detta sätt genererar ett InvalidArgumentError istället för att gissa.

TensorFlow placerar automatiskt operationer på en synlig GPU. För att tvinga fram en enhet, lägg koden i ett block med tf.device('/GPU:0'). Använd först tf.config.list_physical_devices('GPU') för att bekräfta att enheten faktiskt upptäcks.

Båda lagrar typad n-dimensionell data, men en tensor är oföränderlig, kan finnas på en GPU eller TPU och registrerar de operationer som tillämpas på den så att gradienter kan beräknas. En NumPy-array gör ingen av dessa tre saker.

Statiska typkontrollanter och formannoteringsbibliotek jämför deklarerade former mot operationerna i din kod och flaggar felaktigheter innan en körning startar. Redigeringsassistenter visar samma varningar inline, vilket tar bort de flesta trial-and-error-omformningar.ping.

GitHub Copilot föreslår en snabb omskrivning av sessions- och platshållarkod för att möjliggöra snabb exekvering. Verifiera varje förslag, eftersom det ofta föreslår tf.compat.v1-shims där en äkta TensorFlow 2-ersättning finns.

Sammanfatta detta inlägg med: