Grunnleggende om TensorFlow: Tensor, form, type, økter og amp; Operatører

Hva er en Tensor?

Tensorflows navn er direkte avledet fra kjernen: Tensor. I Tensorflow involverer alle beregninger tensorer. En tensor er en vektor eller matrise med 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 blir alle operasjonene utført i en graf. Grafen er et sett av beregninger som foregår suksessivt. Hver operasjon kalles en op-node og er koblet til hverandre.

Grafen skisserer opsjoner og forbindelser mellom nodene. Verdiene vises imidlertid ikke. Kanten av nodene er tensoren, dvs. en måte å fylle operasjonen med data på.

I maskinlæring mates modeller med en liste over objekter som kalles funksjonsvektorer. En funksjonsvektor kan være av hvilken som helst datatype. Funksjonsvektoren vil vanligvis være den primære inngangen for å fylle en tensor. Disse verdiene vil strømme inn i en op-node 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 vises i grafen.

I denne veiledningen lærer du TensorFlow grunnleggende som-

• Hva er en Tensor?
• Representasjon av en Tensor
• Typer Tensor
• Lag en tensor av n-dimensjon
• Form av tensor
• Type data
• Oppretter operatør
• Noen nyttige TensorFlow-operatører
• Variabler
• Plassholder
• Økt
• Kurve

Representasjon av en Tensor

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

Representasjon av en Tensor

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] ] 

Merk: En tensor kan være representert med en skalar eller kan ha en form på mer enn tre dimensjoner. Det er bare mer komplisert å visualisere høyere dimensjonsnivå.

Typer 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 vil gjøre med TensorFlow innebærer 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 du går gjennom opplæringen, må du aktivere kondomiljøet med TensorFlow. Vi kalte dette miljøet hallo-tf.

For MacOS-brukere:

source activate hello-tf 

For Windows-brukere:

activate hello-tf 

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

# Import tfimport tensorflow as tf 

Lag en tensor av n-dimensjon

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

For å lage en tensor, kan du bruke tf.constant () som vist i nedenstående TensorFlow tensorformeksempel:

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

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

Produksjon

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

# Named my_scalarr2 = 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 datatypen.

# Decimalr1_decimal = tf.constant(1.12345, tf.float32)print(r1_decimal)# Stringr1_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 av 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 matrise med to tensordimensjoner, må du lukke parentesene etter hver rad. Sjekk eksemplet på Keras Tensor-form nedenfor

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

Produksjon

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

Matrisen har to 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 parentesene.

## Rank 3r3_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 bildet to.

Form av tensor

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

Under konstruerer du en matrise fylt med et tall fra 10 til 15, og du sjekker formen på m_shape

# Shape of tensorm_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 bestemt form på 10, fylt med 0, kan du kjøre koden nedenfor:

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

Produksjon

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

Eiendommen fungerer også for matrise. Her oppretter du en 10x10 matrise fylt med 1

# Create a vector of 1print(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 en. Matrisen m_shape er en 3x2 dimensjon. Du kan lage en tensor med 3 rader fylt av en med følgende kode:

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

Produksjon

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

Hvis du sender verdien 1 i parentes, kan du konstruere en vektor av lik antall antall kolonner i matrisen m_shape.

# Create a vector of ones with the same number of column as m_shapeprint(tf.ones(m_shape.shape[1])) 

Produksjon

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

Til slutt kan du lage en matrise 3x2 med bare en

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 en type data om gangen. En tensor kan bare ha en type data. Du kan returnere typen med egenskapen dtype.

print(m_shape.dtype) 

Produksjon

I noen tilfeller vil du endre datatypen. I TensorFlow er det mulig med tf.cast-metoden.

Eksempel

Nedenfor konverteres en flyt-tensor til heltall ved hjelp 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) 

Produksjon

TensorFlow velger automatisk datatypen når argumentet ikke er spesifisert under opprettelsen av tensoren. TensorFlow vil gjette hva som er de mest sannsynlige typene data. Hvis du for eksempel sender en tekst, vil den gjette at den er en streng og konvertere den til 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 til å beregne kvadratet til et tall. Denne operasjonen er enkel fordi det bare kreves ett argument for å konstruere tensoren.

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

Merk: Utgangen returnerte et tensorobjekt og ikke resultatet av firkanten på 2. I eksemplet skriver du ut definisjonen av tensoren og ikke den faktiske 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. Ideen er den samme. Hver operasjon krever ett eller flere argumenter.

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

Eksempel

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

Produksjon

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

Kode Forklaring

Lag to tensorer:

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

Du legger opp begge tensorene.

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

# Multiplytensor_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 opprettet konstante tensorer. Det er ikke til stor nytte. Data kommer alltid med forskjellige verdier. For å fange opp dette kan du bruke klassen Variabel. Det vil representere en node der verdiene alltid endres.

For å opprette en variabel kan du bruke 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. 

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 valuesvar = tf.get_variable("var", [1, 2])print(var.shape) 

Produksjon

(1, 2) 

I det andre eksemplet oppretter du en variabel med en 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 innledende verdier for å beregne vekten til funksjonene. Nedenfor setter du denne startverdien 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 overføre verdiene til en konstant tensor i en variabel. Du oppretter en konstant tensor med metoden tf.constant (). Du bruker denne tensoren til å initialisere variabelen.

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

Produksjon

(2, 2) 

Plassholder

En plassholder har som formål å mate tensoren. Plassholder brukes til å initialisere dataene til å strømme inne i tensorene. For å levere en plassholder må du bruke metoden feed_dict. Plassholderen blir matet bare i løpet av en økt.

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

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

Produksjon

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

Økt

TensorFlow fungerer rundt 3 hovedkomponenter:

• Kurve
• Tensor
• Økt

Komponenter	Beskrivelse
Kurve	Grafen er grunnleggende i TensorFlow. Alle matematiske operasjoner (ops) utføres i en graf. Du kan forestille deg en graf som et prosjekt der hver operasjon blir utført. Nodene representerer disse opsjonene, de kan absorbere eller skape nye tensorer.
Tensor	En tensor representerer dataene som går mellom operasjonene. Du så tidligere hvordan du initialiserer en tensor. Forskjellen mellom en konstant og variabel er at de opprinnelige verdiene til en variabel vil endres over tid.
Økt	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 utdata.

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

I eksemplet nedenfor vil du:

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

Trinn 1) Du oppretter to tensorer x og y

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

Trinn 2) Du oppretter operatøren ved å multiplisere x og y

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

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

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

Produksjon

[8] 

Kode forklaring

• tf.Session (): Åpne en økt. Alle operasjonene vil flyte i løpet av øktene
• kjør (multipliser): utfør operasjonen som ble opprettet i trinn 2.
• print (result_1): Til slutt kan du skrive ut resultatet
• lukk (): 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 stenger økten.

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

Produksjon

[8] 

I en sammenheng med økten kan du bruke eval () -metoden til å utføre operasjonen. Det tilsvarer å kjøre (). Det gjør koden mer lesbar.

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

## Check the tensors created beforesess = 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 oppretter 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å overføre dataene til metoden feed_dict.

For eksempel vil du ta makten til 2 av plassholderen data_placeholder_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. 

Kode Forklaring

• importer numpy som np: Importer numpy-bibliotek for å opprette dataene
• tf.pow (data_placeholder_a, 2): Opprett ops
• np.random.rand (1, 10): Lag et tilfeldig utvalg av data
• feed_dict = {data_placeholder_a: data}: Feed plassholderen med data

Produksjon

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

Kurve

TensorFlow er avhengig av en genial tilnærming for å utføre operasjonen. Alle beregningene er representert med et dataflytskjema. Dataflytgrafen er utviklet for å sikre datavhengighet mellom individuell operasjon. Matematisk formel eller algoritme er laget av en rekke påfølgende operasjoner. En graf er en praktisk måte å visualisere hvordan beregningene koordineres på.

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 inngangsdataene. Det avhenger av avhengighetene mellom individuell operasjon.

Grafens struktur forbinder operasjonene (dvs. nodene) og hvordan de opereres blir matet. Merk at grafen ikke viser utdataene fra operasjonene, det 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:

Eksempel på TensorFlow Graph

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

For eksempel kan du se at operasjonen 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 

Kode 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 opprettet 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 operatøren tf.pow (). Det er ikke nødvendig. Vi gjorde det slik at du kan se navnet på tensoren i grafen. Det er sirkelen som heter kvadrat.

Fra grafen kan du forstå hva som vil skje med tensorene, og hvordan det kan gi en effekt på 66.

Koden nedenfor evaluerer funksjonen i en økt.

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) 

Produksjon

[66] 

Sammendrag

TensorFlow fungerer rundt:

• Graf : Beregningsmiljø som inneholder operasjoner og tensorer
• Tensorer : Representerer dataene (eller verdien) som vil strømme i grafen. Det er kanten i grafen
• Økter : Tillat utførelse av operasjonene

Lag en konstant tensor

konstant	gjenstand
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

Lag en operatør	Gjenstand
a + b	tf.add (a, b)
a * b	tf. multiplisere (a, b)

Lag en variabel tensor

Lag en variabel	gjenstand
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

Økt	gjenstand
Lag en økt	tf.Session ()
Kjør en økt	tf.Session.run ()
Evaluer en tensor	variable_name.eval ()
Lukk en økt	sess.close ()
Økt for blokk	med tf.Session () som sess: