TensorFlow-perustiedot: Tensori, muoto, tyyppi, istunnot ja OperaTors

Mikä on tensori?

Tensorflown nimi on suoraan johdettu sen ydinkehyksestä: Tensor. Tensorflow:ssa kaikki laskelmat sisältävät tensoreita. Tensori on n-ulotteinen vektori tai matriisi, joka edustaa kaiken tyyppistä dataa. Kaikilla tensorin arvoilla on identtinen tietotyyppi tunnetulla (tai osittain tunnetulla) muodolla. Tiedon muoto on matriisin tai taulukon ulottuvuus.

Tensori voidaan saada syöttötiedoista tai laskennan tuloksesta. TensorFlow'ssa kaikki toiminnot suoritetaan kaavion sisällä. Kaavio on joukko laskentaa, joka tapahtuu peräkkäin. Jokaista toimintoa kutsutaan operaatiosolmuksi ja ne ovat yhteydessä toisiinsa.

Kaavio esittää toiminnot ja solmujen väliset yhteydet. Se ei kuitenkaan näytä arvoja. Solmujen reuna on tensori, eli tapa täyttää operaatio datalla.

Koneoppimisessa mallit syötetään luettelolla objekteista, joita kutsutaan ominaisuusvektoreiksi. Piirrevektori voi olla mitä tahansa tietotyyppiä. Piirrevektori on yleensä ensisijainen syöte tensorin täyttämiseksi. Nämä arvot virtaavat operaatiosolmuun tensorin kautta ja tämän operaation/laskennan tulos luo uuden tensorin, jota puolestaan ​​käytetään uudessa operaatiossa. Kaikki nämä toiminnot näkyvät kaaviossa.

Tensorin esitys

TensorFlow'ssa tensori on kokoelma n-ulotteisia piirrevektoreita (eli matriisia). Jos meillä on esimerkiksi 2×3 matriisi, jonka arvot ovat 1-6, kirjoitamme:

TensorFlow edustaa tätä matriisia seuraavasti:

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

Jos luomme kolmiulotteisen matriisin arvoilla 1-8, meillä on:

TensorFlow edustaa tätä matriisia seuraavasti:

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

Huomautus: Tensori voidaan esittää skalaarilla tai sillä voi olla enemmän kuin kolmiulotteinen muoto. Korkeamman ulottuvuuden tason visualisointi on vain monimutkaisempaa.

Tensorin tyypit

TensorFlow'ssa kaikki laskelmat kulkevat yhden tai useamman tensorin läpi. tf.tensori on objekti, jolla on kolme ominaisuutta:

• Yksilöllinen etiketti (nimi)
• Mitta (muoto)
• Tietotyyppi (dtype)

Jokainen TensorFlow'n kanssa tekemäsi operaatio sisältää tensorin manipuloinnin. Voit luoda neljä päätensorityyppiä:

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

Tässä opetusohjelmassa opit luomaan tf.constant- ja tf.Variable-muuttujia.

Ennen kuin käymme opetusohjelman läpi, varmista, että aktivoit conda-ympäristön TensorFlow'lla. Annoimme tälle ympäristölle nimeksi hello-tf.

MacOS-käyttäjälle:

source activate hello-tf

varten Windows käyttäjä:

activate hello-tf

Kun olet tehnyt sen, olet valmis tuomaan tensorflow

# Import tf
import tensorflow as tf

Luo n-ulotteinen tensori

Aloitat luomalla tensorin yhdellä ulottuvuudella, nimittäin skalaarilla.

