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

TensorFlow temelleri

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)
tutucu1 l10n-yer
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")
tutucu15 l10n-yer
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)
-yer tutucu23 l10n-yer
<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
tutucu25 l10n-yer
<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)
tutucu28 l10n-yer
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)
tutucu30 l10n-yer
<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)
tutucu32 l10n-yer
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_model kullanarak 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:

  1. tf.train.Checkpoint kullanarak 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.
  2. tf.saved_model kullanarak tf.Variable değerlerini ve tf.function grafiklerini içe ve dışa tf.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]))
-yer tutucu35 l10n-yer
<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)
tutucu37 l10n-yer
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]))
tutucu39 l10n-yer
<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]
tutucu41 l10n-yer
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();

png

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

png

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

png

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')
yer tutucu50 l10n-yer
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');

png

Daha fazla ayrıntı için Temel eğitim döngülerine ve Keras kılavuzuna bakın.