Temel eğitim döngüleri

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
tutucu7 l10n-yer
# Plot all the data
plt.plot(x, y, '.')
plt.show()

png

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
tutucu9 l10n-yer
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())

png

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)
tutucu16 l10n-yer
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()

png

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

png

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")
tutucu21 l10n-yer
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)
tutucu24 l10n-yer
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.