Mis on tensor TensorFlow's? Kuju, tüüp ja Operatorse

Mis on tensor?

Nimi TensorFlow tuleneb otse oma põhiobjektist: tensorist. TensorFlow'is hõlmab iga arvutus tensoreid. Tensor on n-mõõtmeline vektor või maatriks, mis esindab kõiki andmetüüpe. Kõik tensori väärtused omavad identset andmetüüpi, millel on teadaolev (või osaliselt teadaolev) kuju, ja andmete kuju on maatriksi või massiivi dimensioonilisus.

Tensor võib pärineda sisendandmetest või arvutuse tulemusest. TensorFlow's teostatakse kõik toimingud graafi sees. Graafik on järjestikku sooritatavate arvutuste kogum. Iga toimingut nimetatakse op-sõlmeks ja sõlmed on omavahel ühendatud.

Graafik visandab operatsioonid ja sõlmede vahelised ühendused. See aga ei kuva väärtusi. Sõlmede vaheline serv on tensor, st viis operatsiooni andmetega täitmiseks.

Masinõppes antakse mudelitele nimekiri objektidest, mida nimetatakse tunnusevektoriteks. Tunnuvektor võib olla mis tahes andmetüübiga ja tavaliselt on see tensori esmane sisend. Need väärtused voolavad tensori kaudu op-sõlme ja selle operatsiooni tulemus loob uue tensori, mida omakorda kasutatakse uues operatsioonis. Kõiki neid operatsioone saab graafikult vaadata.

Tensori kujutamine

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

TensorFlow esindab seda maatriksit järgmiselt:

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

Kui loome kolmemõõtmelise maatriksi väärtustega 1 kuni 8, siis joonistatakse samad andmed kahe virnastatud tahuga kastina:

TensorFlow esindab seda maatriksit järgmiselt:

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

Märkus: Tensorit saab esitada skalaarina või olla rohkem kui kolmemõõtmeline. Kõrgemaid dimensioonitasemeid on lihtsalt raskem visualiseerida.

Tensori tüübid

TensorFlow's läbivad kõik arvutused ühe või mitme tensori. tf.Tensor on objekt, millel on kolm omadust:

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

Iga TensorFlow'ga tehtav toiming hõlmab tensori manipuleerimist. Saadaval on neli peamist tensoritüüpi:

• tf.Variable
• tf.constant
• tf.placeholder
• tf.SparseTensor

Selles õpetuses õpid, kuidas luua tf.constant ja tf.Variable.

Üks asi, mida enne koodi käivitamist meeles pidada: see õpetus järgib algset TensorFlow 1.x API-t, kus graaf luuakse esmalt ja käivitatakse hiljem seansi sees. TensorFlow 2 töötab vaikimisi innukalt, seega mitu allolevat sümbolit teisaldati või eemaldati. Igaüks neist on endiselt ligipääsetav selle kaudu. tf.compat.v1 nimeruum ja tabel seob igaüks oma tänapäevase vastega.

Enne õpetuse juurde asumist aktiveeri kindlasti Conda keskkond, kuhu on installitud TensorFlow. Selle keskkonna nimi on hello-tf.

eest macOS kasutajad:

source activate hello-tf

eest Windows kasutajad:

activate hello-tf

Pärast seda olete valmis TensorFlow'i importima.

# Import tf
import tensorflow as tf

Looge 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 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`

Mõõtmega 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)

Selle väljundi kolm osa vastavad kolmele tensori omadusele, nagu allpool olev annoteeritud versioon selgelt näitab.

Samuti saate tensorile oma nime anda, kasutades name argument.

# 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 selle tensori nimega. Iga tensoriobjekt on defineeritud atribuutidega, nagu unikaalne silt (nimi), mõõde (kuju) ja TensorFlow andmetüüp (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)

Mõõtmega 1 tensori saab luua järgmiselt:

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

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.

Kahe tensormõõtmega massiivi loomiseks peate iga rea ​​järel sulud sulgema. Vaadake allolevat tensorkuju 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)

Maatriksi koosneb kahest reast ja kahest veerust, mis on täidetud väärtustega 1, 2, 3 ja 4.

Kolmemõõtmeline maatriks konstrueeritakse veel ühe sulgude taseme lisamise teel.

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

Tulemus vastab selle õpetuse alguses näidatud kolmemõõtmelisele kastidiagrammile.

Tensori kuju

Tensori printimisel järeldab TensorFlow kuju. Siiski saate kuju TensorFlow'ga otse lugeda. shape vara.

Allpool konstrueerite maatriksi, mis on täidetud numbritega 10 kuni 15 ja kontrollite selle kuju. m_shape.

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

See omadus töötab ka maatriksi puhul. Siin lood 10×10 maatriksi, mis on täidetud arvuga 1.

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

Väljund

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

Antud maatriksi kuju saab kasutada üheliste vektori loomiseks. m_shape on 3×2 mõõtmega, seega loob järgmine kood tensori, millel on 3 rida, mis on täidetud ühelistega:

# 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 sisestate sulgudesse väärtuse 1, konstrueerite üheliste vektori, mis on võrdne maatriksi veergude arvuga. m_shape.

# 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 3×2 maatriksi, mis on täielikult täidetud ühelistega.

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. Tensor saab korraga hoida ainult ühte tüüpi andmeid ja seda tüüpi saab lugeda funktsiooniga dtype vara.

print(m_shape.dtype)

Väljund

<dtype: &#x27;int32'>

Mõnel juhul soovite muuta andmetüüpi. TensorFlow's on see võimalik järgmise abil: tf.cast meetod.

Näide

Allpool teisendatakse ujukoefitsient täisarvuks, mille puhul cast meetod.

# 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: &#x27;float32'>
<dtype: &#x27;int32'>

TensorFlow valib andmetüübi automaatselt, kui tensori loomisel argumenti ei täpsustata. TensorFlow arvab ära kõige tõenäolisema andmetüübi: näiteks teksti edastamisel järeldab see stringi.

loomine Operator

Mõned kasulikud TensorFlow'd Operatorse

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

TensorFlow sisaldab kõiki põhitehteid. Võite alustada lihtsast ja kasutada TensorFlow meetodit arvu ruutjuure arvutamiseks. See tehe on lihtne, kuna tensori konstrueerimiseks on vaja ainult ühte argumenti.

Arvu ruutjuur konstrueeritakse järgmiselt: tf.sqrt(x), kus x on ujukomaarv.

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 tagastas tensorobjekti, mitte kahest ruutjuure. Selles näites prinditakse tensori definitsioon, mitte tehte tegelikku väärtust. Allolevas seansi osas saate teada, kuidas TensorFlow tehteid täidab.

Järgnevalt on loetletud kõige sagedamini kasutatavad toimingud. Idee on sama: iga toiming nõuab ühte või mitut argumenti.

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

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)

Code Selgitus

Looge kaks tensorit:

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

Liidate mõlemad tensorid kokku.

Pane tähele, et mõlemad tensorid peavad olema sama kujuga. Samuti saad kahe tensori kaudu korrutada.

# Multiply
tensor_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 konstantseid tensoreid, millel on iseenesest piiratud kasutusvõimalus. Andmed saabuvad alati erinevate väärtustega ja selle jäädvustamiseks saate kasutada klassi Muutuja. Muutuja tähistab sõlme, mille väärtused ajas muutuvad.

Muutuja loomiseks võite kasutada tf.get_variable() meetod.

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 kahemõõtmelise muutuja kahe juhusliku väärtusega. Vaikimisi tagastab TensorFlow juhusliku väärtuse. Muutujale panete nimeks var.

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

Väljund

(1, 2)

Selles näites lood ühe rea ja kahe veeruga muutuja, seega edastad muutuja mõõtmena [1, 2].

Tensori algväärtused võivad olla ka nullid. Näiteks mudeli treenimisel on enne tunnuste kaalu arvutamist vaja algväärtusi. 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)

Konstantse tensori väärtused saab edastada ka muutujasse. Konstantse tensori saab luua meetodiga tf.constant() ja kasutage seda tenorit muutuja initsialiseerimiseks.

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

Väljund

(2, 2)

kohatäitja

Kohatäite eesmärk on tensori toitmine. Kohatäite initsialiseerib tensorite sees liikuvad andmed. Kohatäite lisamiseks kasutate feed_dict argument ja kohatäidet sisestatakse ainult seansi sees.

Järgmises näites näed, kuidas meetodi abil kohatäidet luua tf.placeholderSeansi osas õpid, kuidas sisestada kohatäitesse tegelik tensori väärtus.

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

Graafikud ja seansid on sõltumatud. Saate seansi käivitada ja väärtused hilisemaks arvutuseks alles hoida.

Allolevas näites saate teha järgmist.

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

1. samm) Loote kaks tensorit x ja y

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

2. samm) Operaatori loomiseks korruta x ja y

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

3. samm) Avate seansi. Kõik arvutused toimuvad seansi sees ja kui olete lõpetanud, peate selle sulgema.

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

Väljund

[8]

Code selgitus

• tf.Session(): Ava seanss. Kõik toimingud toimuvad seansi piires.
• run(multiply): käivitage 2. etapis loodud toiming
• print(result_1)Lõpuks saate tulemuse välja printida
• close(): Sulge seanss

Tulemuseks on 8, mis on x ja y korrutis.

Teine viis seansi loomiseks on ploki sees. Selle 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 kasutada eval() meetod operatsiooni teostamiseks. See on samaväärne meetodiga run() ja 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. Enne muutuja kasutamist peate selle initsialiseerima. Objekt tf.global_variables_initializer() kutsutakse iga muutuja väärtuse korraga initsialiseerimiseks, mis on kasulik enne mudeli treenimist.

Saate kontrollida eelnevalt loodud muutujate väärtusi. Pange tähele, et tensori hindamiseks peate kasutama run-i.

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 eelnevalt loodud kohatäidet ja sisestada sinna tegeliku väärtuse. Peate andmed edastama feed_dict argument.

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.

Code Selgitus

• import numpy as npImpordi tuim andmete loomiseks vajalik teek
• tf.pow(data_placeholder_a, 2)Loo operatsioonid
• np.random.rand(1, 10)Loo juhuslik andmemassiiv
• feed_dict={data_placeholder_a: data}: Täida kohatäide 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 renderdab iga operatsiooni andmevoo skeemi abil. Andmevoo graafik loodi selleks, et paljastada üksikute operatsioonide vahelised andmesõltuvused. Matemaatiline valem või algoritm koosneb mitmest järjestikusest operatsioonist ja graafik on mugav viis nende arvutuste koordineerimise visualiseerimiseks.

Graafik näitab sõlmi ja servi. Sõlm on operatsiooni esitus, st arvutusüksus. Serv on tensor: see võib genereerida uue tensori või tarbida sisendandmeid, olenevalt üksikute operatsioonide vahelistest sõltuvustest.

Graafi struktuur ühendab operatsioone (st sõlmi) omavahel ja näitab, kuidas igaüht neist toidetakse. Pane tähele, et graafik ei kuva operatsioonide väljundit; see aitab vaid visualiseerida nendevahelisi seoseid.

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 add sõlm ei saa enne mõlemat käivituda Mul ja Pow on oma tulemused andnud. Graafik näitab, et TensorFlow:

1. Arvuta x·z sisse Mul sõlme ja x² sees Pow sõlme
2. liida need kaks tulemust kokku add sõlme
3. liida sellele summale z add_1 sõlme
4. lisa konstant 5 add_2 sõlme

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 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 hoitakse muutujate väärtusi fikseerituna. Konstantne tensor c on funktsiooni f konstantne parameeter ja võtab fikseeritud väärtuse 5; graafikul näete seda parameetrit tensoris, mida nimetatakse konstantseks.

Operaatori võimsuse jaoks loodi ka konstantne tensor tf.pow()See pole vajalik, aga see tähendab, et astendaja kuvatakse graafikul ringina, mida nimetatakse ruuduks.

Graafikult näete, mis tenoritega juhtub ja miks funktsioon tagastab väärtuse 66: 5 × 6 pluss 5² pluss 6 pluss 5 võrdub 66-ga.

Allolev kood hindab funktsiooni seansi sees.

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]

TensorFlow põhitõdede kiirjuhend

Allolevad neli tabelit koondavad kõik selles õpetuses kasutatud käsud, et saaksite neid otsida ilma näidete vahel tagasi kerima.

Loo konstantne tensor

Looge operaator

Loo muutuja tensor

Ava seanss

KKK