TensorFlow-perustiedot: Tensori, muoto, tyyppi, istunnot ja OperaTors
Evelyn Clarke
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:
- laske ja:
- lisää 1) yhteen
- lisää 2)
- 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: |
