Mikä on tensori TensorFlow'ssa? Muoto, tyyppi ja OperaTors

Mikä on tensori?

Nimi TensorFlow on johdettu suoraan sen ydinobjektista: tensorista. TensorFlow'ssa jokainen laskenta sisältää tensoreita. Tensori on n-ulotteinen vektori tai matriisi, joka edustaa kaikkia datatyyppejä. Kaikilla tensorin arvoilla on identtinen datatyyppi, jolla on tunnettu (tai osittain tunnettu) muoto, ja datan muoto on matriisin tai taulukon ulottuvuus.

Tensori voi olla peräisin syötetiedoista tai laskennan tuloksesta. TensorFlow'ssa kaikki operaatiot suoritetaan graafin sisällä. Graafi on joukko peräkkäin tapahtuvia laskutoimituksia. Jokaista operaatiota kutsutaan operaatiosolmuksi, ja solmut ovat yhteydessä toisiinsa.

Graafi hahmottelee operaatiot ja solmujen väliset yhteydet. Se ei kuitenkaan näytä arvoja. Solmujen välinen reuna on tensori eli tapa täyttää operaatio datalla.

Koneoppimisessa malleihin syötetään lista objekteja, joita kutsutaan ominaisuusvektoreiksi. Ominaisuusvektori voi olla minkä tahansa tyyppinen, ja se on yleensä ensisijainen syöte, joka täyttää tensorin. Nämä arvot virtaavat operaatiosolmuun tensorin kautta, ja kyseisen operaation tulos luo uuden tensorin, jota puolestaan ​​käytetään uudessa operaatiossa. Kaikki nämä operaatiot voidaan tarkastella kaaviossa.

Tensorin esitys

TensorFlow'ssa tensori on kokoelma n-ulotteisia ominaisuusvektoreita (eli taulukko). Jos meillä on esimerkiksi 2×3-matriisi, jonka arvot ovat 1–6, kirjoitamme sen alla olevan matriisin mukaisesti:

TensorFlow edustaa tätä matriisia seuraavasti:

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

Jos luomme kolmiulotteisen matriisin arvoilla 1–8, sama data piirtyy laatikkona, jossa on kaksi päällekkäin asetettua pintaa:

TensorFlow edustaa tätä matriisia seuraavasti:

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

Huomautus: Tensori voidaan esittää skalaarilla tai sillä voi olla useampi kuin kolmiulotteinen muoto. Ylempien ulottuvuuksien visualisointi on yksinkertaisesti vaikeampaa.

Tensorin tyypit

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

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

Jokainen TensorFlow'lla suorittamasi operaatio sisältää tensorin manipuloinnin. Voit luoda neljää päätyyppiä tensoreista:

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

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

Yksi asia, joka kannattaa pitää mielessä ennen koodin suorittamista: tämä tutoriaali noudattaa alkuperäistä TensorFlow 1.x -rajapintaa, jossa kaavio rakennetaan ensin ja suoritetaan myöhemmin istunnon aikana. TensorFlow 2 toimii oletuksena innokkaasti, joten useita alla olevista symboleista siirrettiin tai poistettiin. Jokainen niistä on edelleen saatavilla tf.compat.v1 nimiavaruuteen, ja taulukko yhdistää jokaisen sen nykyaikaiseen vastineeseen.

Ennen kuin käyt läpi tutoriaalin, varmista, että aktivoit Conda-ympäristön, johon TensorFlow on asennettu. Tämän ympäristön nimi on hello-tf.

varten macOS käyttäjät:

source activate hello-tf

varten Windows käyttäjät:

activate hello-tf

Kun olet tehnyt sen, olet valmis tuomaan TensorFlow'n.

# Import tf
import tensorflow as tf

Luo n-ulottuvuuden tensori

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

Tensorin luomiseen voit käyttää tf.constant() kuten alla olevassa TensorFlow-tensorimuodon esimerkissä on esitetty:

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 0-ulotteisen tensorin, suorita seuraava koodi.

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

ulostulo

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

Tuon tulosteen kolme osaa vastaavat kolmea tensorominaisuutta, kuten alla oleva annotoitu versio selventää.

Voit myös antaa tensorille oman nimen komennolla name Perustelu.

# 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 sen tensorinimellä. Jokainen tensoriobjekti määritellään ominaisuuksilla, kuten yksilöllisellä tunnisteella (nimi), ulottuvuudella (muoto) ja TensorFlow-tietotyypillä (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)

Yksiulotteisen tensorin voi luoda seuraavasti:

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

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.

Luodaksesi kahden tensorulottuvuuden taulukon, sinun on suljettava hakasulkeet jokaisen rivin jälkeen. Katso alla oleva tensorin muodon esimerkki.

## 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 kaksi riviä ja kaksi saraketta, jotka on täytetty arvoilla 1, 2, 3 ja 4.

Kolmiulotteinen matriisi konstruoidaan lisäämällä siihen uusi sulkujen taso.

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

Tulos vastaa aiemmin tässä opetusohjelmassa esitettyä kolmiulotteista laatikkodiagrammia.

Tensorin muoto

Kun tulostat tensorin, TensorFlow päättelee muodon. Voit kuitenkin lukea muodon suoraan TensorFlow'lla. shape omaisuutta.

Alla konstruoit matriisin, joka on täytetty numeroilla 10–15, ja tarkistat sen muodon. m_shape.

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

Ominaisuus toimii myös matriisille. Tässä luodaan 10×10-matriisi, 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ää annetun matriisin muotoa ykkösten vektorin muodostamiseen. m_shape on 3×2-ulotteinen, joten seuraava koodi luo tensorin, jossa on 3 riviä, jotka on täytetty ykkösillä:

# 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 syötät sulkeisiin arvon 1, konstruoit matriisin sarakkeiden lukumäärän mukaisen ykkösten vektorin. m_shape.

# 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 3×2-matriisin, joka on täytetty kokonaan ykkösillä.

print(tf.ones(m_shape.shape))

ulostulo

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

Tietojen tyyppi

Tensorin toinen ominaisuus on datan tyyppi. Tensori voi sisältää vain yhden tyyppistä dataa kerrallaan, ja voit lukea kyseisen tyypin käyttämällä dtype omaisuutta.

print(m_shape.dtype)

ulostulo

<dtype: &#x27;int32'>

Joissakin tapauksissa haluat muuttaa datan tyyppiä. TensorFlow'ssa se on mahdollista käyttämällä tf.cast menetelmällä.

esimerkki

Alla liukutensori muunnetaan kokonaisluvuksi, jossa on cast menetelmällä.

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

TensorFlow valitsee datatyypin automaattisesti, jos argumenttia ei ole määritetty tensorin luomisen aikana. TensorFlow arvaa todennäköisimmän datatyypin: jos esimerkiksi välität tekstiä, se päättelee merkkijonon.

Luominen OperaTor

Hyödyllistä TensorFlow'ta OperaTors

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

TensorFlow sisältää kaikki peruslaskutoimitukset. Voit aloittaa yksinkertaisella ja käyttää TensorFlow-metodia luvun neliöjuuren laskemiseen. Tämä operaatio on suoraviivainen, koska tensorin konstruointiin tarvitaan vain yksi argumentti.

Luvun neliöjuuri konstruoidaan seuraavasti: tf.sqrt(x), jossa x on liukuluku.

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

ulostulo

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

Huomautus: Tuloste palautti tensoriobjektin eikä luvun 2 neliöjuurta. Tässä esimerkissä tulostat tensorin määritelmän etkä operaation varsinaista laskentaa. Alla olevassa Istunto-osiossa opit, miten TensorFlow suorittaa operaatiot.

Seuraavassa on luettelo yleisesti käytetyistä operaatioista. Idea on sama: jokainen operaatio vaatii yhden tai useamman argumentin.

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

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)

Code Selitys

Luo kaksi tensoria:

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

Laske molemmat tensorit yhteen.

Huomaa, että molempien tensorien on oltava samanmuotoisia. Voit myös suorittaa kertolaskun kahden tensorin yli.

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

ulostulo

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

Muuttujat

Tähän mennessä olet luonut vain vakiotensoreita, joiden käyttö yksinään on rajallista. Data saapuu aina eri arvoilla, ja tämän tallentamiseen voit käyttää Variable-luokkaa. Muuttuja edustaa solmua, jonka arvot muuttuvat ajan kuluessa.

Muuttujan luomiseen voit käyttää tf.get_variable() menetelmällä.

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, jolla on kaksi satunnaista arvoa. Oletusarvoisesti TensorFlow palauttaa satunnaisen arvon. Annat muuttujalle nimeksi var.

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

ulostulo

(1, 2)

Tässä esimerkissä luot muuttujan, jossa on yksi rivi ja kaksi saraketta, joten annat muuttujan ulottuvuutena [1, 2].

Tensorin alkuarvot voivat olla myös nolla. Esimerkiksi mallia koulutettaessa tarvitaan alkuarvot ennen ominaisuuksien painojen laskemista. Alla asetat nämä alkuarvot nollaksi.

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 myös välittää vakiotensorin arvot muuttujaan. Vakiotensorin luot metodilla tf.constant() ja käytä kyseistä tensoria muuttujan alustamiseen.

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

ulostulo

(2, 2)

Paikanpitäjä

Paikkamerkin tarkoituksena on syöttää tietoa tensorille. Paikkamerkki alustaa tensorien sisällä kulkevan datan. Paikkamerkin syöttämiseen käytetään feed_dict argumentti, ja paikkamerkki syötetään vain istunnon sisällä.

Seuraavassa esimerkissä näet, miten paikkamerkki luodaan metodilla tf.placeholderIstunto-osiossa opit syöttämään paikkamerkille todellisen tensoriarvon.

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

Kaaviot ja istunnot ovat toisistaan ​​riippumattomia. Voit suorittaa istunnon ja säilyttää arvot myöhempiä laskutoimituksia varten.

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) Luot operaattorin kertomalla x:n ja y:n

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

Vaihe 3) Avaat istunnon. Kaikki laskelmat tapahtuvat istunnon sisällä, ja kun olet valmis, sinun on suljettava se.

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

ulostulo

[8]

Code selitys

• tf.Session(): Avaa istunto. Kaikki toiminnot tapahtuvat istunnon sisällä.
• run(multiply): suorita vaiheessa 2 luotu toiminto
• print(result_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, 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ä operaation suorittamiseksi. Se vastaa run() ja tekee koodista luettavampaa.

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 oletusarvoisesti tyhjiä, jopa tensorin luomisen jälkeen. Sinun on alustettava muuttuja ennen kuin voit käyttää sitä. Objekti tf.global_variables_initializer() kutsutaan alustamaan kaikkien muuttujien arvot kerralla, mikä on hyödyllistä ennen mallin kouluttamista.

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

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 todellisen arvon. Sinun on välitettävä tiedot feed_dict Perustelu.

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.

Code Selitys

• import numpy as np: Tuo nuhjuinen kirjasto datan luomiseksi
• tf.pow(data_placeholder_a, 2)Luo toiminnot
• np.random.rand(1, 10)Luo satunnainen datataulukko
• feed_dict={data_placeholder_a: data}Syötä paikkamerkkiin tiedot

ulostulo

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

Kaavio

TensorFlow renderöi jokaisen operaation datavuokaaviolla. Datavuokaavio on suunniteltu paljastamaan yksittäisten operaatioiden väliset datariippuvuudet. Matemaattinen kaava tai algoritmi koostuu useista peräkkäisistä operaatioista, ja kaavio on kätevä tapa visualisoida, miten nämä laskelmat koordinoidaan.

Graafi näyttää solmut ja kaaret. Solmu on operaation eli laskentayksikön esitys. Kaula on tensori: se voi tuottaa uuden tensorin tai käyttää syötedataa yksittäisten operaatioiden välisten riippuvuuksien mukaan.

Graafin rakenne yhdistää operaatiot (eli solmut) toisiinsa ja näyttää, miten kutakin niistä syötetään. Huomaa, että kaavio ei näytä operaatioiden tulosta; se ainoastaan ​​auttaa visualisoimaan niiden välisiä yhteyksiä.

Katsotaanpa esimerkkiä. Kuvittele, että haluat evaluoida seuraavan funktion:

TensorFlow luo graafin funktion suorittamiseksi. Graafi näyttää tältä:

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

Esimerkiksi add solmu ei voi toimia ennen molempia Mul ja Pow ovat tuottaneet tuloksensa. Kaavio osoittaa, että TensorFlow:

1. laske x·z kohdassa Mul solmu ja x² Pow solmu
2. laske nuo kaksi tulosta yhteen add solmu
3. Lisää z tähän summaan add_1 solmu
4. lisää vakio 5 add_2 solmu

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 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ä muuttujien arvot pidetään kiinteinä. Vakiotensori c on funktion f vakioparametri ja saa kiinteän arvon 5; kaaviossa tämä parametri näkyy tensorissa nimeltä vakio.

Myös operaattorin teholle luotiin vakiotensori tf.pow()Se ei ole välttämätöntä, mutta se tarkoittaa, että eksponentti näkyy kaaviossa ympyränä, jota kutsutaan neliöksi.

Kaaviosta voit seurata, mitä tensoreille tapahtuu ja miksi funktio palauttaa luvun 66: 5 × 6 plus 5² plus 6 plus 5 on yhtä kuin 66.

Alla oleva koodi evaluoi funktion istunnon sisällä.

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]

TensorFlow'n perusteet - pikaopas

Alla olevat neljä taulukkoa keräävät kaikki tässä opetusohjelmassa käytetyt komennot, jotta voit etsiä niitä selaamatta esimerkkejä taaksepäin.

Luo vakiotensori

Luo operaattori

Luo muuttujatensori

Avaa istunto

UKK