 TensorFlow.org'da görüntüleyin |  Google Colab'da çalıştırın |  Kaynağı GitHub'da görüntüleyin |  Not defterini indir |
Bu kılavuz, TensorFlow temellerine hızlı bir genel bakış sağlar. Bu dokümanın her bölümü daha büyük bir konuya genel bir bakış niteliğindedir; her bölümün sonunda tam kılavuzların bağlantılarını bulabilirsiniz.
TensorFlow, makine öğrenimi için uçtan uca bir platformdur. Aşağıdakileri destekler:
- Çok boyutlu dizi tabanlı sayısal hesaplama ( NumPy'ye benzer.)
- GPU ve dağıtılmış işleme
- Otomatik farklılaşma
- Model yapımı, eğitimi ve ihracatı
- Ve dahası
Tensörler
TensorFlow, tf.Tensor nesneleri olarak temsil edilen çok boyutlu diziler veya tensörler üzerinde çalışır. İşte iki boyutlu bir tensör:
import tensorflow as tf
x = tf.constant([[1., 2., 3.],
[4., 5., 6.]])
print(x)
print(x.shape)
print(x.dtype)
tf.Tensor( [[1. 2. 3.] [4. 5. 6.]], shape=(2, 3), dtype=float32) (2, 3) <dtype: 'float32'>
Bir tf.Tensor en önemli özellikleri shape ve dtype :
-
Tensor.shape: her bir ekseni boyunca tensörün boyutunu size söyler. -
Tensor.dtype: tensördeki tüm öğelerin türünü söyler.
TensorFlow, tensörler üzerinde standart matematiksel işlemlerin yanı sıra makine öğrenimi için özelleştirilmiş birçok işlemi uygular.
Örneğin:
x + x
<tf.Tensor: shape=(2, 3), dtype=float32, numpy=
array([[ 2., 4., 6.],
[ 8., 10., 12.]], dtype=float32)>
5 * x
<tf.Tensor: shape=(2, 3), dtype=float32, numpy=
array([[ 5., 10., 15.],
[20., 25., 30.]], dtype=float32)>
x @ tf.transpose(x)
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[14., 32.],
[32., 77.]], dtype=float32)>
tf.concat([x, x, x], axis=0)
<tf.Tensor: shape=(6, 3), dtype=float32, numpy=
array([[1., 2., 3.],
[4., 5., 6.],
[1., 2., 3.],
[4., 5., 6.],
[1., 2., 3.],
[4., 5., 6.]], dtype=float32)>
tf.nn.softmax(x, axis=-1)
<tf.Tensor: shape=(2, 3), dtype=float32, numpy=
array([[0.09003057, 0.24472848, 0.6652409 ],
[0.09003057, 0.24472848, 0.6652409 ]], dtype=float32)>
tf.reduce_sum(x)
<tf.Tensor: shape=(), dtype=float32, numpy=21.0>
CPU üzerinde büyük hesaplamalar yapmak yavaş olabilir. Düzgün yapılandırıldığında, TensorFlow, işlemleri çok hızlı yürütmek için GPU'lar gibi hızlandırıcı donanımları kullanabilir.
if tf.config.list_physical_devices('GPU'):
print("TensorFlow **IS** using the GPU")
else:
print("TensorFlow **IS NOT** using the GPU")
TensorFlow **IS** using the GPU
Ayrıntılar için Tensör kılavuzuna bakın.
Değişkenler
Normal tf.Tensor nesneleri değişmezdir. Model ağırlıklarını (veya diğer değişken durumları) TensorFlow'da saklamak için bir tf.Variable kullanın.
var = tf.Variable([0.0, 0.0, 0.0])
var.assign([1, 2, 3])
<tf.Variable 'UnreadVariable' shape=(3,) dtype=float32, numpy=array([1., 2., 3.], dtype=float32)>
var.assign_add([1, 1, 1])
<tf.Variable 'UnreadVariable' shape=(3,) dtype=float32, numpy=array([2., 3., 4.], dtype=float32)>
Ayrıntılar için Değişkenler kılavuzuna bakın.
Otomatik farklılaşma
Gradyan inişi ve ilgili algoritmalar, modern makine öğreniminin temel taşıdır.
Bunu etkinleştirmek için TensorFlow, gradyanları hesaplamak için hesabı kullanan otomatik farklılaşmayı (autodiff) uygular. Genellikle bunu, bir modelin ağırlıklarına göre hata veya kaybının gradyanını hesaplamak için kullanırsınız.
x = tf.Variable(1.0)
def f(x):
y = x**2 + 2*x - 5
return y
f(x)
<tf.Tensor: shape=(), dtype=float32, numpy=-2.0>
x = 1.0 y = f(x) = (1**2 + 2*1 - 5) = -2 .
y türevi y' = f'(x) = (2*x + 2) = 4 . TensorFlow bunu otomatik olarak hesaplayabilir:
with tf.GradientTape() as tape:
y = f(x)
g_x = tape.gradient(y, x) # g(x) = dy/dx
g_x
<tf.Tensor: shape=(), dtype=float32, numpy=4.0>
Bu basitleştirilmiş örnek, yalnızca tek bir skalere ( x ) göre türevi alır, ancak TensorFlow, herhangi bir sayıda skaler olmayan tensöre göre gradyanı aynı anda hesaplayabilir.
Ayrıntılar için Autodiff kılavuzuna bakın.
Grafikler ve tf.fonksiyonu
TensorFlow'u herhangi bir Python kitaplığı gibi etkileşimli olarak kullanabilmenize rağmen, TensorFlow ayrıca aşağıdakiler için araçlar sağlar:
- Performans optimizasyonu : eğitimi ve çıkarımı hızlandırmak için.
- Dışa Aktar : eğitim bittiğinde modelinizi kaydedebilmeniz için.
Bunlar, saf TensorFlow kodunuzu Python'dan ayırmak için tf.function kullanmanızı gerektirir.
@tf.function
def my_func(x):
print('Tracing.\n')
return tf.reduce_sum(x)
tf.function ilk kez çalıştırdığınızda, Python'da yürütülmesine rağmen, işlev içinde yapılan TensorFlow hesaplamalarını temsil eden eksiksiz, optimize edilmiş bir grafik yakalar.
x = tf.constant([1, 2, 3])
my_func(x)
Tracing. <tf.Tensor: shape=(), dtype=int32, numpy=6>
Sonraki çağrılarda TensorFlow, TensorFlow olmayan adımları atlayarak yalnızca optimize edilmiş grafiği yürütür. Aşağıda, print bir my_func işlevi değil, bir Python işlevi olduğundan my_func öğesinin izleme print unutmayın.
x = tf.constant([10, 9, 8])
my_func(x)
<tf.Tensor: shape=(), dtype=int32, numpy=27>
Bir grafik, farklı imzaya sahip girdiler için yeniden kullanılamayabilir ( shape ve dtype ), bu nedenle bunun yerine yeni bir grafik oluşturulur:
x = tf.constant([10.0, 9.1, 8.2], dtype=tf.float32)
my_func(x)
Tracing. <tf.Tensor: shape=(), dtype=float32, numpy=27.3>
Bu yakalanan grafikler iki fayda sağlar:
- Çoğu durumda, yürütmede önemli bir hızlanma sağlarlar (bu önemsiz örnek olmasa da).
- Bu grafikleri
tf.saved_modelkullanarak sunucu veya mobil cihaz gibi diğer sistemlerde çalıştırmak için Python kurulumu gerektirmeden dışa aktarabilirsiniz.
Daha fazla ayrıntı için Grafiklere giriş bölümüne bakın.
Modüller, katmanlar ve modeller
tf.Module , tf.Variable nesnelerinizi ve bunlar üzerinde çalışan tf.function nesnelerini yönetmek için bir sınıftır. tf.Module sınıfı, iki önemli özelliği desteklemek için gereklidir:
-
tf.train.Checkpointkullanarak değişkenlerinizin değerlerini kaydedebilir ve geri yükleyebilirsiniz. Bu, bir modelin durumunu kaydetmek ve geri yüklemek için hızlı olduğu için eğitim sırasında yararlıdır. - tf.saved_model kullanarak
tf.Variabledeğerlerini vetf.functiongrafiklerini içe ve dışatf.saved_model. Bu, modelinizi, onu oluşturan Python programından bağımsız olarak çalıştırmanıza olanak tanır.
Basit bir tf.Module nesnesini dışa aktarmanın tam bir örneği:
class MyModule(tf.Module):
def __init__(self, value):
self.weight = tf.Variable(value)
@tf.function
def multiply(self, x):
return x * self.weight
mod = MyModule(3)
mod.multiply(tf.constant([1, 2, 3]))
<tf.Tensor: shape=(3,), dtype=int32, numpy=array([3, 6, 9], dtype=int32)>
Module kaydedin:
save_path = './saved'
tf.saved_model.save(mod, save_path)
INFO:tensorflow:Assets written to: ./saved/assets 2022-01-19 02:29:48.135588: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
Ortaya çıkan SavedModel, onu oluşturan koddan bağımsızdır. Python'dan, diğer dil bağlamalarından veya TensorFlow Serving'den SavedModel yükleyebilirsiniz . Ayrıca TensorFlow Lite veya TensorFlow JS ile çalışacak şekilde dönüştürebilirsiniz.
reloaded = tf.saved_model.load(save_path)
reloaded.multiply(tf.constant([1, 2, 3]))
<tf.Tensor: shape=(3,), dtype=int32, numpy=array([3, 6, 9], dtype=int32)>
tf.keras.layers.Layer ve tf.keras.Model sınıfları, tf.Module üzerinde oluşturulur ve model oluşturmak, eğitmek ve kaydetmek için ek işlevsellik ve kolaylık yöntemleri sağlar. Bunlardan bazıları bir sonraki bölümde gösterilmiştir.
Ayrıntılar için Modüllere Giriş'e bakın.
Eğitim döngüleri
Şimdi hepsini bir araya getirerek temel bir model oluşturun ve onu sıfırdan eğitin.
İlk olarak, bazı örnek veriler oluşturun. Bu, ikinci dereceden bir eğriyi gevşek bir şekilde takip eden bir nokta bulutu oluşturur:
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams['figure.figsize'] = [9, 6]
x = tf.linspace(-2, 2, 201)
x = tf.cast(x, tf.float32)
def f(x):
y = x**2 + 2*x - 5
return y
y = f(x) + tf.random.normal(shape=[201])
plt.plot(x.numpy(), y.numpy(), '.', label='Data')
plt.plot(x, f(x), label='Ground truth')
plt.legend();
Bir model oluşturun:
class Model(tf.keras.Model):
def __init__(self, units):
super().__init__()
self.dense1 = tf.keras.layers.Dense(units=units,
activation=tf.nn.relu,
kernel_initializer=tf.random.normal,
bias_initializer=tf.random.normal)
self.dense2 = tf.keras.layers.Dense(1)
def call(self, x, training=True):
# For Keras layers/models, implement `call` instead of `__call__`.
x = x[:, tf.newaxis]
x = self.dense1(x)
x = self.dense2(x)
return tf.squeeze(x, axis=1)
model = Model(64)
plt.plot(x.numpy(), y.numpy(), '.', label='data')
plt.plot(x, f(x), label='Ground truth')
plt.plot(x, model(x), label='Untrained predictions')
plt.title('Before training')
plt.legend();
Temel bir eğitim döngüsü yazın:
variables = model.variables
optimizer = tf.optimizers.SGD(learning_rate=0.01)
for step in range(1000):
with tf.GradientTape() as tape:
prediction = model(x)
error = (y-prediction)**2
mean_error = tf.reduce_mean(error)
gradient = tape.gradient(mean_error, variables)
optimizer.apply_gradients(zip(gradient, variables))
if step % 100 == 0:
print(f'Mean squared error: {mean_error.numpy():0.3f}')
Mean squared error: 16.123 Mean squared error: 0.997 Mean squared error: 0.964 Mean squared error: 0.946 Mean squared error: 0.932 Mean squared error: 0.921 Mean squared error: 0.913 Mean squared error: 0.907 Mean squared error: 0.901 Mean squared error: 0.897-yer tutucu47 l10n-yer
plt.plot(x.numpy(),y.numpy(), '.', label="data")
plt.plot(x, f(x), label='Ground truth')
plt.plot(x, model(x), label='Trained predictions')
plt.title('After training')
plt.legend();
Bu işe yarıyor, ancak tf.keras modülünde ortak eğitim yardımcı programlarının uygulamalarının mevcut olduğunu unutmayın. Bu yüzden kendinizinkini yazmadan önce bunları kullanmayı düşünün. Başlangıç olarak, Model.compile ve Model.fit yöntemleri sizin için bir eğitim döngüsü uygular:
new_model = Model(64)
new_model.compile(
loss=tf.keras.losses.MSE,
optimizer=tf.optimizers.SGD(learning_rate=0.01))
history = new_model.fit(x, y,
epochs=100,
batch_size=32,
verbose=0)
model.save('./my_model')
INFO:tensorflow:Assets written to: ./my_model/assets
plt.plot(history.history['loss'])
plt.xlabel('Epoch')
plt.ylim([0, max(plt.ylim())])
plt.ylabel('Loss [Mean Squared Error]')
plt.title('Keras training progress');
Daha fazla ayrıntı için Temel eğitim döngülerine ve Keras kılavuzuna bakın.