Luodaksesi tensorin, voit käyttää tf.constant()-funktiota alla olevan TensorFlow-tensorin muotoesimerkin mukaisesti:

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`

Luodaksesi tensorin dimensiolle 0, suorita seuraava koodi

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

ulostulo

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

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

ulostulo

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

Jokainen tensori näytetään tensorin nimellä. Jokainen tensoriobjekti määritellään tensorimääritteillä, kuten yksilöllinen nimiö (nimi), ulottuvuus (muoto) ja TensorFlow-tietotyypit (dtype).

Voit määrittää tensorin desimaaliarvoilla tai merkkijonolla muuttamalla tietotyyppiä.

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

ulostulo

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

Dimension 1 tensori voidaan luoda seuraavasti:

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

ulostulo

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

Voit huomata, että TensorFlow-muoto koostuu vain yhdestä sarakkeesta.

Jos haluat luoda 2 tensorimitan taulukon, sinun on suljettava sulut jokaisen rivin jälkeen. Tarkista Keras Tensor -muotoesimerkki alta

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

ulostulo

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

Matriisissa on 2 riviä ja 2 saraketta, jotka on täytetty arvoilla 1, 2, 3, 4.

Kolmiulotteinen matriisi rakennetaan lisäämällä toinen taso suluilla.

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

ulostulo

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

Matriisi näyttää samalta kuin kuvassa kaksi.

Tensorin muoto

Kun tulostat tensoria, TensorFlow arvaa muodon. Voit kuitenkin saada tensorin muodon TensorFlow-muotoominaisuuden avulla.

Alla rakennat matriisin, joka on täytetty numerolla 10-15 ja tarkistat m_shapen muodon

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

ulostulo

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

Matriisissa on 3 riviä ja 2 saraketta.

TensorFlow sisältää hyödyllisiä komentoja vektorin tai matriisin luomiseen, joka on täytetty 0:lla tai 1:llä. Jos esimerkiksi haluat luoda 1-D-tensorin, jolla on tietty muoto 10 ja joka on täytetty 0:lla, voit suorittaa alla olevan koodin:

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

ulostulo

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

Omaisuus toimii myös matriisissa. Täällä luot 10 × 10 -matriisin, joka on täytetty luvulla 1

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

ulostulo

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

Voit käyttää tietyn matriisin muotoa muodostaaksesi niistä vektorin. Matriisi m_muoto on 3×2-mitta. Voit luoda tensorin, jossa on 3 riviä, jotka täytetään yhdellä seuraavalla koodilla:

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

ulostulo

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

Jos välität arvon 1 hakasulkeeseen, voit muodostaa vektorin ykkösistä, jotka ovat yhtä suuria kuin sarakkeiden lukumäärä matriisissa m_muoto.

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

ulostulo

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

Lopuksi voit luoda matriisin 3×2, jossa on vain yksi

print(tf.ones(m_shape.shape))

ulostulo

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

Tyyppi

Tensorin toinen ominaisuus on tiedon tyyppi. Tensorilla voi olla vain yhden tyyppistä dataa kerrallaan. Tensorilla voi olla vain yhden tyyppistä dataa. Voit palauttaa tyypin ominaisuudella dtype.

print(m_shape.dtype)

ulostulo

<dtype: 'int32'>

Joissakin tapauksissa haluat muuttaa tietojen tyyppiä. TensorFlow'ssa se on mahdollista tf.cast-menetelmällä.

esimerkki

Alla kelluva tensori muunnetaan kokonaisluvuksi käyttämällä menetelmää 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)

ulostulo

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

TensorFlow valitsee tietotyypin automaattisesti, kun argumenttia ei ole määritetty tensorin luomisen aikana. TensorFlow arvaa, mikä on todennäköisin tietotyyppi. Jos esimerkiksi välität tekstin, se arvaa sen olevan merkkijono ja muuntaa sen merkkijonoksi.

Luodaan operaattoria

Joitakin hyödyllisiä TensorFlow-operaattoreita

Tiedät kuinka luoda tensori TensorFlow'lla. On aika opetella suorittamaan matemaattisia operaatioita.

TensorFlow sisältää kaikki perustoiminnot. Voit aloittaa yksinkertaisella. Käytät TensorFlow-menetelmää luvun neliön laskemiseen. Tämä toiminto on yksinkertainen, koska tensorin muodostamiseen tarvitaan vain yksi argumentti.

Luvun neliö muodostetaan tf.sqrt(x):llä, jossa x on kelluva luku.

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

ulostulo

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

Huomautus: Tulos palautti tensoriobjektin, ei neliön 2 tulosta. Esimerkissä tulostetaan tensorin määritelmä, ei toiminnan varsinaista arviointia. Seuraavassa osiossa opit kuinka TensorFlow toimii toimintojen suorittamiseksi.

Seuraavassa on luettelo yleisesti käytetyistä toiminnoista. Idea on sama. Jokainen toiminto vaatii yhden tai useamman argumentin.

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

esimerkki

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

ulostulo

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

Koodin selitys

Luo kaksi tensoria:

• yksi tensori, jossa on 1 ja 2
• yksi tensori, jossa on 3 ja 4

Laske molemmat tensorit yhteen.

Ilmoitus: että molemmilla tensoreilla on oltava sama muoto. Voit suorittaa kertolaskun kahdella tensorilla.

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

ulostulo

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

Muuttujat

Toistaiseksi olet luonut vain vakiotensoreja. Siitä ei ole suurta hyötyä. Tiedot saapuvat aina eri arvoilla, voit kaapata tämän käyttämällä Variable-luokkaa. Se edustaa solmua, jossa arvot muuttuvat aina.

Voit luoda muuttujan käyttämällä menetelmää 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.

Esimerkiksi alla oleva koodi luo kaksiulotteisen muuttujan kahdella satunnaisarvolla. Oletuksena TensorFlow palauttaa satunnaisen arvon. Annat muuttujan nimeksi var

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

ulostulo

(1, 2)

Toisessa esimerkissä luot muuttujan, jossa on yksi rivi ja kaksi saraketta. Sinun on käytettävä [1,2] muuttujan ulottuvuuden luomiseen

Tämän tensorin alkuarvot ovat nolla. Kun esimerkiksi koulutat mallia, sinulla on oltava alkuarvot ominaisuuksien painon laskemiseksi. Alla asetat nämä alkuarvot nollaan.

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

ulostulo

(1, 2)

Voit välittää vakiotensorin arvot muuttujassa. Luot vakiotensorin menetelmällä tf.constant(). Käytät tätä tensoria muuttujan alustamiseen.

Muuttujan ensimmäiset arvot ovat 10, 20, 30 ja 40. Uuden tensorin muoto on 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)

ulostulo

(2, 2)

Paikanpitäjä

Paikkamerkin tarkoituksena on syöttää tensoria. Paikkamerkkiä käytetään alustamaan data virtaamaan tensorien sisällä. Jos haluat antaa paikkamerkin, sinun on käytettävä menetelmää feed_dict. Paikkamerkki syötetään vain istunnon aikana.

Seuraavassa esimerkissä näet kuinka luodaan paikkamerkki menetelmällä tf.placeholder. Seuraavassa istunnossa opit syöttämään paikkamerkin todellisella tensoriarvolla.

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

ulostulo

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

istunto

TensorFlow toimii kolmen pääkomponentin ympärillä:

• Kaavio
• tensor
• istunto

komponentit	Kuvaus
Kaavio	Kaavio on perustavanlaatuinen TensorFlow'ssa. Kaikki matemaattiset toiminnot (ops) suoritetaan kaavion sisällä. Voit kuvitella kaavion projektina, jossa kaikki toiminnot tehdään. Solmut edustavat näitä operaatioita, ne voivat absorboida tai luoda uusia tensoreja.
tensor	Tensori edustaa dataa, joka etenee operaatioiden välillä. Näit aiemmin, kuinka tensori alustetaan. Ero vakion ja muuttujan välillä on muuttujan alkuarvot, jotka muuttuvat ajan myötä.
istunto	Istunto suorittaa toiminnon kaaviosta. Jos haluat syöttää kaavioon tensorin arvot, sinun on avattava istunto. Istunnon sisällä sinun on suoritettava operaattori tulosteen luomiseksi.

Kaaviot ja istunnot ovat itsenäisiä. Voit suorittaa istunnon ja saada arvot käytettäväksi myöhemmin lisälaskutoimissa.

Alla olevassa esimerkissä:

• Luo kaksi tensoria
• Luo operaatio
• Avaa istunto
• Tulosta tulos

Vaihe 1) Luot kaksi tensoria x ja y

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

Vaihe 2) Luo operaattori kertomalla x ja y

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

Vaihe 3) Avaat istunnon. Kaikki laskelmat tapahtuvat istunnon aikana. Kun olet valmis, sinun on suljettava istunto.

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

ulostulo

[8]

Koodin selitys

• tf.Session(): Avaa istunto. Kaikki toiminnot suoritetaan istuntojen sisällä
• run(multiply): suorita vaiheessa 2 luotu toiminto.
• print(tulos_1): Lopuksi voit tulostaa tuloksen
• close(): Sulje istunto

Tuloksena on 8, joka on x:n ja y:n kertolasku.

Toinen tapa luoda istunto on lohkon sisällä. Etuna on se, että se sulkee istunnon automaattisesti.

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

ulostulo

[8]

Istunnon yhteydessä voit käyttää eval()-menetelmää toiminnon suorittamiseen. Se vastaa sanaa run(). Se tekee koodista luettavamman.

Voit luoda istunnon ja nähdä arvot tähän mennessä luomiesi tensorien sisällä.

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

ulostulo

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

Muuttujat ovat oletuksena tyhjiä, vaikka olisit luonut tensorin. Sinun on alustettava muuttuja, jos haluat käyttää muuttujaa. Objektia tf.global_variables_initializer() on kutsuttava muuttujan arvojen alustamiseksi. Tämä objekti alustaa eksplisiittisesti kaikki muuttujat. Tämä on hyödyllistä ennen mallin kouluttamista.

Voit tarkistaa aiemmin luomiesi muuttujien arvot. Huomaa, että sinun on käytettävä run-komentoa tensorin arvioimiseen

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

ulostulo

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

Voit käyttää aiemmin luomaasi paikkamerkkiä ja syöttää siihen todellista arvoa. Sinun on välitettävä tiedot menetelmään feed_dict.

Käytät esimerkiksi arvoa 2 paikkamerkkidata_paikkamerkki_a:sta.

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.

Koodin selitys

• tuonti numpy as np: Tuo nuhjuinen kirjasto tietojen luomiseksi
• tf.pow(data_placeholder_a, 2): Luo ops
• np.random.rand(1, 10): Luo satunnainen datajoukko
• feed_dict={data_placeholder_a: data}: Syötä paikkamerkki datalla

ulostulo

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

Kaavio

TensorFlow riippuu nerokkaasta lähestymistavasta operaation tekemiseen. Kaikki laskelmat esitetään tietovuokaaviolla. Tietovirtakaavio on kehitetty näkemään yksittäisten toimintojen väliset datariippuvuudet. Matemaattinen kaava tai algoritmi koostuu useista peräkkäisistä operaatioista. Kaavio on kätevä tapa visualisoida, kuinka laskelmat koordinoidaan.

Kaaviossa näkyy a solmu ja reuna. Solmu on toiminnan esitys eli laskentayksikkö. Reuna on tensori, se voi tuottaa uuden tensorin tai kuluttaa syötetiedot. Se riippuu yksittäisten toimintojen välisistä riippuvuuksista.

Graafin rakenne yhdistää operaatiot (eli solmut) ja kuinka ne toimivat syötteenä. Huomaa, että kaavio ei näytä operaatioiden tulosta, se auttaa vain visualisoimaan yksittäisten operaatioiden välisen yhteyden.

Katsotaanpa esimerkki.

Kuvittele, että haluat arvioida seuraavan funktion:

TensorFlow luo kaavion funktion suorittamiseksi. Kaavio näyttää tältä:

Voit helposti nähdä polun, jonka tensorit kulkevat päästäkseen lopulliseen määränpäähän.

Voit esimerkiksi nähdä, että toimintoa ei voi tehdä ennen ja . Kaavio selittää, että se:

1. laske ja:
2. lisää 1) yhteen
3. lisää 2)
4. lisää 3) siihen

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

Koodin selitys

• x: Alusta muuttuja nimeltä x, jonka vakioarvo on 5
• z: Alusta z-niminen muuttuja, jonka vakioarvo on 6
• c: Alusta vakiotensori nimeltä c, jonka vakioarvo on 5
• neliö: Alusta vakiotensori nimeltä neliö, jonka vakioarvo on 2
• f: Muodosta operaattori

Tässä esimerkissä päätämme pitää muuttujien arvot kiinteinä. Loimme myös vakiotensorin nimeltä c, joka on funktion f vakioparametri. Se vaatii kiinteän arvon 5. Kuvaajassa näet tämän parametrin tensorissa, jota kutsutaan vakioksi.

Rakensimme myös vakiotensorin teholle operaattorissa tf.pow(). Se ei ole tarpeen. Teimme sen niin, että näet tensorin nimen kaaviossa. Se on ympyrä nimeltä neliö.

Kaaviosta voit ymmärtää, mitä tensoreille tapahtuu ja kuinka se voi palauttaa ulostulon 66.

Alla oleva koodi arvioi funktion istunnossa.

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)

ulostulo

[66]

Yhteenveto

TensorFlow toimii noin:

• Kaavio: Laskennallinen ympäristö, joka sisältää operaatiot ja tensorit
• tensors: Edustaa dataa (tai arvoa), joka virtaa kaaviossa. Se on kaavion reuna
• Sessions: Salli toimintojen suorittaminen

Luo vakiotensori

vakio	objekti
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)

Luo operaattori

Luo operaattori	objekti
a + b	tf.add(a, b)
a * b	tf.multiply(a, b)

Luo muuttujatensori

Luo muuttuja	objekti
satunnaistettu arvo	tf.get_variable("muuttuja", [1, 2])
alustettu ensimmäinen arvo	tf.get_variable("var_init_2", dtype=tf.int32, alustus =[ [1, 2], [3, 4] ])

Avaa istunto

istunto	objekti
Luo istunto	tf. istunto ()
Suorita istunto	tf.Session.run()
Arvioi tensori	muuttujan_nimi.eval()
Sulje istunto	sess.close()
Istunto lohkoittain	jossa tf.Session() on sess: