TensorFlow'da Tensor Nedir? Şekli, Türü ve Operaları

Tensör nedir?

Adı TensorFlow TensorFlow, temel nesnesi olan tensörden doğrudan türetilmiştir. TensorFlow'da her hesaplama 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 türünü içerir ve 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çinde gerçekleştirilir. Grafik, ardışık olarak gerçekleşen bir dizi hesaplamadan oluşur. Her işleme bir işlem düğümü (op node) denir ve düğümler birbirine bağlıdır.

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

Makine öğreniminde, modellere özellik vektörleri adı verilen bir nesne listesi verilir. Bir özellik vektörü herhangi bir veri türünde olabilir ve genellikle bir tensörü dolduran birincil girdidir. Bu değerler tensör aracılığıyla bir işlem düğümüne akar ve bu işlemin sonucu yeni bir tensör oluşturur; bu tensör de yeni bir işlemde kullanılır. Tüm bu işlemler grafikte görülebilir.

Bir Tensörün Temsili

TensorFlow'da bir tensör, n boyutlu özellik vektörlerinin (yani bir dizinin) bir koleksiyonudur. Örneğin, 1'den 6'ya kadar değerlere sahip 2×3'lük bir matrisimiz varsa, bunu aşağıdaki gibi bir matris olarak 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, aynı veriler üst üste iki yüzü olan bir kutu olarak çizilir:

TensorFlow bu matrisi şu şekilde temsil eder:

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

Not: Bir tensör, bir skalerle temsil edilebilir veya üç boyuttan daha fazla bir şekle sahip olabilir. Ancak daha yüksek boyut seviyelerini görselleştirmek daha zordur.

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 gerçekleştirdiğiniz her işlem, bir tensörün manipülasyonunu içerir. Oluşturabileceğiniz dört ana tensör türü vardır:

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

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

Kodu çalıştırmadan önce aklınızda bulundurmanız gereken bir nokta: Bu eğitim, bir grafiğin önce oluşturulduğu ve daha sonra bir oturum içinde yürütüldüğü orijinal TensorFlow 1.x API'sini takip etmektedir. TensorFlow 2 varsayılan olarak hemen çalıştırılır, bu nedenle aşağıdaki sembollerin birçoğu taşındı veya kaldırıldı. Bunların her birine hala erişilebilir. tf.compat.v1 Ad alanı ve tablo, her birini modern karşılığına eşler.

Eğitime başlamadan önce, TensorFlow'un kurulu olduğu conda ortamını etkinleştirdiğinizden emin olun. Bu ortamın adı hello-tf'dir.

Her Ticaretçi İçin Mükemmellik macOS kullanıcılar:

source activate hello-tf

Her Ticaretçi İçin Mükemmellik Windows kullanıcılar:

activate hello-tf

Bunu yaptıktan sonra, TensorFlow'u içe aktarmaya hazırsınız.

# Import tf
import tensorflow as tf

N Boyutunun 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 şunu kullanabilirsiniz: tf.constant() Aşağıda TensorFlow tensör şekli örneğinde gösterildiği gibi:

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`

Boyutu 0 olan 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)

Aşağıda açıklama eklenmiş versiyonunda da görüldüğü gibi, bu çıktının üç bölümü üç tensör özelliğine karşılık gelir.

Tensöre kendi adınızı da verebilirsiniz. name argüman.

# 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), bir boyut (şekil) ve bir TensorFlow veri türü (dtype) gibi özelliklerle 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 olan bir tensör şu şekilde oluşturulabilir:

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

Çı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.

İki boyutlu bir tensör dizisi oluşturmak için, her satırdan sonra parantezleri kapatmanız gerekir. Aşağıdaki tensör şekli örneğini inceleyin.

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

Matris, 1, 2, 3 ve 4 değerleriyle doldurulmuş 2 satır ve 2 sütundan oluşmaktadır.

Üç boyutlu bir matris, parantezlere bir seviye daha eklenerek 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)

Sonuç, bu eğitimde daha önce gösterilen üç boyutlu kutu diyagramıyla eşleşiyor.

Tensörün Şekli

Bir tensörü yazdırdığınızda, TensorFlow şeklini çıkarır. Ancak, TensorFlow ile şekli doğrudan okuyabilirsiniz. shape özelliği.

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

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

Bu özellik matrisler için de geçerlidir. Burada, 1'lerle doldurulmuş 10×10'luk bir matris oluşturuyorsunuz.

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

Çıktı

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

Verilen bir matrisin şeklini kullanarak birler vektörü oluşturabilirsiniz. Matris m_shape 3×2 boyutlarında olduğundan, aşağıdaki kod 3 satırı birlerle dolu bir tensör oluşturur:

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

Parantez içine 1 değerini girerseniz, matristeki sütun sayısı kadar 1'lerden oluşan bir vektör oluşturursunuz. m_shape.

# 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, tamamı birlerden oluşan 3×2'lik bir matris oluşturabilirsiniz.

print(tf.ones(m_shape.shape))

Çıktı

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

Veri Türü

Tensörün ikinci özelliği veri türüdür. Bir tensör aynı anda yalnızca bir tür veri tutabilir ve bu türü şu şekilde okuyabilirsiniz: dtype özelliği.

print(m_shape.dtype)

Çıktı

<dtype: &#x27;int32'>

Bazı durumlarda veri türünü değiştirmek isteyebilirsiniz. TensorFlow'da bu, aşağıdaki yöntemle mümkündür: tf.cast yöntemi.

Örnek E-posta

Aşağıda, bir kayan noktalı tensör, aşağıdaki yöntemle tamsayıya dönüştürülmüştür. cast yöntemi.

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

TensorFlow, tensör oluşturma sırasında argüman belirtilmediğinde veri türünü otomatik olarak seçer. TensorFlow, en olası veri türünü tahmin eder: örneğin, metin geçerseniz, bunun bir dize olduğunu varsayar.

Oluşturma Operator

Bazı Yararlı TensorFlow Operaları

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 işlemle başlayıp, bir sayının karekökünü hesaplamak için bir TensorFlow metodu kullanabilirsiniz. Bu işlem oldukça basittir çünkü tensörü oluşturmak için yalnızca bir argüman gereklidir.

Bir sayının karekökü aşağıdaki formülle oluşturulur: tf.sqrt(x)x, ondalıklı bir sayı olmak üzere,

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

Çıktı

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

Not: Çıktı, 2'nin karekökünü değil, bir tensör nesnesini döndürdü. Bu örnekte, işlemin gerçek değerlendirmesini değil, tensörün tanımını yazdırıyorsunuz. Aşağıdaki Oturum bölümünde, TensorFlow'un işlemleri nasıl yürüttüğünü öğreneceksiniz.

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

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

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

Code 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.

İki tensörün de aynı şekle sahip olması gerektiğini unutmayın. Ayrıca iki tensör üzerinde çarpma işlemi de gerçekleştirebilirsiniz.

# 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 ki bu tek başına sınırlı bir kullanıma sahiptir. Veriler her zaman farklı değerlerle gelir ve bunu yakalamak için Variable sınıfını kullanabilirsiniz. Bir değişken, değerleri zaman içinde değişen bir düğümü temsil eder.

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

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ı veriyorsunuz.

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

Çıktı

(1, 2)

Bu örnekte, tek satır ve iki sütundan oluşan bir değişken oluşturuyorsunuz, bu nedenle değişkenin boyutu olarak [1, 2] değerini iletiyorsunuz.

Bir tensörün başlangıç ​​değerleri sıfır da olabilir. Örneğin, bir model eğitirken, özelliklerin ağırlığını hesaplamadan önce başlangıç ​​değerlerine ihtiyacınız vardır. Aşağıda, bu başlangıç ​​değerlerini sıfıra ayarlıyorsunuz.

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 de aktarabilirsiniz. Sabit bir tensörü şu yöntemle oluşturursunuz: tf.constant() ve bu tensörü kullanarak değişkeni başlatın.

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

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

Çıktı

(2, 2)

Yer Tutucu

Yer tutucunun amacı tensöre veri sağlamaktır. Yer tutucu, tensörlerin içine akacak verileri başlatır. Bir yer tutucu sağlamak için şunu kullanırsınız: feed_dict Bu argüman geçerlidir ve yer tutucu yalnızca oturum içinde beslenir.

Bir sonraki örnekte, bu yöntemle nasıl yer tutucu oluşturulacağını göreceksiniz. tf.placeholderOturum bölümünde, bir yer tutucuya gerçek bir tensör değeri nasıl gireceğinizi öğ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

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

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

Adım 1) x ve y olmak üzere iki tensör oluşturun.

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

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

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

3. Adım) Bir oturum açarsınız. Tüm hesaplamalar oturum içinde gerçekleşir ve iş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]

Code açıklama

• tf.Session(): Bir oturum açın. Tüm işlemler oturum içerisinde gerçekleşir.
• run(multiply)2. adımda oluşturulan işlemi yürütün
• print(result_1)Son olarak, sonucu yazdırabilirsiniz.
• close()Oturumu kapat

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

Oturum oluşturmanın bir başka yolu da blok içinde oluşturmaktır. Avantajı, oturumu otomatik olarak kapatmasıdır.

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

Çıktı

[8]

Bir oturum bağlamında şunları kullanabilirsiniz: eval() İşlemi gerçekleştirme yöntemi. Şuna eşdeğerdir: run() ve kodun daha okunabilir olmasını sağlar.

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]]]

Tensor oluşturulduktan sonra bile değişkenler varsayılan olarak boştur. Bir değişkeni kullanmadan önce başlatmanız gerekir. Nesne tf.global_variables_initializer() Bu fonksiyon, bir modeli eğitmeden önce her değişkenin değerlerini aynı anda başlatmak için çağrılır; bu da faydalıdır.

Daha önce oluşturduğunuz değişkenlerin değerlerini kontrol edebilirsiniz. Tensörü değerlendirmek için `run` komutunu 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 kullanabilir ve ona gerçek bir değer girebilirsiniz. Verileri şuraya aktarmanız gerekiyor: feed_dict argüman.

Ö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.

Code açıklama

• import numpy as np: İçe aktar Dizi verileri oluşturmak için kütüphane
• tf.pow(data_placeholder_a, 2)Operasyonları oluşturun
• np.random.rand(1, 10): Rastgele bir veri dizisi oluşturun
• feed_dict={data_placeholder_a: data}Yer tutucuya veri girin:

Çıktı

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

grafik

TensorFlow, her işlemi bir veri akışı şemasıyla gösterir. Veri akışı grafiği, bireysel işlemler arasındaki veri bağımlılıklarını ortaya koymak için tasarlanmıştır. Matematiksel bir formül veya algoritma, bir dizi ardışık işlemden oluşur ve bir grafik, bu hesaplamaların nasıl koordine edildiğini görselleştirmek için uygun bir yoldur.

Grafik, düğümleri ve kenarları göstermektedir. Bir düğüm, bir işlemin temsilidir, yani hesaplama birimidir. Bir kenar ise tensördür: bireysel işlemler arasındaki bağımlılıklara bağlı olarak yeni bir tensör üretebilir veya giriş verilerini tüketebilir.

Grafın yapısı, işlemleri (yani düğümleri) birbirine bağlar ve her birinin nasıl beslendiğini gösterir. Grafın işlemlerin çıktısını göstermediğini, yalnızca aralarındaki bağlantıları görselleştirmeye yardımcı olduğunu unutmayın.

Bir örnek üzerinden inceleyelim. Aşağıdaki fonksiyonu değerlendirmek istediğinizi hayal edin:

TensorFlow, fonksiyonu çalıştırmak için bir grafik oluşturur. Grafik şu şekilde görünür:

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

Örneğin, add Düğüm, her ikisinden önce çalıştırılamaz. Mul hem de Pow Sonuçlarını ortaya koydular. Grafik, TensorFlow'un şunları yapacağını gösteriyor:

1. x·z'yi hesaplayın Mul düğüm ve x²'de Pow düğüm
2. Bu iki sonucu bir araya ekleyin. add düğüm
3. Bu toplamaya z'yi ekleyin. add_1 düğüm
4. 5 sabitini ekleyin add_2 düğüm

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 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ğerleri sabit tutulmuştur. Sabit tensör c, f fonksiyonundaki sabit parametredir ve 5 sabit değerini alır; grafikte bu parametreyi sabit adı verilen tensörde görebilirsiniz.

Operatördeki güç için de sabit bir tensör oluşturuldu. tf.pow()Gerekli olmasa da, üssün grafikte kare adı verilen bir daire şeklinde görünmesi anlamına gelir.

Grafikten, tensörlere ne olduğunu ve fonksiyonun neden 66 döndürdüğünü anlayabilirsiniz: 5 × 6 + 5² + 6 + 5 = 66.

Aşağıdaki kod, fonksiyonu bir oturum içinde 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]

TensorFlow Temelleri Hızlı Referans

Aşağıdaki dört tablo, bu eğitimde kullanılan tüm komutları bir araya getiriyor, böylece örnekler arasında geriye doğru kaydırmanıza gerek kalmadan istediğiniz komutu bulabilirsiniz.

Sabit bir tensör oluşturun

Operatör oluştur

Değişken tensör oluşturma

Bir oturum aç

SSS