Yardım Kaggle üzerinde TensorFlow ile Büyük Bariyer Resifi korumak Meydan Üyelik

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ılavuzları olarak, öğrendiğiniz tensörlerle , değişkenler , gradyan bant ve modüllerin . Bu kılavuzda, modelleri eğitmek için bunların hepsini bir araya getireceksiniz.

TensorFlow da içerir tf.Keras API , klişe düşürmek için yararlı soyut sağlayan yüksek düzeyde sinir ağı API. Ancak bu kılavuzda temel sınıfları kullanacaksınız.

Kurmak

import tensorflow as tf

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
  • O kaybı için hesaplama eğim ve veri sığdırmak değişkenleri ayarlamak için bir iyimserlik kullanın.
  • Sonuçlarınızı değerlendirin.

Gösterim amacıyla, bu kılavuzda basit bir doğrusal model, geliştireceğiz \(f(x) = x * W + b\): iki değişken vardır, \(W\) (ağırlıkları) ve \(b\) (yanlılık).

Bu makine öğrenme sorunlarının en temel: Verilen \(x\) ve \(y\), eğimi bulmak ve üzerinden bir çizginin dengelemek denemek basit doğrusal regresyon .

Veri

Denetimli öğrenme kullanımları (genellikle x olarak belirtilmiştir) girişi ve çıkışı (gösterilen Y, sık olarak adlandırılan etiket). 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 = 1000

# A vector of random x values
x = tf.random.normal(shape=[NUM_EXAMPLES])

# Generate some noise
noise = tf.random.normal(shape=[NUM_EXAMPLES])

# Calculate y
y = x * TRUE_W + TRUE_B + noise
# Plot all the data
import matplotlib.pyplot as plt

plt.scatter(x, y, c="b")
plt.show()

png

Tansörler çoğunlukla gruplar halinde bir araya geldiği, ya da girişlerin ve çıkışların grupları birlikte istiflenmiş. 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

Kullanım tf.Variable bir modelde tüm ağırlıkları temsil etmek. Bir tf.Variable bir değer depolayan ve gerektiğinde tensör biçiminde bu içerir. Bkz değişken rehber fazla ayrıntı için.

Kullanım tf.Module değişkenleri ve hesaplama saklanması. Herhangi bir Python nesnesini kullanabilirsiniz, ancak bu şekilde kolayca kaydedilebilir.

Burada, ağırlık ve değişken b hem de tanımlar.

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-10-26 01:27:06.061274: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.

İlk değişkenler sabit bir şekilde burada ayarlanan ancak Keras bir takım herhangi biriyle geliyor edilmektedir initalizers sizinle veya keras geri kalanı olmadan kullanabilirsiniz.

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.scatter(x, y, c="b")
plt.scatter(x, model(x), c="r")
plt.show()

print("Current loss: %1.6f" % loss(y, model(x)).numpy())

png

Current loss: 9.008277

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, kullanmakta modeli eğitebilirsiniz gradyan arttırma .

Yakalanır degrade iniş şemasının birçok varyasyonu vardır tf.keras.optimizers . Ama ilk prensiplerden bina ruhu içinde, burada yardımıyla temel matematik kendinizi uygulayacak tf.GradientTape otomatik farklılaşma ve için tf.assign_sub (birleştiren bir değer azaltma için tf.assign ve tf.sub ):

# 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ğitim bir göz için, eğitim döngü içinde x ve y aynı toplu gönderebilir ve nasıl görebilirsiniz W ve b gelişir.

model = MyModel()

# Collect the history of W-values and b-values to plot later
Ws, bs = [], []
epochs = range(10)

# Define a training loop
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
    Ws.append(model.w.numpy())
    bs.append(model.b.numpy())
    current_loss = loss(y, model(x))

    print("Epoch %2d: W=%1.2f b=%1.2f, loss=%2.5f" %
          (epoch, Ws[-1], bs[-1], current_loss))
print("Starting: W=%1.2f b=%1.2f, loss=%2.5f" %
      (model.w, model.b, loss(y, model(x))))

# Do the training
training_loop(model, x, y)

# Plot it
plt.plot(epochs, Ws, "r",
         epochs, bs, "b")

plt.plot([TRUE_W] * len(epochs), "r--",
         [TRUE_B] * len(epochs), "b--")

plt.legend(["W", "b", "True W", "True b"])
plt.show()
Starting: W=5.00 b=0.00, loss=9.00828
Epoch  0: W=4.60 b=0.39, loss=6.16010
Epoch  1: W=4.28 b=0.71, loss=4.33501
Epoch  2: W=4.02 b=0.97, loss=3.16548
Epoch  3: W=3.82 b=1.17, loss=2.41602
Epoch  4: W=3.66 b=1.33, loss=1.93573
Epoch  5: W=3.53 b=1.46, loss=1.62793
Epoch  6: W=3.42 b=1.57, loss=1.43068
Epoch  7: W=3.34 b=1.65, loss=1.30426
Epoch  8: W=3.27 b=1.72, loss=1.22324
Epoch  9: W=3.22 b=1.78, loss=1.17131

png

# Visualize how the trained model performs
plt.scatter(x, y, c="b")
plt.scatter(x, model(x), c="r")
plt.show()

print("Current loss: %1.6f" % loss(model(x), y).numpy())

png

Current loss: 1.171306

Aynı çözüm, ancak Keras ile

Yukarıdaki kodu Keras'taki eşdeğeriyle karşılaştırmak yararlıdır.

Size alt sınıf ise tam olarak aynı modeli görünüyor tanımlanması tf.keras.Model . 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.60 b=0.39, loss=6.16010
Epoch  1: W=4.28 b=0.71, loss=4.33501
Epoch  2: W=4.02 b=0.97, loss=3.16548
Epoch  3: W=3.82 b=1.17, loss=2.41602
Epoch  4: W=3.66 b=1.33, loss=1.93573
Epoch  5: W=3.53 b=1.46, loss=1.62793
Epoch  6: W=3.42 b=1.57, loss=1.43068
Epoch  7: W=3.34 b=1.65, loss=1.30426
Epoch  8: W=3.27 b=1.72, loss=1.22324
Epoch  9: W=3.22 b=1.78, loss=1.17131

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, kullanmak gerekecektir model.compile() parametrelerini ayarlamak için, ve model.fit() yetiştirmek. 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 beklediği veri veya NumPy dizi olarak tam bir veri seti harmanlanmış. 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 halden geçmelidir maç için x büyüklüğü 1000 tek bir parti halinde de.

print(x.shape[0])
keras_model.fit(x, y, epochs=10, batch_size=1000)
1000
Epoch 1/10
1/1 [==============================] - 0s 212ms/step - loss: 9.0083
Epoch 2/10
1/1 [==============================] - 0s 2ms/step - loss: 6.1601
Epoch 3/10
1/1 [==============================] - 0s 3ms/step - loss: 4.3350
Epoch 4/10
1/1 [==============================] - 0s 2ms/step - loss: 3.1655
Epoch 5/10
1/1 [==============================] - 0s 2ms/step - loss: 2.4160
Epoch 6/10
1/1 [==============================] - 0s 2ms/step - loss: 1.9357
Epoch 7/10
1/1 [==============================] - 0s 2ms/step - loss: 1.6279
Epoch 8/10
1/1 [==============================] - 0s 2ms/step - loss: 1.4307
Epoch 9/10
1/1 [==============================] - 0s 2ms/step - loss: 1.3043
Epoch 10/10
1/1 [==============================] - 0s 2ms/step - loss: 1.2232
<keras.callbacks.History at 0x7f6c1bf96bd0>

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 gidiş yolu .

Yerleşik keras eğitim döngüler kullanma konusunda daha fazla bilgi için bkz bu kılavuzu . Daha fazla eğitim döngüler ve keras üzerinde için bkz bu kılavuzu . Özel dağıtılan eğitim döngüler yazma için bkz bu kılavuzu .