 TensorFlow.org'da görüntüleyin |  Google Colab'da çalıştırın |  Kaynağı GitHub'da görüntüleyin |  Not defterini indir |
Önceki kılavuzlarda tensörler , değişkenler , degrade bant ve modüller hakkında bilgi edindiniz. Bu kılavuzda, modelleri eğitmek için bunların hepsini bir araya getireceksiniz.
TensorFlow, aynı zamanda, kalıp levhasını azaltmak için faydalı soyutlamalar sağlayan üst düzey bir sinir ağı API'si olan tf.Keras API'sini de içerir. Ancak bu kılavuzda temel sınıfları kullanacaksınız.
Kurmak
import tensorflow as tf
import matplotlib.pyplot as plt
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
Makine öğrenimi sorunlarını çözme
Bir makine öğrenimi problemini çözmek genellikle aşağıdaki adımlardan oluşur:
- Eğitim verilerini alın.
- Modeli tanımlayın.
- Bir kayıp fonksiyonu tanımlayın.
- İdeal değerden kaybı hesaplayarak eğitim verilerini gözden geçirin
- Bu kayıp için gradyanları hesaplayın ve değişkenleri verilere uyacak şekilde ayarlamak için bir optimize edici kullanın.
- Sonuçlarınızı değerlendirin.
Açıklama amacıyla, bu kılavuzda, iki değişkeni olan \(f(x) = x * W + b\)adlı basit bir doğrusal model geliştireceksiniz: \(W\) (ağırlıklar) ve \(b\) (bias).
Bu, makine öğrenimi problemlerinin en temelidir: \(x\) ve \(y\)verildiğinde, basit doğrusal regresyon yoluyla bir çizginin eğimini ve ofsetini bulmaya çalışın.
Veri
Denetimli öğrenme, girdileri (genellikle x ile gösterilir) ve çıktıları ( y ile gösterilir, genellikle etiketler olarak adlandırılır) kullanır. Amaç, bir girdiden çıktının değerini tahmin edebilmeniz için eşleştirilmiş girdi ve çıktılardan öğrenmektir.
TensorFlow'da verilerinizin her girişi hemen hemen her zaman bir tensör ile temsil edilir ve genellikle bir vektördür. Denetimli eğitimde çıktı (veya tahmin etmek istediğiniz değer) aynı zamanda bir tensördür.
İşte bir çizgi boyunca noktalara Gauss (Normal) gürültü eklenerek sentezlenen bazı veriler.
# The actual line
TRUE_W = 3.0
TRUE_B = 2.0
NUM_EXAMPLES = 201
# A vector of random x values
x = tf.linspace(-2,2, NUM_EXAMPLES)
x = tf.cast(x, tf.float32)
def f(x):
return x * TRUE_W + TRUE_B
# Generate some noise
noise = tf.random.normal(shape=[NUM_EXAMPLES])
# Calculate y
y = f(x) + noise
# Plot all the data
plt.plot(x, y, '.')
plt.show()
Tensörler genellikle yığınlar halinde veya birlikte yığılmış girdi ve çıktı grupları halinde toplanır. Toplu işleme bazı eğitim faydaları sağlayabilir ve hızlandırıcılar ve vektörleştirilmiş hesaplama ile iyi çalışır. Bu veri kümesinin ne kadar küçük olduğu göz önüne alındığında, tüm veri kümesini tek bir toplu iş olarak değerlendirebilirsiniz.
Modeli tanımlayın
Bir modeldeki tüm ağırlıkları temsil etmek için tf.Variable kullanın. Bir tf.Variable bir değeri saklar ve bunu gerektiğinde tensör formunda sağlar. Daha fazla ayrıntı için değişken kılavuzuna bakın.
Değişkenleri ve hesaplamayı kapsüllemek için tf.Module kullanın. Herhangi bir Python nesnesini kullanabilirsiniz, ancak bu şekilde kolayca kaydedilebilir.
Burada hem w hem de b'yi değişken olarak tanımlarsınız.
class MyModel(tf.Module):
def __init__(self, **kwargs):
super().__init__(**kwargs)
# Initialize the weights to `5.0` and the bias to `0.0`
# In practice, these should be randomly initialized
self.w = tf.Variable(5.0)
self.b = tf.Variable(0.0)
def __call__(self, x):
return self.w * x + self.b
model = MyModel()
# List the variables tf.modules's built-in variable aggregation.
print("Variables:", model.variables)
# Verify the model works
assert model(3.0).numpy() == 15.0
Variables: (<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=0.0>, <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=5.0>) 2021-12-08 17:11:44.542944: 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.
İlk değişkenler burada sabit bir şekilde ayarlanır, ancak Keras, Keras'ın geri kalanı olsun veya olmasın, kullanabileceğiniz herhangi bir başlatıcı ile birlikte gelir.
Bir kayıp işlevi tanımlayın
Bir kayıp işlevi, belirli bir girdi için bir modelin çıktısının hedef çıktıyla ne kadar iyi eşleştiğini ölçer. Amaç eğitim sırasında bu farkı en aza indirmektir. "Ortalama kare" hatası olarak da bilinen standart L2 kaybını tanımlayın:
# This computes a single loss value for an entire batch
def loss(target_y, predicted_y):
return tf.reduce_mean(tf.square(target_y - predicted_y))
Modeli eğitmeden önce, modelin tahminlerini kırmızı ve eğitim verilerini mavi olarak çizerek kayıp değerini görselleştirebilirsiniz:
plt.plot(x, y, '.', label="Data")
plt.plot(x, f(x), label="Ground truth")
plt.plot(x, model(x), label="Predictions")
plt.legend()
plt.show()
print("Current loss: %1.6f" % loss(y, model(x)).numpy())
Current loss: 10.301712
Bir eğitim döngüsü tanımlayın
Eğitim döngüsü, sırayla üç görevi tekrar tekrar yapmaktan oluşur:
- Çıktıları oluşturmak için model aracılığıyla bir grup girdi gönderme
- Çıktıları çıktı (veya etiket) ile karşılaştırarak kaybı hesaplama
- Degradeleri bulmak için degrade bandı kullanma
- Değişkenleri bu gradyanlarla optimize etme
Bu örnek için, modeli gradyan inişini kullanarak eğitebilirsiniz.
Gradyan iniş şemasının tf.keras.optimizers içinde yakalanan birçok çeşidi vardır. Ancak, ilk ilkelerden inşa etme ruhu içinde, burada otomatik türevlendirme için tf.GradientTape ve bir değeri azaltmak için tf.assign_sub ( tf.assign ve tf.sub birleştirir) yardımıyla temel matematiği kendiniz uygulayacaksınız:
# Given a callable model, inputs, outputs, and a learning rate...
def train(model, x, y, learning_rate):
with tf.GradientTape() as t:
# Trainable variables are automatically tracked by GradientTape
current_loss = loss(y, model(x))
# Use GradientTape to calculate the gradients with respect to W and b
dw, db = t.gradient(current_loss, [model.w, model.b])
# Subtract the gradient scaled by the learning rate
model.w.assign_sub(learning_rate * dw)
model.b.assign_sub(learning_rate * db)
Eğitime bir göz atmak için, eğitim döngüsü boyunca aynı x ve y partisini gönderebilir ve W ve b nasıl geliştiğini görebilirsiniz.
model = MyModel()
# Collect the history of W-values and b-values to plot later
weights = []
biases = []
epochs = range(10)
# Define a training loop
def report(model, loss):
return f"W = {model.w.numpy():1.2f}, b = {model.b.numpy():1.2f}, loss={current_loss:2.5f}"
def training_loop(model, x, y):
for epoch in epochs:
# Update the model with the single giant batch
train(model, x, y, learning_rate=0.1)
# Track this before I update
weights.append(model.w.numpy())
biases.append(model.b.numpy())
current_loss = loss(y, model(x))
print(f"Epoch {epoch:2d}:")
print(" ", report(model, current_loss))
eğitimi yap
current_loss = loss(y, model(x))
print(f"Starting:")
print(" ", report(model, current_loss))
training_loop(model, x, y)
Starting:
W = 5.00, b = 0.00, loss=10.30171
Epoch 0:
W = 4.46, b = 0.40, loss=10.30171
Epoch 1:
W = 4.06, b = 0.72, loss=10.30171
Epoch 2:
W = 3.77, b = 0.97, loss=10.30171
Epoch 3:
W = 3.56, b = 1.18, loss=10.30171
Epoch 4:
W = 3.40, b = 1.34, loss=10.30171
Epoch 5:
W = 3.29, b = 1.47, loss=10.30171
Epoch 6:
W = 3.21, b = 1.58, loss=10.30171
Epoch 7:
W = 3.15, b = 1.66, loss=10.30171
Epoch 8:
W = 3.10, b = 1.73, loss=10.30171
Epoch 9:
W = 3.07, b = 1.78, loss=10.30171
Ağırlıkların zaman içindeki gelişimini çizin:
plt.plot(epochs, weights, label='Weights', color=colors[0])
plt.plot(epochs, [TRUE_W] * len(epochs), '--',
label = "True weight", color=colors[0])
plt.plot(epochs, biases, label='bias', color=colors[1])
plt.plot(epochs, [TRUE_B] * len(epochs), "--",
label="True bias", color=colors[1])
plt.legend()
plt.show()
Eğitilmiş modelin nasıl performans gösterdiğini görselleştirin
plt.plot(x, y, '.', label="Data")
plt.plot(x, f(x), label="Ground truth")
plt.plot(x, model(x), label="Predictions")
plt.legend()
plt.show()
print("Current loss: %1.6f" % loss(model(x), y).numpy())
Current loss: 0.897898
Aynı çözüm, ancak Keras ile
Yukarıdaki kodu Keras'taki eşdeğeriyle karşılaştırmak yararlıdır.
Modeli tanımlamak, tf.keras.Model alt sınıfını alırsanız tamamen aynı görünür. Keras modellerinin nihayetinde modülden miras aldığını unutmayın.
class MyModelKeras(tf.keras.Model):
def __init__(self, **kwargs):
super().__init__(**kwargs)
# Initialize the weights to `5.0` and the bias to `0.0`
# In practice, these should be randomly initialized
self.w = tf.Variable(5.0)
self.b = tf.Variable(0.0)
def call(self, x):
return self.w * x + self.b
keras_model = MyModelKeras()
# Reuse the training loop with a Keras model
training_loop(keras_model, x, y)
# You can also save a checkpoint using Keras's built-in support
keras_model.save_weights("my_checkpoint")
Epoch 0:
W = 4.46, b = 0.40, loss=10.30171
Epoch 1:
W = 4.06, b = 0.72, loss=10.30171
Epoch 2:
W = 3.77, b = 0.97, loss=10.30171
Epoch 3:
W = 3.56, b = 1.18, loss=10.30171
Epoch 4:
W = 3.40, b = 1.34, loss=10.30171
Epoch 5:
W = 3.29, b = 1.47, loss=10.30171
Epoch 6:
W = 3.21, b = 1.58, loss=10.30171
Epoch 7:
W = 3.15, b = 1.66, loss=10.30171
Epoch 8:
W = 3.10, b = 1.73, loss=10.30171
Epoch 9:
W = 3.07, b = 1.78, loss=10.30171
Her model oluşturduğunuzda yeni eğitim döngüleri yazmak yerine, Keras'ın yerleşik özelliklerini kısayol olarak kullanabilirsiniz. Python eğitim döngülerini yazmak veya hatalarını ayıklamak istemediğiniz zaman bu yararlı olabilir.
Bunu yaparsanız, parametreleri ayarlamak için model.fit() ve eğitmek için model.fit model.compile() ) kullanmanız gerekir. Yine kısayol olarak Keras L2 kaybı ve gradyan iniş uygulamalarını kullanmak daha az kod olabilir. Keras kayıpları ve optimize ediciler bu kolaylık fonksiyonlarının dışında da kullanılabilir ve önceki örnekte bunları kullanmış olabilir.
keras_model = MyModelKeras()
# compile sets the training parameters
keras_model.compile(
# By default, fit() uses tf.function(). You can
# turn that off for debugging, but it is on now.
run_eagerly=False,
# Using a built-in optimizer, configuring as an object
optimizer=tf.keras.optimizers.SGD(learning_rate=0.1),
# Keras comes with built-in MSE error
# However, you could use the loss function
# defined above
loss=tf.keras.losses.mean_squared_error,
)
Keras fit , toplu verileri veya eksiksiz bir veri kümesini NumPy dizisi olarak bekler. NumPy dizileri toplu işlere bölünür ve varsayılan olarak 32 toplu iş boyutuna ayarlanır.
Bu durumda, elle yazılmış döngünün davranışını eşleştirmek için x 1000 boyutunda tek bir parti olarak iletmelisiniz.
print(x.shape[0])
keras_model.fit(x, y, epochs=10, batch_size=1000)
201 Epoch 1/10 1/1 [==============================] - 0s 242ms/step - loss: 10.3017 Epoch 2/10 1/1 [==============================] - 0s 3ms/step - loss: 6.3148 Epoch 3/10 1/1 [==============================] - 0s 3ms/step - loss: 4.0341 Epoch 4/10 1/1 [==============================] - 0s 3ms/step - loss: 2.7191 Epoch 5/10 1/1 [==============================] - 0s 3ms/step - loss: 1.9548 Epoch 6/10 1/1 [==============================] - 0s 2ms/step - loss: 1.5068 Epoch 7/10 1/1 [==============================] - 0s 3ms/step - loss: 1.2422 Epoch 8/10 1/1 [==============================] - 0s 2ms/step - loss: 1.0845 Epoch 9/10 1/1 [==============================] - 0s 2ms/step - loss: 0.9899 Epoch 10/10 1/1 [==============================] - 0s 3ms/step - loss: 0.9327 <keras.callbacks.History at 0x7f02ad940050>
Keras'ın kaybı önceden değil, antrenmandan sonra yazdırdığını unutmayın, bu nedenle ilk kayıp daha düşük görünür, ancak aksi takdirde bu temelde aynı antrenman performansını gösterir.
Sonraki adımlar
Bu kılavuzda, bir model oluşturmak ve eğitmek için temel tensörler, değişkenler, modüller ve gradyan bant sınıflarının nasıl kullanılacağını ve bu fikirlerin Keras ile nasıl eşleştiğini gördünüz.
Ancak bu son derece basit bir problemdir. Daha pratik bir giriş için bkz. Özel eğitim kılavuzu .
Yerleşik Keras eğitim döngülerini kullanma hakkında daha fazla bilgi için bu kılavuza bakın. Eğitim döngüleri ve Keras hakkında daha fazla bilgi için bu kılavuza bakın. Özel dağıtılmış eğitim döngüleri yazmak için bu kılavuza bakın.