Podstawy TensorFlow: Tensor, kształt, typ, sesje i Operatorsy

Co to jest tensor?

Nazwa Tensorflow wywodzi się bezpośrednio z jego podstawowego frameworka: Tensor. W Tensorflow wszystkie obliczenia wykorzystują tensory. Tensor to wektor lub macierz n-wymiarów, która reprezentuje wszystkie typy danych. Wszystkie wartości w tensorze zawierają identyczny typ danych ze znanym (lub częściowo znanym) kształtem. Kształt danych to wymiar macierzy lub tablicy.

Tensor może pochodzić z danych wejściowych lub wyniku obliczeń. W TensorFlow wszystkie operacje są przeprowadzane wewnątrz grafu. Graf jest zbiorem obliczeń, które odbywają się kolejno. Każda operacja jest nazywana węzłem operacyjnym i są ze sobą połączone.

Wykres przedstawia operacje i połączenia między węzłami. Jednak nie wyświetla wartości. Krawędź węzłów jest tensorem, tj. sposobem na wypełnienie operacji danymi.

W uczeniu maszynowym modele są zasilane listą obiektów zwanych wektorami cech. Wektor cech może być dowolnego typu danych. Wektor cech będzie zazwyczaj podstawowym wejściem do wypełnienia tensora. Te wartości będą przepływać do węzła operacyjnego przez tensor, a wynik tej operacji/obliczenia utworzy nowy tensor, który z kolei zostanie użyty w nowej operacji. Wszystkie te operacje można wyświetlić na wykresie.

Reprezentacja tensora

W TensorFlow tensor jest zbiorem wektorów cech (tj. tablicy) o n-wymiarach. Na przykład, jeśli mamy macierz 2×3 o wartościach od 1 do 6, piszemy:

TensorFlow reprezentuje tę macierz jako:

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

Jeżeli utworzymy trójwymiarową macierz o wartościach od 1 do 8, otrzymamy:

TensorFlow reprezentuje tę macierz jako:

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

Uwaga: Tensor można przedstawić za pomocą skalara lub może mieć kształt więcej niż trzech wymiarów. Po prostu trudniej jest wizualizować wyższy poziom wymiaru.

Rodzaje tensora

W TensorFlow wszystkie obliczenia przechodzą przez jeden lub więcej tensorów. Tf.tensor to obiekt o trzech właściwościach:

• Unikalna etykieta (nazwa)
• Wymiar (kształt)
• Typ danych (dtype)

Każda operacja, którą wykonasz z TensorFlow, obejmuje manipulację tensorem. Istnieją cztery główne typy tensorów, które możesz utworzyć:

• tf.Zmienna
• tf.stała
• symbol zastępczy tf
• tf.SparseTensor

W tym samouczku dowiesz się, jak utworzyć tf.constant i tf.Variable.

Zanim przejdziemy przez samouczek, upewnij się, że aktywowałeś środowisko conda za pomocą TensorFlow. Nazwaliśmy to środowisko hello-tf.

Dla użytkowników MacOS:

source activate hello-tf

Dla litu szacuje się Windows użytkownik:

activate hello-tf

Gdy już to zrobisz, możesz zaimportować tensorflow

# Import tf
import tensorflow as tf

Utwórz tensor n-wymiaru

Zaczynasz od utworzenia tensora o jednym wymiarze, a mianowicie skalarze.

Aby utworzyć tensor, możesz użyć tf.constant(), jak pokazano w poniższym przykładzie kształtu tensora TensorFlow:

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`

Aby utworzyć tensor o wymiarze 0, uruchom następujący kod

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

Wydajność

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

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

Wydajność

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

Każdy tensor jest wyświetlany przez nazwę tensora. Każdy obiekt tensora jest zdefiniowany za pomocą atrybutów tensora, takich jak unikalna etykieta (nazwa), wymiar (kształt) i typy danych TensorFlow (dtype).

Można zdefiniować tensor z wartościami dziesiętnymi lub ciągiem znaków, zmieniając typ danych.

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

Wydajność

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

Tensor wymiaru 1 można utworzyć w następujący sposób:

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

Wydajność

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

Można zauważyć, że kształt TensorFlow składa się tylko z 1 kolumny.

Aby utworzyć tablicę 2 wymiarów tensora, musisz zamknąć nawiasy po każdym wierszu. Sprawdź poniższy przykład kształtu tensora Keras

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

Wydajność

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

Macierz ma 2 wiersze i 2 kolumny wypełnione wartościami 1, 2, 3, 4.

Macierz trójwymiarowa powstaje poprzez dodanie kolejnego poziomu za pomocą nawiasów.

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

Wydajność

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

Matryca wygląda jak na obrazku drugim.

Kształt tensora

Kiedy drukujesz tensor, TensorFlow odgaduje kształt. Można jednak uzyskać kształt tensora za pomocą właściwości kształtu TensorFlow.

Poniżej konstruujesz macierz wypełnioną liczbą od 10 do 15 i sprawdzasz kształt m_shape

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

Wydajność

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

Macierz ma 3 wiersze i 2 kolumny.

TensorFlow zawiera przydatne polecenia do tworzenia wektora lub macierzy wypełnionej wartościami 0 lub 1. Na przykład, jeśli chcesz utworzyć tensor 1-D o określonym kształcie 10 wypełnionym wartością 0, możesz uruchomić poniższy kod:

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

Wydajność

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

Właściwość działa również dla macierzy. Tutaj tworzysz macierz 10×10 wypełnioną jedynką

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

Wydajność

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

Możesz użyć kształtu danej macierzy, aby utworzyć wektor jedynek. Macierz m_shape ma wymiary 3×2. Możesz utworzyć tensor z 3 wierszami wypełnionymi jedynkami za pomocą następującego kodu:

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

Wydajność

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

Jeśli przekażesz wartość 1 do nawiasu, możesz skonstruować wektor jedynek równy liczbie kolumn macierzy m_shape.

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

Wydajność

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

Wreszcie możesz stworzyć macierz 3×2 z tylko jednej

print(tf.ones(m_shape.shape))

Wydajność

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

Rodzaj danych

Drugą właściwością tensora jest typ danych. Tensor może mieć jednocześnie tylko jeden typ danych. Tensor może zawierać tylko jeden typ danych. Typ można zwrócić za pomocą właściwości dtype.

print(m_shape.dtype)

Wydajność

<dtype: 'int32'>

W niektórych przypadkach chcesz zmienić typ danych. W TensorFlow jest to możliwe za pomocą metody tf.cast.

Przykład

Poniżej tensor zmiennoprzecinkowy jest konwertowany na liczbę całkowitą przy użyciu metody rzutowania.

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

Wydajność

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

TensorFlow automatycznie wybiera typ danych, jeśli podczas tworzenia tensora nie zostanie określony argument. TensorFlow odgadnie, jakie są najbardziej prawdopodobne typy danych. Na przykład, jeśli przekażesz tekst, odgadnie, że jest to ciąg znaków i przekonwertuje go na ciąg.

Tworzenie operatora

Niektóre przydatne operatory TensorFlow

Wiesz, jak utworzyć tensor za pomocą TensorFlow. Czas nauczyć się, jak wykonywać operacje matematyczne.

TensorFlow zawiera wszystkie podstawowe operacje. Możesz zacząć od prostej. Użyjesz metody TensorFlow, aby obliczyć kwadrat liczby. Ta operacja jest prosta, ponieważ do skonstruowania tensora wymagany jest tylko jeden argument.

Kwadrat liczby jest konstruowany za pomocą tf.sqrt(x) z x jako liczbą zmiennoprzecinkową.

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

Wydajność

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

Uwaga: Wyjście zwróciło obiekt tensora, a nie wynik kwadratu 2. W tym przykładzie drukujesz definicję tensora, a nie rzeczywistą ocenę operacji. W następnej sekcji dowiesz się, jak działa TensorFlow, aby wykonać operacje.

Poniżej znajduje się lista powszechnie używanych operacji. Pomysł jest ten sam. Każda operacja wymaga jednego lub więcej argumentów.

• tf.add(a, b)
• tf.substract(a, b)
• tf.mnożyć(a, b)
• tf.div(a, b)
• tf.pow(a, b)
• tf.exp(a)
• tf.sqrt(a)

Przykład

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

Wydajność

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

Code Wyjaśnienie

Utwórz dwa tensory:

• jeden tensor z 1 i 2
• jeden tensor z 3 i 4

Sumujesz oba tensory.

Informacje : że oba tensory muszą mieć ten sam kształt. Można wykonać mnożenie przez dwa tensory.

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

Wydajność

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

Zmienne

Jak dotąd utworzyłeś tylko tensory stałe. Nie jest to zbyt przydatne. Dane zawsze przychodzą z różnymi wartościami, aby to uchwycić, możesz użyć klasy Variable. Będzie reprezentować węzeł, w którym wartości zawsze się zmieniają.

Aby utworzyć zmienną, możesz użyć metody 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.

Na przykład poniższy kod tworzy dwuwymiarową zmienną z dwiema losowymi wartościami. Domyślnie TensorFlow zwraca wartość losową. Nazywasz zmienną var

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

Wydajność

(1, 2)

W drugim przykładzie tworzysz zmienną zawierającą jeden wiersz i dwie kolumny. Aby utworzyć wymiar zmiennej, musisz użyć [1,2].

Początkowe wartości tego tensora wynoszą zero. Na przykład podczas uczenia modelu potrzebne są wartości początkowe, aby obliczyć wagę funkcji. Poniżej ustawiasz tę wartość początkową na zero.

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

Wydajność

(1, 2)

Możesz przekazać wartości stałego tensora do zmiennej. Tworzysz stały tensor za pomocą metody tf.constant(). Tensora tego używasz do inicjalizacji zmiennej.

Pierwsze wartości zmiennej to 10, 20, 30 i 40. Nowy tensor będzie miał kształt 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)

Wydajność

(2, 2)

zastępczy

Symbol zastępczy ma na celu zasilenie tensora. Symbol zastępczy służy do inicjowania przepływu danych wewnątrz tensorów. Aby dostarczyć symbol zastępczy, musisz użyć metody Feed_dict. Symbol zastępczy będzie zasilany tylko w ramach sesji.

W następnym przykładzie zobaczysz, jak utworzyć symbol zastępczy za pomocą metody tf.placeholder. W następnej sesji nauczysz się karmić symbol zastępczy rzeczywistą wartością tensora.

Składnia jest następująca:

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)

Wydajność

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

Sesja

TensorFlow działa wokół 3 głównych komponentów:

• Wykres
• napinacz
• Sesja

Komponenty	Opis
Wykres	Graf jest fundamentalny w TensorFlow. Wszystkie operacje matematyczne (ops) są wykonywane wewnątrz grafu. Możesz wyobrazić sobie graf jako projekt, w którym wykonywane są wszystkie operacje. Węzły reprezentują te ops, mogą absorbować lub tworzyć nowe tensory.
napinacz	Tensor reprezentuje dane, które przechodzą między operacjami. Wcześniej widziałeś, jak zainicjować tensor. Różnica między stałą a zmienną polega na tym, że początkowe wartości zmiennej będą się zmieniać w czasie.
Sesja	Sesja wykona operację z grafu. Aby zasilić graf wartościami tensora, musisz otworzyć sesję. Wewnątrz sesji musisz uruchomić operator, aby utworzyć wynik.

Wykresy i sesje są niezależne. Możesz uruchomić sesję i uzyskać wartości do wykorzystania później w dalszych obliczeniach.

W poniższym przykładzie:

• Utwórz dwa tensory
• Utwórz operację
• Otwórz sesję
• Wydrukuj wynik

Krok 1) Tworzysz dwa tensory x i y

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

Krok 2) Operator tworzysz mnożąc x i y

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

Krok 3) Otwierasz sesję. Wszystkie obliczenia zostaną wykonane w ramach sesji. Kiedy skończysz, musisz zamknąć sesję.

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

Wydajność

[8]

Code wyjaśnienie

• tf.Session(): Otwórz sesję. Wszystkie operacje będą przebiegać w sesjach
• run(multiply): wykonuje operację utworzoną w kroku 2.
• print(result_1): Na koniec możesz wydrukować wynik
• zamknij(): Zamyka sesję

Wynik pokazuje 8, co jest mnożeniem x i y.

Innym sposobem utworzenia sesji jest umieszczenie jej w bloku. Zaletą jest to, że automatycznie zamyka sesję.

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

Wydajność

[8]

W kontekście sesji możesz użyć metody eval(), aby wykonać operację. Jest ona równoważna z run(). Sprawia, że ​​kod jest bardziej czytelny.

Możesz utworzyć sesję i zobaczyć wartości wewnątrz tensorów, które dotychczas utworzyłeś.

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

Wydajność

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

Zmienne są domyślnie puste, nawet po utworzeniu tensora. Jeśli chcesz użyć zmiennej, musisz ją zainicjować. Aby zainicjować wartości zmiennej, należy wywołać obiekt tf.global_variables_initializer(). Obiekt ten jawnie zainicjuje wszystkie zmienne. Jest to przydatne przed wytrenowaniem modelu.

Możesz sprawdzić wartości zmiennych, które utworzyłeś wcześniej. Pamiętaj, że musisz użyć run, aby ocenić tensor

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

Wydajność

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

Możesz użyć utworzonego wcześniej symbolu zastępczego i zasilić go rzeczywistą wartością. Musisz przekazać dane do metody Feed_dict.

Na przykład weźmiesz potęgę 2 z symbolu zastępczego data_placeholder_a.

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 Wyjaśnienie

• importuj numpy jako np: Importuj biblioteka numpy do tworzenia danych
• tf.pow(data_placeholder_a, 2): Utwórz operacje
• np.random.rand(1, 10): Utwórz losową tablicę danych
• Feed_dict={data_placeholder_a: data}: Podaj symbol zastępczy danymi

Wydajność

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

Wykres

TensorFlow opiera się na genialnym podejściu do renderowania operacji. Wszystkie obliczenia są reprezentowane za pomocą schematu przepływu danych. Graf przepływu danych został opracowany w celu obserwowania zależności danych między poszczególnymi operacjami. Wzór matematyczny lub algorytm składa się z szeregu kolejnych operacji. Graf jest wygodnym sposobem wizualizacji sposobu koordynacji obliczeń.

Wykres przedstawia a węzeł oraz krawędź. Węzeł jest reprezentacją operacji, tj. jednostką obliczeniową. Krawędź jest tensorem, może wytworzyć nowy tensor lub zużyć dane wejściowe. Zależy to od zależności między poszczególnymi operacjami.

Struktura grafu łączy ze sobą operacje (tj. węzły) i sposób, w jaki te operacje są zasilane. Należy zauważyć, że graf nie wyświetla wyników operacji, pomaga jedynie zwizualizować połączenie między poszczególnymi operacjami.

Zobaczmy przykład.

Wyobraź sobie, że chcesz ocenić następującą funkcję:

TensorFlow utworzy wykres w celu wykonania funkcji. Wykres wygląda następująco:

Możesz łatwo zobaczyć ścieżkę, jaką pokonują tensory, aby dotrzeć do miejsca docelowego.

Na przykład możesz zobaczyć, że operacja add nie może być wykonana przed i . Wykres wyjaśnia, że ​​będzie to:

1. obliczyć i:
2. dodaj 1) razem
3. dodać do 2)
4. dodać 3) do

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 Wyjaśnienie

• x: Zainicjuj zmienną o nazwie x ze stałą wartością 5
• z: Zainicjuj zmienną zwaną z stałą wartością 6
• c: Zainicjuj stały tensor o nazwie c ze stałą wartością 5
• kwadrat: Zainicjuj stały tensor zwany kwadratem ze stałą wartością 2
• f: Konstruowanie operatora

W tym przykładzie zdecydowaliśmy się zachować stałe wartości zmiennych. Stworzyliśmy także stały tensor zwany c, który jest stałym parametrem funkcji f. Przyjmuje stałą wartość 5. Na wykresie widać ten parametr w tensorze zwanym stałą.

Skonstruowaliśmy również stały tensor dla potęgi w operatorze tf.pow(). Nie jest to konieczne. Zrobiliśmy to, abyś mógł zobaczyć nazwę tensora na wykresie. Jest to okrąg o nazwie kwadrat.

Z wykresu można zrozumieć, co stanie się z tensorami i w jaki sposób może zwrócić wynik 66.

Poniższy kod ocenia funkcję w sesji.

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)

Wydajność

[66]

Podsumowanie

TensorFlow działa wokół:

• Wykres:Środowisko obliczeniowe zawierające operacje i tensory
• Tensory: reprezentuje dane (lub wartość), które będą przepływać na wykresie. To jest krawędź na wykresie
• Sesji:Zezwól na wykonanie operacji

Utwórz stały tensor

stały	przedmiot
D0	tf.constant(1, tf.int16)
D1	tf.stała([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)

Utwórz operatora

Utwórz operatora	przedmiot
a + b	tf.add(a, b)
a * b	tf.mnożyć(a, b)

Utwórz zmienny tensor

Utwórz zmienną	przedmiot
wartość losowa	tf.get_variable(“zmienna”, [1, 2])
zainicjowana pierwsza wartość	tf.get_variable(“var_init_2”, dtype=tf.int32, inicjator=[ [1, 2], [3, 4] ])

Otwórz sesję

Sesja	przedmiot
Utwórz sesję	tf.Sesja()
Uruchom sesję	tf.Sesja.run()
Oblicz tensor	nazwa_zmiennej.eval()
Zamknij sesję	sess.close()
Sesja po bloku	z tf.Session() jako sess: