TensorFlow Grunnleggende: Tensor, Shape, Type, Sessions & Operatorer

Hva er en Tensor?

Tensorflows navn er direkte avledet fra kjernerammeverket: Tensor. I Tensorflow involverer alle beregningene tensorer. En tensor er en vektor eller matrise av n-dimensjoner som representerer alle typer data. Alle verdier i en tensor har identisk datatype med en kjent (eller delvis kjent) form. Formen på dataene er dimensjonaliteten til matrisen eller matrisen.

En tensor kan stamme fra inngangsdataene eller resultatet av en beregning. I TensorFlow utføres alle operasjonene i en graf. Grafen er et sett med beregninger som finner sted suksessivt. Hver operasjon kalles en op-node og er koblet til hverandre.

Grafen skisserer operasjonene og forbindelsene mellom nodene. Den viser imidlertid ikke verdiene. Kanten på nodene er tensoren, dvs. en måte å fylle operasjonen med data.

I maskinlæring mates modeller med en liste over objekter som kalles funksjonsvektorer. En egenskapsvektor kan være av hvilken som helst datatype. Funksjonsvektoren vil vanligvis være den primære inngangen for å fylle ut en tensor. Disse verdiene vil flyte inn i en opnode gjennom tensoren og resultatet av denne operasjonen/beregningen vil skape en ny tensor som igjen vil bli brukt i en ny operasjon. Alle disse operasjonene kan sees i grafen.

Representasjon av en tensor

I TensorFlow er en tensor en samling av egenskapsvektorer (dvs. matrise) med n-dimensjoner. For eksempel, hvis vi har en 2×3 matrise med verdier fra 1 til 6, skriver vi:

TensorFlow representerer denne matrisen som:

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

Hvis vi lager en tredimensjonal matrise med verdier fra 1 til 8, har vi:

TensorFlow representerer denne matrisen som:

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

OBS: En tensor kan representeres med en skalar eller kan ha en form på mer enn tre dimensjoner. Det er bare mer komplisert å visualisere høyere dimensjonsnivå.

Typer av tensor

I TensorFlow går alle beregningene gjennom en eller flere tensorer. En tf.tensor er et objekt med tre egenskaper:

• En unik etikett (navn)
• En dimensjon (form)
• En datatype (dtype)

Hver operasjon du skal gjøre med TensorFlow involverer manipulering av en tensor. Det er fire hovedtensortyper du kan lage:

• tf.Variabel
• tf.konstant
• tf.plassholder
• tf.SparseTensor

I denne opplæringen lærer du hvordan du lager en tf.constant og en tf.Variable.

Før vi går gjennom opplæringen, sørg for at du aktiverer conda-miljøet med TensorFlow. Vi kalte dette miljøet hello-tf.

For MacOS-brukere:

source activate hello-tf

Til Windows bruker:

activate hello-tf

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

# Import tf
import tensorflow as tf

Lag en tensor med n-dimensjon

Du begynner med å lage en tensor med én dimensjon, nemlig en skalar.

For å lage en tensor, kan du bruke tf.constant() som vist i TensorFlow-tensorformeksemplet nedenfor:

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 å lage en tensor med dimensjon 0, kjør følgende kode

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

Produksjon

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

# Named my_scalar
r2 = tf.constant(1, tf.int16, name = "my_scalar") 
print(r2)

Produksjon

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

Hver tensor vises med tensornavnet. Hvert tensorobjekt er definert med tensorattributter som en unik etikett (navn), en dimensjon (form) og TensorFlow-datatyper (dtype).

Du kan definere en tensor med desimalverdier eller med en streng ved å endre type data.

# Decimal
r1_decimal = tf.constant(1.12345, tf.float32)
print(r1_decimal)
# String
r1_string = tf.constant("Guru99", tf.string)
print(r1_string)

Produksjon

Tensor("Const_1:0", shape=(), dtype=float32)
Tensor("Const_2:0", shape=(), dtype=string)

En tensor med dimensjon 1 kan opprettes 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)

Produksjon

Tensor("Const_3:0", shape=(3,), dtype=int16)
Tensor("Const_4:0", shape=(3,), dtype=bool)

Du kan legge merke til at TensorFlow-formen bare består av 1 kolonne.

For å lage en rekke med 2 tensordimensjoner, må du lukke parentesene etter hver rad. Sjekk Keras Tensor-formeksemplet nedenfor

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

Produksjon

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

Matrisen har 2 rader og 2 kolonner fylt med verdiene 1, 2, 3, 4.

En matrise med 3 dimensjoner er konstruert ved å legge til et nytt nivå med brakettene.

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

Produksjon

Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16)

Matrisen ser ut som bilde to.

Form på tensor

Når du skriver ut tensor, gjetter TensorFlow formen. Du kan imidlertid få formen til tensoren med TensorFlow-formegenskapen.

Nedenfor konstruerer du en matrise fylt med et tall fra 10 til 15 og du sjekker formen til m_shape

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

Produksjon

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

Matrisen har 3 rader og 2 kolonner.

TensorFlow har nyttige kommandoer for å lage en vektor eller en matrise fylt med 0 eller 1. Hvis du for eksempel vil lage en 1-D tensor med en spesifikk form på 10, fylt med 0, kan du kjøre koden nedenfor:

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

Produksjon

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

Egenskapen fungerer også for matrise. Her lager du en 10×10 matrise fylt med 1

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

Produksjon

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

Du kan bruke formen til en gitt matrise for å lage en vektor av ener. Matrisen m_shape er en 3×2 dimensjon. Du kan lage en tensor med 3 rader fylt med en med følgende kode:

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

Produksjon

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

Hvis du sender verdien 1 inn i parentesen, kan du konstruere en vektor av enere som er lik antall kolonner 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]))

Produksjon

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

Til slutt kan du lage en matrise 3×2 med bare ens

print(tf.ones(m_shape.shape))

Produksjon

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

Type data

Den andre egenskapen til en tensor er typen data. En tensor kan bare ha én type data om gangen. En tensor kan bare ha én type data. Du kan returnere typen med egenskapen dtype.

print(m_shape.dtype)

Produksjon

<dtype: 'int32'>

I noen tilfeller ønsker du å endre type data. I TensorFlow er det mulig med tf.cast-metoden.

Eksempel

Nedenfor konverteres en flyttensor til heltall ved å bruke 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)

Produksjon

<dtype: 'float32'>
<dtype: 'int32'>

TensorFlow velger type data automatisk når argumentet ikke er spesifisert under opprettelsen av tensoren. TensorFlow vil gjette hva som er den mest sannsynlige typen data. For eksempel, hvis du sender en tekst, vil den gjette at det er en streng og konvertere den til en streng.

Oppretter operatør

Noen nyttige TensorFlow-operatører

Du vet hvordan du lager en tensor med TensorFlow. Det er på tide å lære å utføre matematiske operasjoner.

TensorFlow inneholder alle de grunnleggende operasjonene. Du kan begynne med en enkel. Du vil bruke TensorFlow-metoden for å beregne kvadratet til et tall. Denne operasjonen er enkel fordi det bare kreves ett argument for å konstruere tensoren.

Kvadraten til et tall er konstruert med tf.sqrt(x) med x som et flytende tall.

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

Produksjon

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

OBS: Utdataene returnerte et tensorobjekt og ikke resultatet av kvadratet på 2. I eksemplet skriver du ut definisjonen av tensoren og ikke selve evalueringen av operasjonen. I neste avsnitt vil du lære hvordan TensorFlow fungerer for å utføre operasjonene.

Følgende er en liste over ofte brukte operasjoner. Tanken er den samme. Hver operasjon krever ett eller flere argumenter.

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

Eksempel

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

Produksjon

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

Code Forklaring

Lag to tensorer:

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

Du legger sammen begge tensorene.

Legge merke til: at begge tensorene må ha samme form. Du kan utføre en multiplikasjon over de to tensorene.

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

Produksjon

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

Variabler

Så langt har du bare laget konstante tensorer. Det er ikke til stor nytte. Data kommer alltid med forskjellige verdier, for å fange opp dette kan du bruke Variable-klassen. Det vil representere en node der verdiene alltid endres.

For å lage en variabel kan du bruke tf.get_variable() metoden

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.

For eksempel oppretter koden nedenfor en todimensjonal variabel med to tilfeldige verdier. Som standard returnerer TensorFlow en tilfeldig verdi. Du navngir variabelen var

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

Produksjon

(1, 2)

I det andre eksemplet lager du en variabel med én rad og to kolonner. Du må bruke [1,2] for å lage dimensjonen til variabelen

Initialverdiene til denne tensoren er null. For eksempel, når du trener en modell, må du ha startverdier for å beregne vekten av funksjonene. Nedenfor setter du disse startverdiene til null.

var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32,  initializer=tf.zeros_initializer)
print(var_init_1.shape)

Produksjon

(1, 2)

Du kan sende verdiene til en konstant tensor i en variabel. Du lager en konstant tensor med metoden tf.constant(). Du bruker denne tensoren til å initialisere variabelen.

De første verdiene av variabelen er 10, 20, 30 og 40. Den nye tensoren vil ha en form på 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)

Produksjon

(2, 2)

Plassholder

En plassholder har som formål å mate tensoren. Plassholder brukes til å initialisere dataene til å flyte inne i tensorene. For å oppgi en plassholder må du bruke metoden feed_dict. Plassholderen mates bare i løpet av en økt.

I neste eksempel vil du se hvordan du lager en plassholder med metoden tf.placeholder. I neste økt vil du lære å mate en plassholder med faktisk tensorverdi.

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

Produksjon

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

Session

TensorFlow fungerer rundt 3 hovedkomponenter:

• Graph
• tensor
• Session

komponenter	Beskrivelse
Graph	Grafen er grunnleggende i TensorFlow. Alle de matematiske operasjonene (ops) utføres inne i en graf. Du kan forestille deg en graf som et prosjekt der alle operasjoner utføres. Nodene representerer disse operasjonene, de kan absorbere eller lage nye tensorer.
tensor	En tensor representerer dataene som går mellom operasjoner. Du så tidligere hvordan du initialiserer en tensor. Forskjellen mellom en konstant og variabel er at startverdiene til en variabel vil endre seg over tid.
Session	En økt vil utføre operasjonen fra grafen. For å mate grafen med verdiene til en tensor, må du åpne en økt. Inne i en økt må du kjøre en operatør for å lage en utgang.

Grafer og økter er uavhengige. Du kan kjøre en økt og få verdiene til bruk senere for videre beregninger.

I eksemplet nedenfor vil du:

• Lag to tensorer
• Opprett en operasjon
• Åpne en økt
• Skriv ut resultatet

Trinn 1) Du lager to tensorer x og y

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

Trinn 2) Du lager operatoren ved å multiplisere x og y

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

Trinn 3) Du åpner en økt. Alle beregningene vil skje i løpet av økten. Når du er ferdig, må du lukke økten.

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

Produksjon

[8]

Code forklaring

• tf.Session(): Åpne en økt. Alle operasjonene vil flyte i løpet av øktene
• kjør (multipliser): utfør operasjonen opprettet i trinn 2.
• print(result_1): Til slutt kan du skrive ut resultatet
• close(): Lukk økten

Resultatet viser 8, som er multiplikasjonen av x og y.

En annen måte å lage en økt på er inne i en blokk. Fordelen er at den automatisk lukker økten.

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

Produksjon

[8]

I en kontekst av økten kan du bruke metoden eval() for å utføre operasjonen. Det tilsvarer run(). Det gjør koden mer lesbar.

Du kan opprette en økt og se verdiene inne i tensorene du har laget så langt.

## Check the tensors created before
sess = tf.Session()
print(sess.run(r1))
print(sess.run(r2_matrix))
print(sess.run(r3_matrix))

Produksjon

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

Variabler er tomme som standard, selv etter at du har opprettet en tensor. Du må initialisere variabelen hvis du vil bruke variabelen. Objektet tf.global_variables_initializer() må kalles for å initialisere verdiene til en variabel. Dette objektet vil eksplisitt initialisere alle variablene. Dette er nyttig før du trener en modell.

Du kan sjekke verdiene til variablene du opprettet før. Merk at du må bruke run for å evaluere tensoren

sess.run(tf.global_variables_initializer())
print(sess.run(var))
print(sess.run(var_init_1))
print(sess.run(var_init_2))

Produksjon

[[-0.05356491  0.75867283]]
[[0 0]]
[[10 20] 
 [30 40]]

Du kan bruke plassholderen du opprettet før og mate den med faktisk verdi. Du må sende dataene inn i metoden feed_dict.

For eksempel vil du ta kraften til 2 av plassholderen 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 Forklaring

• import numpy som np: Importer numpy bibliotek å lage dataene
• tf.pow(data_placeholder_a, 2): Lag ops
• np.random.rand(1, 10): Lag en tilfeldig rekke data
• feed_dict={data_placeholder_a: data}: Mate plassholderen med data

Produksjon

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

Graph

TensorFlow er avhengig av en genial tilnærming for å gjengi operasjonen. Alle beregningene er representert med et dataflytskjema. Dataflytgrafen er utviklet for å se dataavhengigheter mellom individuelle operasjoner. Matematisk formel eller algoritme er laget av en rekke påfølgende operasjoner. En graf er en praktisk måte å visualisere hvordan beregningene er koordinert.

Grafen viser en node og en kant. Noden er representasjonen av en operasjon, dvs. beregningsenheten. Kanten er tensoren, den kan produsere en ny tensor eller forbruke inndataene. Det avhenger av avhengighetene mellom individuell drift.

Strukturen til grafen kobler sammen operasjonene (dvs. nodene) og hvordan disse er operasjoner. Merk at grafen ikke viser resultatet av operasjonene, den hjelper bare å visualisere sammenhengen mellom individuelle operasjoner.

La oss se et eksempel.

Tenk deg at du vil evaluere følgende funksjon:

TensorFlow vil lage en graf for å utføre funksjonen. Grafen ser slik ut:

Du kan enkelt se banen som tensorene vil ta for å nå den endelige destinasjonen.

Du kan for eksempel se at operasjonen add ikke kan gjøres før og . Grafen forklarer at den vil:

1. beregne og:
2. legg til 1) sammen
3. legg til 2)
4. legg til 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

Code Forklaring

• x: Initialiser en variabel kalt x med en konstant verdi på 5
• z: Initialiser en variabel kalt z med en konstant verdi på 6
• c: Initialiser en konstant tensor kalt c med en konstant verdi på 5
• kvadrat: Initialiser en konstant tensor kalt kvadrat med en konstant verdi på 2
• f: Konstruer operatøren

I dette eksemplet velger vi å holde verdiene til variablene faste. Vi laget også en konstant tensor kalt c som er konstantparameteren i funksjonen f. Det tar en fast verdi på 5. I grafen kan du se denne parameteren i tensoren kalt konstant.

Vi konstruerte også en konstant tensor for kraften i operatoren tf.pow(). Det er ikke nødvendig. Vi gjorde det slik at du kan se navnet på tensoren i grafen. Det er sirkelen som kalles kvadrat.

Fra grafen kan du forstå hva som vil skje med tensorene og hvordan det kan returnere en utgang på 66.

Koden nedenfor evaluerer funksjonen i en økt.

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)

Produksjon

[66]

Sammendrag

tensorflow jobber rundt:

• Graph: Beregningsmiljø som inneholder operasjonene og tensorene
• Tensorer: Representerer dataene (eller verdien) som vil flyte i grafen. Det er kanten i grafen
• Økter: Tillat utførelse av operasjonene

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

Opprett en operatør

Opprett en operatør	Objekt
a + b	tf.add(a, b)
a*b	tf.multiply(a, b)

Lag en variabel tensor

Lag en variabel	objekt
randomisert verdi	tf.get_variable(“var”, [1, 2])
initialisert første verdi	tf.get_variable(“var_init_2”, dtype=tf.int32, initializer=[ [1, 2], [3, 4] ])

Åpne en økt

Session	objekt
Lag en økt	tf.Session()
Kjør en økt	tf.Session.run()
Vurder en tensor	variabelnavn.eval()
Avslutt en økt	sess.close()
Økt for blokk	med tf.Session() som sess: