TensorFlow põhitõed: tensor, kuju, tüüp, seansid ja Operatorse

Mis on tensor?

Tensorflow nimi on otseselt tuletatud selle põhiraamistikust: Tensor. Tensorflow'is hõlmavad kõik arvutused tensoreid. Tensor on n-mõõtmeline vektor või maatriks, mis esindab igat tüüpi andmeid. Kõik tensori väärtused sisaldavad identset andmetüüpi teadaoleva (või osaliselt teadaoleva) kujuga. Andmete kuju on maatriksi või massiivi mõõtmed.

Tensor võib tuleneda sisendandmetest või arvutuse tulemusest. TensorFlow's tehakse kõik toimingud graafiku sees. Graafik on arvutuste kogum, mis toimub järjestikku. Iga toimingut nimetatakse opsõlmeks ja need on üksteisega ühendatud.

Graafik kirjeldab toimingud ja sõlmedevahelised ühendused. Väärtusi see aga ei kuva. Sõlmede serv on tensor, st viis operatsiooni andmetega täitmiseks.

Masinõppes edastatakse mudelid objektide loendiga, mida nimetatakse funktsioonivektoriteks. Funktsioonivektor võib olla mis tahes andmetüübiga. Tunnuste vektor on tavaliselt esmane sisend tensori sisestamiseks. Need väärtused voolavad tensori kaudu op-sõlme ja selle toimingu/arvutuse tulemus loob uue tensori, mida omakorda kasutatakse uues toimingus. Kõiki neid toiminguid saab graafikult vaadata.

Tensori kujutamine

TensorFlow's on tensor n-mõõtmeliste tunnusvektorite (st massiivi) kogum. Näiteks kui meil on 2 × 3 maatriks väärtustega 1 kuni 6, kirjutame:

TensorFlow esindab seda maatriksit järgmiselt:

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

Kui loome kolmemõõtmelise maatriksi väärtustega 1 kuni 8, saame:

TensorFlow esindab seda maatriksit järgmiselt:

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

Märge: Tensorit saab esitada skalaariga või sellel võib olla rohkem kui kolmemõõtmeline kuju. Kõrgema dimensioonitaseme visualiseerimine on lihtsalt keerulisem.

Tensori tüübid

TensorFlow's läbivad kõik arvutused ühe või mitu tensorit. tf.tensor on kolme omadusega objekt:

• Unikaalne silt (nimi)
• Mõõt (kuju)
• Andmetüüp (dtype)

Iga TensorFlow'ga tehtav toiming hõlmab tensoriga manipuleerimist. Saate luua nelja peamist tensoritüüpi:

• tf.Muutuja
• tf.konstant
• tf.placeholder
• tf.SparseTensor

Sellest õpetusest saate teada, kuidas luua tf.constant ja tf.Variable.

Enne õpetuse läbimist veenduge, et aktiveeriksite Conda keskkonna TensorFlow abil. Panime sellele keskkonnale nimeks tere-tf.

MacOS-i kasutajale:

source activate hello-tf

eest Windows kasutaja:

activate hello-tf

Kui olete seda teinud, olete valmis tensorflow importimiseks

# Import tf
import tensorflow as tf

Loo n-mõõtme tensor

Alustate ühe mõõtmega tensori, nimelt skalaari loomisega.

Tensori loomiseks võite kasutada tf.constant(), nagu on näidatud allolevas TensorFlow tensorikuju näites:

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`

Dimensiooni 0 tensori loomiseks käivitage järgmine kood

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

Väljund

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

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

Väljund

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

Iga tensor kuvatakse tensori nime all. Iga tensorobjekt on määratletud tensoriatribuutidega, nagu kordumatu silt (nimi), mõõde (kuju) ja TensorFlow andmetüübid (dtype).

Tensori saate määratleda kümnendväärtustega või stringiga, muutes andmete tüüpi.

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

Väljund

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

Dimensiooni 1 tensori saab luua järgmiselt:

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

Väljund

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

Võite märgata, et TensorFlow kuju koosneb ainult ühest veerust.

Kahest tensorimõõtmest koosneva massiivi loomiseks peate sulgema iga rea ​​järel sulud. Vaadake allolevat Keras Tensori kuju näidet

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

Väljund

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

Maatriksis on 2 rida ja 2 veergu, mis on täidetud väärtustega 1, 2, 3, 4.

Kolmemõõtmeline maatriks konstrueeritakse, lisades sulgudega veel ühe taseme.

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

Väljund

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

Maatriks näeb välja nagu pilt kaks.

Tensori kuju

Tensori printimisel arvab TensorFlow kuju ära. Tensori kuju saate aga TensorFlow kuju omadusega.

Allpool koostate maatriksi, mis on täidetud arvuga 10 kuni 15 ja kontrollite m_shape kuju

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

Väljund

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

Maatriksis on 3 rida ja 2 veergu.

TensorFlow'l on kasulikud käsud 0 või 1-ga täidetud vektori või maatriksi loomiseks. Näiteks kui soovite luua 1-D tensori konkreetse kujuga 10, mis on täidetud 0-ga, saate käivitada alloleva koodi:

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

Väljund

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

Vara töötab ka maatriksi jaoks. Siin loote 10 × 10 maatriksi, mis on täidetud 1-ga

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

Väljund

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

Saate kasutada antud maatriksi kuju, et luua neist maatriksist vektor. Maatriks m_kuju on mõõtmetega 3 × 2. Saate luua tensori, millel on 3 rida, mis on täidetud järgmise koodiga:

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

Väljund

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

Kui annate väärtuse 1 sulgudesse, saate koostada vektori, mis võrdub maatriksi m_kuju veergude arvuga.

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

Väljund

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

Lõpuks saate luua maatriksi 3 × 2 ainult ühe maatriksiga

print(tf.ones(m_shape.shape))

Väljund

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

Andmete tüüp

Tensori teine ​​omadus on andmete tüüp. Tensoril saab korraga olla ainult ühte tüüpi andmeid. Tensoril võib olla ainult ühte tüüpi andmeid. Tüübi saate tagastada atribuudiga dtype.

print(m_shape.dtype)

Väljund

<dtype: 'int32'>

Mõnel juhul soovite andmete tüüpi muuta. TensorFlow's on see võimalik tf.cast meetodil.

Näide

Allpool teisendatakse hõljuktensor täisarvuks, kasutades cast meetodit.

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

Väljund

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

TensorFlow valib andmete tüübi automaatselt, kui argumenti tensori loomisel ei täpsustata. TensorFlow arvab ära, millised on kõige tõenäolisemad andmetüübid. Näiteks kui edastate teksti, arvab see, et see on string, ja teisendab selle stringiks.

Operaatori loomine

Mõned kasulikud TensorFlow operaatorid

Teate, kuidas TensorFlow abil tensorit luua. On aeg õppida matemaatilisi tehteid sooritama.

TensorFlow sisaldab kõiki põhitoiminguid. Võite alustada lihtsast. Arvu ruudu arvutamiseks kasutate TensorFlow meetodit. See toiming on lihtne, kuna tensori konstrueerimiseks on vaja ainult ühte argumenti.

Arvu ruut konstrueeritakse tf.sqrt(x) abil, kus x on ujuv arv.

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

Väljund

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

Märge: Väljund tagastas tensoriobjekti, mitte ruudu 2 tulemuse. Näites trükitakse tensori definitsioon, mitte tehte tegelik hinnang. Järgmises jaotises saate teada, kuidas TensorFlow toiminguid teostab.

Järgnevalt on toodud sagedamini kasutatavate toimingute loend. Idee on sama. Iga toiming nõuab ühte või mitut argumenti.

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

Näide

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

Väljund

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

Koodi selgitus

Looge kaks tensorit:

• üks tensor 1 ja 2-ga
• üks tensor 3 ja 4-ga

Liidate mõlemad tensorid kokku.

teade: et mõlemad tensorid peavad olema sama kujuga. Saate sooritada kahe tensori korrutamise.

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

Väljund

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

Muutujad

Seni olete loonud ainult konstantseid tensoreid. Sellest pole suurt kasu. Andmed saabuvad alati erinevate väärtustega, selle jäädvustamiseks võite kasutada klassi Muutuja. See tähistab sõlme, kus väärtused alati muutuvad.

Muutuja loomiseks võite kasutada meetodit 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.

Näiteks loob allolev kood kahe juhusliku väärtusega kahemõõtmelise muutuja. Vaikimisi tagastab TensorFlow juhusliku väärtuse. Nimetate muutujale var

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

Väljund

(1, 2)

Teises näites loote ühe rea ja kahe veeruga muutuja. Muutuja dimensiooni loomiseks peate kasutama [1,2]

Selle tensori algväärtused on null. Näiteks kui treenite mudelit, peavad teil olema algväärtused, et arvutada funktsioonide kaal. Allpool määrate need algväärtused nulliks.

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

Väljund

(1, 2)

Muutujas saate edastada konstantse tensori väärtused. Konstanttensori loote meetodiga tf.constant(). Seda tensorit kasutate muutuja lähtestamiseks.

Muutuja esimesed väärtused on 10, 20, 30 ja 40. Uus tensor saab olema 2×2 kujuga.

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

Väljund

(2, 2)

kohatäitja

Kohahoidja eesmärk on tensorit toita. Kohatäidet kasutatakse andmete lähtestamiseks, et need voolaksid tensorites. Kohatäide esitamiseks peate kasutama meetodit feed_dict. Kohatäidet sisestatakse ainult seansi jooksul.

Järgmises näites näete, kuidas luua kohahoidja meetodiga tf.placeholder. Järgmisel seansil õpite sisestama tegeliku tensori väärtusega kohahoidjat.

Süntaks on:

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)

Väljund

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

istung

TensorFlow töötab kolme põhikomponendi ümber:

• Graafik
• pinguti
• istung

Kompkletis	Kirjeldus
Graafik	Graafik on TensorFlow's põhiline. Kõik matemaatilised toimingud (ops) tehakse graafikus. Võite kujutada graafikut ette projektina, kus kõik toimingud tehakse. Sõlmed esindavad neid opsid, nad võivad absorbeerida või luua uusi tensoreid.
pinguti	Tensor tähistab andmeid, mis liiguvad operatsioonide vahel. Näete varem, kuidas tensorit lähtestada. Konstandi ja muutuja erinevus seisneb selles, et muutuja algväärtused muutuvad aja jooksul.
istung	Seanss teostab toimingu graafikult. Graafiku esitamiseks tensori väärtustega peate avama seansi. Seansi sees peate väljundi loomiseks käivitama operaatori.

Graafikud ja seansid on sõltumatud. Saate käivitada seansi ja hankida väärtused, mida hiljem edasiste arvutuste jaoks kasutada.

Allolevas näites saate teha järgmist.

• Loo kaks tensorit
• Loo operatsioon
• Ava seanss
• Printige tulemus

Step 1) Loote kaks tensorit x ja y

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

Step 2) Operaatori loote x ja y korrutamisega

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

Step 3) Avate seansi. Kõik arvutused toimuvad seansi jooksul. Kui olete lõpetanud, peate seansi sulgema.

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

Väljund

[8]

Koodi selgitus

• tf.Session(): seansi avamine. Kõik toimingud toimuvad seansside sees
• run(multiply): käivitage sammus 2 loodud toiming.
• print(tulemus_1): Lõpuks saate tulemuse printida
• close(): seansi sulgemine

Tulemuseks on 8, mis on x ja y korrutis.

Teine võimalus seansi loomiseks on ploki sees. Eeliseks on see, et see sulgeb seansi automaatselt.

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

Väljund

[8]

Seansi kontekstis saate operatsiooni läbiviimiseks kasutada meetodit eval(). See on samaväärne funktsiooniga run (). See muudab koodi loetavamaks.

Saate luua seansi ja näha seni loodud tensorite sees olevaid väärtusi.

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

Väljund

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

Muutujad on vaikimisi tühjad isegi pärast tensori loomist. Kui soovite muutujat kasutada, peate muutuja lähtestama. Muutuja väärtuste lähtestamiseks tuleb kutsuda objekt tf.global_variables_initializer(). See objekt lähtestab selgesõnaliselt kõik muutujad. See on kasulik enne modelli koolitamist.

Saate kontrollida varem loodud muutujate väärtusi. Pange tähele, et tensori hindamiseks peate kasutama käsku Run

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

Väljund

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

Saate kasutada varem loodud kohatäit ja toita seda tegeliku väärtusega. Peate andmed edastama meetodisse feed_dict.

Näiteks võtate kohatäite andmete_kohahoidja_a võimsuse 2.

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.

Koodi selgitus

• import numpy as np: Import tuim raamatukogu andmete loomiseks
• tf.pow(data_placeholder_a, 2): loo operatsioonid
• np.random.rand(1, 10): looge juhuslik andmete massiiv
• feed_dict={data_placeholder_a: data}: sisestage kohahoidja andmetega

Väljund

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

Graafik

TensorFlow sõltub geniaalsest lähenemisest operatsiooni renderdamisel. Kõik arvutused on esitatud andmevoo skeemiga. Andmevoo graafik on välja töötatud selleks, et näha andmete sõltuvust üksikute toimingute vahel. Matemaatiline valem või algoritm koosnevad mitmest järjestikusest operatsioonist. Graafik on mugav viis arvutuste koordineerimise visualiseerimiseks.

Graafik näitab a sõlme ja serv. Sõlm on operatsiooni esitus ehk arvutusühik. Serv on tensor, see võib toota uue tensori või tarbida sisendandmeid. See sõltub üksikute toimingute vahelistest sõltuvustest.

Graafiku struktuur ühendab omavahel operatsioonid (st sõlmed) ja nende toimimise viisi. Pange tähele, et graafik ei näita tehte väljundit, see aitab ainult visualiseerida üksikute toimingute vahelist seost.

Vaatame näidet.

Kujutage ette, et soovite hinnata järgmist funktsiooni:

TensorFlow loob funktsiooni täitmiseks graafiku. Graafik näeb välja selline:

Näete hõlpsalt teed, mida tensorid lõppsihtkohta jõuavad.

Näiteks näete toimingut lisamist ei saa teha enne ja . Graafik selgitab, et see:

1. arvutada ja:
2. lisage 1) kokku
3. lisa 2-le)
4. lisada 3) juurde

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

Koodi selgitus

• x: initsialiseerige muutuja nimega x konstantse väärtusega 5
• z: initsialiseerige muutuja nimega z konstantse väärtusega 6
• c: initsialiseerige konstantne tensor nimega c konstantse väärtusega 5
• ruut: lähtestage konstantne tensor nimega ruut konstantse väärtusega 2
• f: konstrueerige operaator

Selles näites otsustame jätta muutujate väärtused fikseerituks. Samuti lõime konstantse tensori nimega c, mis on funktsiooni f konstantne parameeter. See võtab fikseeritud väärtuse 5. Graafikus näete seda parameetrit tensoris, mida nimetatakse konstantseks.

Samuti konstrueerisime operaatori tf.pow() võimsuse jaoks konstantse tensori. See pole vajalik. Tegime seda nii, et näeksite graafikul tensori nime. See on ring, mida nimetatakse ruuduks.

Graafiku põhjal saate aru, mis juhtub tensoritega ja kuidas see tagastab väljundi 66.

Allolev kood hindab funktsiooni seansi jooksul.

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)

Väljund

[66]

kokkuvõte

TensorFlow töötab ümber:

• Graafik: arvutuskeskkond, mis sisaldab tehteid ja tensoreid
• Tensorid: esindab andmeid (või väärtust), mis graafikus voolavad. See on graafiku serv
• Seansid: lubab toiminguid sooritada

Loo konstantne tensor

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

Looge operaator

Looge operaator	objekt
a + b	tf.add(a, b)
a*b	tf.multiply(a, b)

Loo muutuja tensor

Loo muutuja	objekt
randomiseeritud väärtus	tf.get_variable("var", [1, 2])
initsialiseeritud esimene väärtus	tf.get_variable(“var_init_2”, dtype=tf.int32, initsialiseerija=[ [1, 2], [3, 4] ])

Ava seanss

istung	objekt
Loo seanss	tf.Session()
Käivitage seanss	tf.Session.run()
Hinnake tensorit	muutuja_nimi.eval()
Seansi sulgemine	sess.close()
Seanss plokkide kaupa	koos tf.Session() kui sess: