TensorFlow põhitõed: Tensor, kuju, tüüp, seansid & Operaatorid

Mis on tensor?

Tensorflow nimi tuleneb otseselt selle põhiraamistikust: Tensor. Tensorflow'is hõlmavad kõik arvutused tenoreid. Tensor on n-mõõtmete vektor või maatriks, mis esindab igat tüüpi andmeid. Kõigil tensori väärtustel on sama (või osaliselt tuntud) kujuga andmetüüp. Andmete kuju on maatriksi või massiivi mõõtmed.

Tensor võib pärineda sisendandmetest või arvutuse tulemustest. TensorFlow'is viiakse kõik toimingud läbi graafiku sees. Graafik on järjestikuste arvutuste kogum. Iga toimingut nimetatakse op-sõlmeks ja need on omavahel ühendatud.

Graafikul on toodud sõlmede vahelised ops ja ühendused. Kuid see ei näita väärtusi. Sõlmede serv on tensor, st viis, kuidas operatsiooni andmetega täita.

Masinõppes söödetakse mudeleid objektide loendiga, mida nimetatakse funktsioonivektoriteks. Funktsioonivektor võib olla mis tahes tüüpi. Funktsioonivektor on tavaliselt tenori sisestamise peamine sisend. Need väärtused voolavad läbi tensori op-sõlme ja selle toimingu / arvutuse tulemus loob uue tensori, mida omakorda kasutatakse uues operatsioonis. Kõiki neid toiminguid saab graafikult vaadata.

Selles õpetuses õpite TensorFlow põhitõdesid nagu-

• Mis on tensor?
• Tensori esindus
• Tensori tüübid
• Looge n-dimensiooni tenor
• Tensori kuju
• Andmete tüüp
• Operaatori loomine
• Mõned kasulikud TensorFlow-operaatorid
• Muutujad
• Kohatäide
• Seanss
• Graafik

Tensori esindus

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

Tensori esindus

TensorFlow tähistab seda maatriksit järgmiselt:

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

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

TensorFlow tähistab seda maatriksit järgmiselt:

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

Märkus . Tensorit saab kujutada skalaariga või selle kuju võib olla üle kolme mõõtme. Kõrgema dimensiooni taseme visualiseerimine on lihtsalt keerulisem.

Tensori tüübid

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

• Kordumatu silt (nimi)
• Dimensioon (kuju)
• Andmetüüp (dtype)

Iga TensorFlow abil tehtav operatsioon hõlmab manipulatsiooni tensoriga. Teil on neli peamist tensoritüüpi:

• tf. Muutuv
• tf.püsiv
• tf.placeholder
• tf.SparseTensor

Selles õpetuses saate teada, kuidas luua tf.constant ja tf.Variable.

Enne õpetuse läbimist veenduge, et aktiveerite kondakeskkonna TensorFlow abil. Nimetasime sellele keskkonnale hello-tf.

MacOS-i kasutaja jaoks:

source activate hello-tf 

Windowsi kasutajale:

activate hello-tf 

Pärast seda olete valmis tensorflow'i importima

# Import tfimport tensorflow as tf 

Looge n-dimensiooni tenor

Alustate tensori loomisega, millel on üks mõõde, nimelt skalaar.

Tensori loomiseks võite kasutada tf.constant (), nagu on näidatud allpool toodud TensorFlow tensori kuju 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 namer1 = tf.constant(1, tf.int16)print(r1)

Väljund

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

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

Väljund

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

Iga tensor kuvatakse tenori nime järgi. Iga tensoriobjekt on määratletud tensori atribuutidega, nagu kordumatu silt (nimi), dimensioon (kuju) ja TensorFlow andmetüübid (dtype).

Andmetüübi muutmisega saate määrata kümnendi kümnendväärtuste või stringiga.

# Decimalr1_decimal = tf.constant(1.12345, tf.float32)print(r1_decimal)# Stringr1_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 kuju TensorFlow koosneb ainult ühest veerust.

Kahe tensori mõõtmetega massiivi loomiseks peate sulgema sulgema iga rea ​​järel. Vaadake allpool toodud Keras Tensori kuju näidet

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

Väljund

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

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

Kolme mõõtmega maatriks konstrueeritakse, lisades sulgudele veel ühe taseme.

## Rank 3r3_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 teine ​​pilt.

Tensori kuju

Tensori printimisel arvab TensorFlow kuju ära. Tensori kuju saate aga omaduse TensorFlow kuju abil.

Allpool koostate maatriksi, mis on täidetud arvuga 10–15, ja kontrollite m_ kuju kuju

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

Väljund

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

Maatriksil 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, mille konkreetne kuju on 10 ja täidetud 0-ga, võite käivitada alloleva koodi:

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

Väljund

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

Atribuut töötab ka maatriksi jaoks. Siin loote 10x10 maatriksi, mis on täidetud ühega

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

Väljund

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

Nendest maatriksi kuju saate kasutada vektorite moodustamiseks. Maatriks m_shape on 3x2 mõõdet. Võite luua kolmest reast koosneva tensori järgmise koodiga:

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

Väljund

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

Kui kannate väärtuse 1 sulgudesse, saate konstrueerida neist vektori, mis võrdub maatriksi m_shape veergude arvuga.

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

Väljund

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

Lõpuks saate luua maatriksi 3x2 ainult ühega

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

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

Näide

Allpool teisendatakse ujuktensor täisarvuks, kasutades valatud meetodit.

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

Väljund

TensorFlow valib andmete tüübi automaatselt, kui tensori loomise ajal pole argumenti määratud. TensorFlow arvab ära, mis on kõige tõenäolisemad andmetüübid. Näiteks kui edastate teksti, arvab ta, et see on string, ja teisendab selle stringiks.

Operaatori loomine

Mõned kasulikud TensorFlow-operaatorid

Teate, kuidas luua TensorFlow abil tensorit. On aeg õppida matemaatilisi toiminguid tegema.

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

Arvu ruut on konstrueeritud nii, et tf.sqrt (x), 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ärkus . Väljund andis tagasi tensoriobjekti, mitte ruudu 2 tulemuse. Näites printite tenori definitsiooni, mitte operatsiooni tegeliku hinnangu. Järgmises jaotises saate teada, kuidas TensorFlow toimingute sooritamisel töötab.

Järgnevas loendis on tavaliselt kasutatavad toimingud. Idee on sama. Iga toiming nõuab ühte või mitut argumenti.

• tf.add (a, b)
• tf. abstrakt (a, b)
• tf. mitu korda (a, b)
• tf.div (a, b)
• tf.pow (a, b)
• tf.exp (a)
• tf.sqrt (a)

Näide

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

Väljund

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

Koodi selgitus

Looge kaks tensorit:

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

Te liidate mõlemad tenorid.

Pange tähele, et mõlemal tenoril peab olema sama kuju. Võite korrutada kahe tensori.

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

Väljund

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

Muutujad

Siiani olete loonud ainult pidevaid tenoreid. Sellest pole suurt kasu. Andmetel on alati erinevad väärtused, selle hõivamiseks võite kasutada klassi Variable. 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. OptionalIf initializer is specified, there is no need to include the `values` as the shape of `initializer` is used. 

Näiteks loob allolev kood kahemõõtmelise muutuja, millel on kaks juhuslikku väärtust. Vaikimisi tagastab TensorFlow juhusliku väärtuse. Nimetate muutuja var

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

Väljund

(1, 2) 

Teises näites loote muutuja, millel on üks rida ja kaks veergu. Muutuja dimensiooni loomiseks peate kasutama [1,2]

Selle tenori initsiaalide väärtused on null. Näiteks mudeli koolitamisel peab teil olema funktsioonide kaalu arvutamiseks algväärtused. Allpool määrate selle algväärtuse 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) 

Muutuvas saab edastada konstantse tensori väärtused. Pideva tensori loote meetodiga tf.constant (). Selle tensori abil saate muutuja lähtestada.

Muutuja esimesed väärtused on 10, 20, 30 ja 40. Uue tenori kuju on 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) 

Väljund

(2, 2) 

Kohatäide

Kohatäie eesmärk on tenori söötmine. Kohatäitjat kasutatakse andmete initsialiseerimiseks tensorite sees liikumiseks. Kohatäite sisestamiseks peate kasutama meetodit feed_dict. Kohahoidjat söödetakse ainult seansi jooksul.

Järgmises näites näete, kuidas luua kohahoidja meetodiga tf.placeholder. Järgmisel seansil õpid kohatäidet söötma tegeliku tensoriväärtusega.

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

Väljund

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

Seanss

TensorFlow töötab kolme peamise komponendi ümber:

• Graafik
• Tensor
• Seanss

Komponendid	Kirjeldus
Graafik	Graafik on TensorFlow'is põhiline. Kõik matemaatilised toimingud (op) tehakse graafiku sees. Graafi võite ette kujutada projektina, kus kõik toimingud tehakse. Sõlmed esindavad neid ops, nad võivad neelata või luua uusi tensoreid.
Tensor	Tensor tähistab andmeid, mis toimingute vahel edenevad. Varem nägite, kuidas tensorit lähtestada. Konstandi ja muutuja vahe on see, et muutuja algväärtused muutuvad aja jooksul.
Seanss	Seanss täidab toimingu graafikult. Graafiku söötmiseks tenori 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 edasiseks arvutamiseks kasutada.

Allpool toodud näites:

• Looge kaks tensorit
• Looge toiming
• Avage seanss
• Printige tulemus välja

Samm 1) Loote kaks pinget x ja y

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

Samm 2) Loote operaatori korrutades x ja y

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

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

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

Väljund

[8] 

Koodi selgitus

• tf.Session (): avage seanss. Kõik toimingud liiguvad seansside sees
• run (korrutama): käivitage 2. etapis loodud toiming.
• print (tulemus_1): lõpuks saate tulemuse printida
• close (): seansi sulgemine

Tulemuseks on 8, mis on x ja y korrutamine.

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 teostamiseks kasutada meetodit eval (). See on samaväärne jooksmisega (). See muudab koodi paremini loetavaks.

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

## Check the tensors created beforesess = 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 tenori loomist. Muutuja kasutamiseks peate lähtestama muutuja. Muutuja väärtuste initsialiseerimiseks tuleb kutsuda objekt tf.global_variables_initializer (). See objekt lähtestab selgesõnaliselt kõik muutujad. See on kasulik enne mudeli koolitamist.

Saate kontrollida varem loodud muutujate väärtusi. Pange tähele, et tenori hindamiseks peate kasutama jooksu

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

Võite kasutada varem loodud kohahoidjat ja edastada seda tegeliku väärtusega. Andmed peate edastama meetodisse feed_dict.

Näiteks võtate kahest kohatäite data_placeholder_a võimsuse.

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. 

Koodi selgitus

• import numpy kui np: andmete loomiseks importige numpy teek
• tf.pow (data_placeholder_a, 2): looge ops
• np.random.rand (1, 10): looge juhuslik andmemassiiv
• 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 operatsiooni renderdamiseks geeniuslikust lähenemisviisist. Kõik arvutused on kujutatud andmevoo skeemiga. Andmevoo graafik on välja töötatud, et näha üksikute toimingute vahelisi andmete sõltuvusi. Matemaatiline valem või algoritm on tehtud mitmest järjestikusest toimingust. Graafik on mugav viis arvutuste kooskõlastamise visualiseerimiseks.

Graafik näitab sõlme ja serva . Sõlm on operatsiooni, st arvutusühiku kujutis. Serv on tensor, see võib luua uue tenori või tarbida sisendandmeid. See sõltub sõltuvustest üksikute toimingute vahel.

Graafiku struktuur ühendab toimingud (st sõlmed) ja selle, kuidas need toimivad. Pange tähele, et graafik ei kuva toimingute väljundit, see aitab ainult visualiseerida üksikute toimingute vahelist seost.

Vaatame näite.

Kujutage ette, et soovite hinnata järgmist funktsiooni:

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

TensorFlow Graafiku näide

Saate hõlpsasti näha teed, mida tensorid lähevad lõppsihtkohta jõudmiseks.

Näiteks näete, et operatsiooni add ei saa enne ja. Graafikul selgitatakse, et see:

1. arvuta ja:
2. liida 1) kokku
3. lisada 2-le)
4. lisada 3)

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: lähtestage konstantne tensor nimega c, konstantse väärtusega 5
• ruut: lähtestage konstantne tensor, mida nimetatakse ruuduks, püsiväärtusega 2
• f: ehitage operaator

Selles näites valime muutujate väärtuste fikseerimise. Lõime ka konstantse tensori nimega c, mis on funktsiooni f konstantne parameeter. See võtab fikseeritud väärtuse 5. Graafikul näete seda parameetrit tensoris, mida nimetatakse konstantiks.

Ehitasime ka operaatori tf.pow () võimsuse konstantse pinge. See pole vajalik. Tegime seda nii, et graafikul näeksite tenori nime. See on ring, mida nimetatakse ruuduks.

Graafikult saate aru, mis juhtub tensoritega ja kuidas see võib anda väljundi 66.

Allolev kood hindab seansi funktsiooni.

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) 

Väljund

[66] 

Kokkuvõte

TensorFlow töötab ümber:

• Graafik : operatsioone ja tenoreid sisaldav arvutuslik keskkond
• Tensorid : esindab graafikus voogavaid andmeid (või väärtust). See on graafi serv
• Seansid : lubage toimingute sooritamine

Loo pidev 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. mitu korda (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, initsiaator = [[1, 2], [3, 4]])

Avage seanss

Seanss	objekt
Looge seanss	tf. Seanss ()
Käivita seanss	tf.Session.run ()
Hinnake tensorit	muutuja_nimi.eval ()
Sulgege seanss	sess.close ()
Seanss plokkide kaupa	koos tf.Session () kui sess: