TensorFlow Temelleri: Tensör, Şekil, Tür, Oturumlar ve Operaları

Tensör nedir?

Tensorflow'un adı doğrudan çekirdek çerçevesinden türetilmiştir: Tensor. Tensorflow'da tüm hesaplamalar tensörleri içerir. Tensör, tüm veri türlerini temsil eden n boyutlu bir vektör veya matristir. Bir tensördeki tüm değerler, bilinen (veya kısmen bilinen) bir şekle sahip aynı veri tipini içerir. Verinin şekli matrisin veya dizinin boyutluluğudur.

Bir tensör, giriş verilerinden veya bir hesaplamanın sonucundan kaynaklanabilir. TensorFlow'da tüm işlemler bir grafik içerisinde gerçekleştirilir. Grafik, ardışık olarak gerçekleşen bir hesaplama kümesidir. Her bir işleme işlem düğümü adı verilir ve birbirine bağlanır.

Grafik, düğümler arasındaki işlemleri ve bağlantıları özetlemektedir. Ancak değerleri göstermiyor. Düğümlerin kenarı tensördür, yani işlemi verilerle doldurmanın bir yoludur.

Makine Öğreniminde modeller, özellik vektörleri adı verilen nesnelerin bir listesiyle beslenir. Bir özellik vektörü herhangi bir veri türünde olabilir. Özellik vektörü genellikle bir tensörü doldurmak için birincil girdi olacaktır. Bu değerler tensör aracılığıyla bir op düğümüne akacak ve bu işlemin/hesaplamanın sonucu, yeni bir işlemde kullanılacak yeni bir tensör yaratacaktır. Tüm bu işlemleri grafikte görebilirsiniz.

Bir Tensörün Temsili

TensorFlow'da bir tensör, n boyutlu özellik vektörlerinin (yani dizi) bir koleksiyonudur. Örneğin, 2'den 3'ya kadar değerleri olan 1x6'lük bir matrisimiz varsa şunu yazarız:

TensorFlow bu matrisi şu şekilde temsil eder:

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

1'den 8'e kadar değerlere sahip üç boyutlu bir matris oluşturursak:

TensorFlow bu matrisi şu şekilde temsil eder:

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

Not: Bir tensör bir skaler ile temsil edilebilir veya üç boyuttan daha büyük bir şekle sahip olabilir. Daha yüksek boyut seviyesini görselleştirmek sadece daha karmaşıktır.

Tensör Çeşitleri

TensorFlow'da tüm hesaplamalar bir veya daha fazla tensörden geçer. Bir tf.tensor üç özelliğe sahip bir nesnedir:

• Benzersiz bir etiket (isim)
• Bir boyut (şekil)
• Bir veri türü (dtype)

TensorFlow ile yapacağınız her işlem bir tensörün manipülasyonunu içerir. Oluşturabileceğiniz dört ana tensör türü vardır:

• tf.Değişken
• tf.sabit
• tf.yer tutucu
• tf.SparseTensor

Bu eğitimde tf.constant ve tf.Variable'ın nasıl oluşturulacağını öğreneceksiniz.

Öğreticiye geçmeden önce conda ortamını TensorFlow ile etkinleştirdiğinizden emin olun. Bu ortama hello-tf adını verdik.

MacOS kullanıcıları için:

source activate hello-tf

ABD Windows kullanıcı:

activate hello-tf

Bunu yaptıktan sonra tensorflow'u içe aktarmaya hazırsınız

# Import tf
import tensorflow as tf

N boyutlu bir tensör oluşturun

Tek boyutlu, yani skaler bir tensörün yaratılmasıyla başlarsınız.

Bir tensör oluşturmak için aşağıdaki TensorFlow tensör şekli örneğinde gösterildiği gibi tf.constant() öğesini kullanabilirsiniz:

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`

0 boyutlu bir tensör oluşturmak için aşağıdaki kodu çalıştırın

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

Çıktı

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

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

Çıktı

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

Her tensör tensör adıyla görüntülenir. Her tensör nesnesi, benzersiz bir etiket (ad), boyut (şekil) ve TensorFlow veri türleri (dtype) gibi tensör nitelikleriyle tanımlanır.

Veri türünü değiştirerek ondalık değerlerle veya bir dizeyle tensör tanımlayabilirsiniz.

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

Çıktı

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

Boyut 1'in bir tensörü aşağıdaki gibi oluşturulabilir:

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

Çıktı

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

TensorFlow şeklinin yalnızca 1 sütundan oluştuğunu fark edebilirsiniz.

2 tensör boyutlu bir dizi oluşturmak için her satırdan sonra parantezleri kapatmanız gerekir. Aşağıdaki Keras Tensör şekil örneğini kontrol edin

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

Çıktı

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

Matrisin 2, 2, 1, 2 değerleriyle dolu 3 satırı ve 4 sütunu vardır.

Parantez içine bir düzey daha eklenerek 3 boyutlu bir matris oluşturulur.

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

Çıktı

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

Matris ikinci resimdekine benziyor.

Tensörün şekli

Tensörü yazdırdığınızda TensorFlow şekli tahmin eder. Ancak TensorFlow Shape özelliği ile tensörün şeklini elde edebilirsiniz.

Aşağıda 10'dan 15'e kadar sayılarla dolu bir matris oluşturuyorsunuz ve m_shape'in şeklini kontrol ediyorsunuz.

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

Çıktı

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

Matrisin 3 satırı ve 2 sütunu vardır.

TensorFlow, 0 veya 1 ile doldurulmuş bir vektör veya matris oluşturmak için yararlı komutlara sahiptir. Örneğin, 1 ile doldurulmuş, belirli bir 10 şekline sahip 0 boyutlu bir tensör oluşturmak istiyorsanız aşağıdaki kodu çalıştırabilirsiniz:

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

Çıktı

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

Özellik matris için de çalışır. Burada 10 ile dolu 10x1'luk bir matris yaratırsınız.

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

Çıktı

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

Verilen bir matrisin şeklini kullanarak birlerden oluşan bir vektör oluşturabilirsiniz. m_shape matrisi 3×2 boyutludur. Aşağıdaki kodla birlerle dolu 3 satırdan oluşan bir tensör oluşturabilirsiniz:

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

Çıktı

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

Eğer 1 değerini parantez içine alırsanız, m_shape matrisindeki sütun sayısına eşit olanlardan oluşan bir vektör oluşturabilirsiniz.

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

Çıktı

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

Son olarak, yalnızca bir tane ile 3×2'lik bir matris oluşturabilirsiniz.

print(tf.ones(m_shape.shape))

Çıktı

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

Veri tipi

Tensörün ikinci özelliği veri türüdür. Bir tensör aynı anda yalnızca bir tür veriye sahip olabilir. Bir tensör yalnızca bir tür veriye sahip olabilir. Türü dtype özelliğiyle döndürebilirsiniz.

print(m_shape.dtype)

Çıktı

<dtype: 'int32'>

Bazı durumlarda veri türünü değiştirmek istersiniz. TensorFlow'da tf.cast metodu ile mümkündür.

Örnek E-posta

Aşağıda, bir kayan nokta tensörü, cast yöntemini kullanarak tam sayıya dönüştürülür.

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

Çıktı

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

TensorFlow, tensörün oluşturulması sırasında argüman belirtilmediğinde veri türünü otomatik olarak seçer. TensorFlow, en olası veri türlerinin ne olduğunu tahmin edecektir. Örneğin, bir metni iletirseniz, bunun bir dize olduğunu tahmin edecek ve onu dizeye dönüştürecektir.

Operatör oluşturma

Bazı Faydalı TensorFlow operatörleri

TensorFlow ile nasıl tensör oluşturulacağını biliyorsunuz. Matematiksel işlemlerin nasıl gerçekleştirileceğini öğrenmenin zamanı geldi.

TensorFlow tüm temel işlemleri içerir. Basit bir taneyle başlayabilirsiniz. Bir sayının karesini hesaplamak için TensorFlow yöntemini kullanacaksınız. Bu işlem basittir çünkü tensörü oluşturmak için yalnızca bir argüman gereklidir.

Bir sayının karesi, x'in kayan sayı olduğu tf.sqrt(x) ile oluşturulur.

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

Çıktı

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

Not: Çıktı, 2'nin karesinin sonucu değil, bir tensör nesnesi döndürdü. Örnekte, işlemin gerçek değerlendirmesini değil, tensörün tanımını yazdırıyorsunuz. Bir sonraki bölümde TensorFlow'un işlemleri yürütmek için nasıl çalıştığını öğreneceksiniz.

Aşağıda yaygın olarak kullanılan işlemlerin bir listesi bulunmaktadır. Fikir aynıdır. Her işlem bir veya daha fazla argüman gerektirir.

• tf.add(a, b)
• tf.substract(a, b)
• tf.çarpma(a, b)
• tf.div(a, b)
• tf.pow(a, b)
• tf.exp(a)
• tf.sqrt(a)

Örnek E-posta

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

Çıktı

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

Kod Açıklama

İki tensör oluşturun:

• 1 ve 2 ile bir tensör
• 3 ve 4 ile bir tensör

Her iki tensörü de topluyorsunuz.

ihbar: her iki tensörün de aynı şekle sahip olması gerekir. İki tensör üzerinde çarpma işlemi yapabilirsiniz.

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

Çıktı

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

Değişkenler

Şu ana kadar yalnızca sabit tensörler oluşturdunuz. Pek kullanışlı değil. Veriler her zaman farklı değerlerle gelir, bunu yakalamak için Variable sınıfını kullanabilirsiniz. Değerlerin sürekli değiştiği bir düğümü temsil edecektir.

Bir değişken oluşturmak için tf.get_variable() yöntemini kullanabilirsiniz.

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.

Örneğin aşağıdaki kod, iki rastgele değere sahip iki boyutlu bir değişken oluşturur. Varsayılan olarak TensorFlow rastgele bir değer döndürür. Değişkene var adını verirsiniz

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

Çıktı

(1, 2)

İkinci örnekte, bir satır ve iki sütundan oluşan bir değişken yaratacaksınız. Değişkenin boyutunu oluşturmak için [1,2] kullanmanız gerekir

Bu tensörün başlangıç ​​değerleri sıfırdır. Örneğin, bir modeli eğitirken özelliklerin ağırlığını hesaplamak için başlangıç ​​değerlerine sahip olmanız gerekir. Aşağıda bu başlangıç ​​değerini sıfıra ayarlayacaksınız.

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

Çıktı

(1, 2)

Sabit bir tensörün değerlerini bir değişkene aktarabilirsiniz. tf.constant() yöntemiyle sabit bir tensör yaratırsınız. Değişkeni başlatmak için bu tensörü kullanırsınız.

Değişkenin ilk değerleri 10, 20, 30 ve 40'tır. Yeni tensör 2×2 şeklinde olacaktır.

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

Çıktı

(2, 2)

Yer Tutucu

Yer tutucunun tensörü besleme amacı vardır. Yer tutucu, tensörlerin içinde akacak verileri başlatmak için kullanılır. Bir yer tutucu sağlamak için feed_dict yöntemini kullanmanız gerekir. Yer tutucu yalnızca bir oturum içinde beslenecektir.

Bir sonraki örnekte tf.placeholder yöntemiyle nasıl yer tutucu oluşturulacağını göreceksiniz. Bir sonraki oturumda, bir yer tutucuyu gerçek tensör değeriyle beslemeyi öğreneceksiniz.

Sözdizimi şöyledir:

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)

Çıktı

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

oturum

TensorFlow 3 ana bileşen etrafında çalışır:

• grafik
• tensör
• oturum

Bileşenler	Açıklama
grafik	Grafik TensorFlow'da temeldir. Tüm matematiksel işlemler (ops) bir grafik içinde gerçekleştirilir. Bir grafiği her işlemin yapıldığı bir proje olarak düşünebilirsiniz. Düğümler bu operasyonları temsil eder, yeni tensörleri emebilir veya oluşturabilirler.
tensör	Tensör, işlemler arasında ilerleyen verileri temsil eder. Daha önce bir tensörün nasıl başlatılacağını gördünüz. Bir sabit ile değişken arasındaki fark, bir değişkenin başlangıç ​​değerlerinin zamanla değişmesidir.
oturum	Bir oturum, işlemi grafikten yürütecektir. Grafiği bir tensörün değerleriyle beslemek için bir oturum açmanız gerekir. Bir oturumun içinde çıktı oluşturmak için bir operatörü çalıştırmanız gerekir.

Grafikler ve oturumlar bağımsızdır. Bir oturum çalıştırabilir ve daha sonraki hesaplamalar için kullanmak üzere değerleri alabilirsiniz.

Aşağıdaki örnekte şunları yapacaksınız:

• İki tensör oluşturun
• Bir işlem oluştur
• Bir oturum aç
• Sonucu yazdırın

) 1 Adım İki tensör x ve y yaratırsınız

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

) 2 Adım Operatörü x ve y'yi çarparak oluşturursunuz

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

) 3 Adım Bir oturum açıyorsunuz. Tüm hesaplamalar oturum içerisinde gerçekleşecektir. İşiniz bittiğinde oturumu kapatmanız gerekir.

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

Çıktı

[8]

Kod açıklaması

• tf.Session(): Bir oturum açar. Tüm işlemler seanslar içerisinde akacak
• çalıştır(çarp): 2. adımda oluşturulan işlemi yürütün.
• print(result_1): Son olarak sonucu yazdırabilirsiniz.
• close(): Oturumu kapatır

Sonuç, x ve y'nin çarpımı olan 8'i gösterir.

Oturum oluşturmanın başka bir yolu da bloğun içindedir. Avantajı oturumu otomatik olarak kapatmasıdır.

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

Çıktı

[8]

Oturumun bağlamında, işlemi yürütmek için eval() yöntemini kullanabilirsiniz. Run() işlevine eşdeğerdir. Kodu daha okunabilir hale getirir.

Bir oturum oluşturabilir ve şu ana kadar oluşturduğunuz tensörlerin içindeki değerleri görebilirsiniz.

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

Çıktı

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

Bir tensör oluşturduktan sonra bile değişkenler varsayılan olarak boştur. Değişkeni kullanmak istiyorsanız değişkeni başlatmanız gerekir. Bir değişkenin değerlerini başlatmak için tf.global_variables_initializer() nesnesinin çağrılması gerekir. Bu nesne açıkça tüm değişkenleri başlatacaktır. Bu, bir modeli eğitmeden önce faydalıdır.

Daha önce oluşturduğunuz değişkenlerin değerlerini kontrol edebilirsiniz. Tensörü değerlendirmek için run'u kullanmanız gerektiğini unutmayın.

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

Çıktı

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

Daha önce oluşturduğunuz yer tutucuyu kullanıp gerçek değerle besleyebilirsiniz. Verileri feed_dict yöntemine aktarmanız gerekir.

Örneğin, data_placeholder_a yer tutucusunun 2'sinin kuvvetini alacaksınız.

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.

Kod Açıklama

• numpy'yi np olarak içe aktar: İçe aktar numpy kütüphanesi verileri oluşturmak için
• tf.pow(data_placeholder_a, 2): İşlemleri oluşturun
• np.random.Rand(1, 10): Rastgele bir veri dizisi oluşturun
• feed_dict={data_placeholder_a: data}: Yer tutucuyu verilerle besleyin

Çıktı

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

grafik

TensorFlow, işlemi gerçekleştirmek için dahiyane bir yaklaşıma dayanır. Tüm hesaplamalar bir veri akışı şemasıyla temsil edilir. Veri akışı grafiği, bireysel işlemler arasındaki veri bağımlılıklarını görmek için geliştirilmiştir. Matematiksel formül veya algoritma birbirini takip eden bir dizi işlemden oluşur. Grafik, hesaplamaların nasıl koordine edildiğini görselleştirmenin uygun bir yoludur.

Grafikte bir düğüm ve bir kenar. Düğüm bir işlemin, yani hesaplama biriminin temsilidir. Kenar tensördür, yeni bir tensör üretebilir veya giriş verilerini tüketebilir. Bireysel operasyonlar arasındaki bağımlılıklara bağlıdır.

Grafiğin yapısı, işlemleri (yani düğümleri) ve bunların nasıl beslendiklerini birbirine bağlar. Grafiğin işlemlerin çıktısını göstermediğini, yalnızca bireysel işlemler arasındaki bağlantıyı görselleştirmeye yardımcı olduğunu unutmayın.

Bir örnek görelim.

Aşağıdaki fonksiyonu değerlendirmek istediğinizi düşünün:

TensorFlow, işlevi yürütmek için bir grafik oluşturacaktır. Grafik şöyle görünüyor:

Tensörlerin nihai hedefe ulaşmak için izleyecekleri yolu kolaylıkla görebilirsiniz.

Örneğin add işleminin daha önce yapılamayacağını ve . Grafik şunu açıklıyor:

1. hesaplayın ve:
2. 1)'i birlikte ekleyin
3. 2'ye ekle)
4. 3)'ü ekle

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

Kod Açıklama

• x: x adlı bir değişkeni 5 sabit değeriyle başlatın
• z: z adlı bir değişkeni 6 sabit değeriyle başlatın
• c: c adı verilen sabit bir tensörü 5 sabit değeriyle başlatın
• kare: Kare adı verilen sabit değeri 2 olan sabit bir tensörü başlatın
• f: Operatörü oluşturun

Bu örnekte değişkenlerin değerlerini sabit tutmayı seçiyoruz. Ayrıca f fonksiyonundaki sabit parametre olan c adında bir sabit tensör oluşturduk. 5 gibi sabit bir değer alır. Grafikte bu parametreyi sabit adı verilen tensörde görebilirsiniz.

Ayrıca tf.pow() operatöründeki güç için sabit bir tensör oluşturduk. Bu gerekli değil. Tensörün adını grafikte görebilmeniz için yaptık. Kare adı verilen dairedir.

Grafikten tensörlerin ne olacağını ve nasıl 66 çıktısını döndürebileceğini anlayabilirsiniz.

Aşağıdaki kod bir oturumdaki işlevi değerlendirir.

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)

Çıktı

[66]

ÖZET

TensorFlow etrafında çalışır:

• grafik: İşlemleri ve tensörleri içeren hesaplama ortamı
• Tansörler: Grafikte akacak verileri (veya değeri) temsil eder. Grafikteki kenardır
• Oturumlar: İşlemlerin yürütülmesine izin ver

Sabit bir tensör oluşturun

sabit	nesne
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)

Operatör oluştur

Operatör oluştur	nesne
a + b	tf.add(a, b)
a * b	tf.çarpma(a, b)

Değişken tensör oluşturma

Bir değişken oluşturun	nesne
rastgele değer	tf.get_variable(“var”, [1, 2])
başlatılan ilk değer	tf.get_variable(“var_init_2”, dtype=tf.int32, başlatıcı=[ [1, 2], [3, 4] ])

Bir oturum aç

oturum	nesne
Oturum oluştur	tf.Oturum()
Bir oturum çalıştırın	tf.Session.run()
Bir tensörü değerlendirin	değişken_adı.eval()
Bir oturumu kapat	sess.close()
Blok bazında oturum	sess olarak tf.Session() ile: