Veri Bilimcisi

Makine Öğrenmesi, Derin Öğrenme, Veri Madenciliği, Veri Analizi

TensorFlow 101

TensorFlow™, veri akış çizgeleri kullanarak sayısal hesaplama için kullanılan açık kaynaklı bir yazılım kütüphanesidir. Çizgedeki düğümler, matematiksel işlemleri temsil ederken, çizgenin kenarları arasında iletilen çok boyutlu veri dizilerini (tensörler) temsil eder. Esnek mimarisi ile, hesaplamayı tek bir API ile bir masaüstü, sunucu veya mobil cihazdaki bir veya daha fazla CPU’ya veya GPU’ya dağıtmanıza olanak tanır. TensorFlow başlangıçta, makine öğrenmesi ve derin sinir ağları araştırmalarını yürütmek amacıyla Google’ın Machine Intelligence research organizasyonu içindeki Google Beyin Ekibi üzerinde çalışan araştırmacılar ve mühendisler tarafından geliştirildi, ancak sistem, diğer alanlarda da geniş bir yelpazede oldukça iyidir. Kaynak

  1. TensorFlow’a Kolay Bir Başlangıç
  2. TensorFlow: Algılayıcı
  3. TensorFlow’a Başlarken
  4. TensorFlow: Makine Öğrenmesine Yeni Başlayanlar için MNIST
  5. TensorFlow: Lineer Regresyon
  6. Programcı Kılavuzu

TensorFlow’a Başlarken

Bu öğretici TensorFlow’da programlamaya başlamanızı sağlar. Başlamadan önce TensorFlow’u yükleyin.  Burada nasıl yükleneceği Installing TensorFlow anlatılmıştır. TensorFlow’u öğrenmeye başlamadan önce eksiklerinizi tamamlamalısınız.

TensorFlow, çoklu API’ler sağlar. En düşük düzey API – TensorFlow Core – size komple programlama kontrolü sağlar. Makine öğrenmesi üzerine çalışan araştırmacılar ve modelleri üzerinde ince kontrol seviyeleri isteyen diğer kullanıcılar için TensorFlow Çekirdeği önerilir. Üst düzey API’ler TensorFlow Çekirdeği üzerine inşa edilmiştir. Bu üst düzey API’ler, TensorFlow Çekirdekten daha kolay öğrenilir ve kullanılırlar. Buna ek olarak, üst düzey API’ler, tekrar eden görevleri farklı kullanıcılar arasında daha kolay ve daha tutarlı hale getirir. Tf.contrib.learn gibi üst düzey bir API, veri kümelerini, tahmincileri, eğitim ve çıkarımı yönetmenize yardımcı olur. Üst düzey TensorFlow API’lerinden bazıları hala geliştirme aşamasındadır.

Bu öğretici, TensorFlow Çekirdeği ile başlar.

Tensörler

TensorFlow’daki verilerin merkezi birimi tensördür. Bir tensör, herhangi bir sayıda boyuta sahip bir dizi şeklinde şekillendirilmiş bir dizi primitive değerden oluşur. Bir tensörün derecesi, boyutların sayısıdır. Tensörlere bazı örnekler:

3 # a rank 0 tensor; this is a scalar with shape []
[1. ,2., 3.] # a rank 1 tensor; this is a vector with shape [3]
[[1., 2., 3.], [4., 5., 6.]] # a rank 2 tensor; a matrix with shape [2, 3]
[[[1., 2., 3.]], [[7., 8., 9.]]] # a rank 3 tensor with shape [2, 1, 3]

TensorFlow Çekirdek (Core)

TensorFlow’u İçe Aktarma (import etme)

TensorFlow programlarının standart import açıklaması şöyledir:

import tensorflow as tf

Bu, Python’un TensorFlow’un tüm sınıflarına, yöntemlerine ve simgelerine erişmeyi sağlar. Bundan sonra bu satırı tekrar tekrar yazmayacağız, sizin zaten tensorflow’u import ettiğiniz varsayılacaktır.

Hesaplamalı Çizge (The Computational Graph)

Hesaplamalı Çizge Hakkında Daha Fazla Bilgi İçin.

TensorFlow Çekirdeği programlarını iki ayrı bölümden oluşan olarak düşünebilirsiniz:

  • Hesaplamalı Çizgeyi oluşturmak
  • Hesaplamalı Çizgeyi çalıştırmak

Hesaplamalı bir çizge, düğümlerin(node) çizgede düzenlenmiş bir dizi TensorFlow işlemidir. Basit bir hesaplamalı çizge oluşturalım. Her bir düğüm, sıfır veya daha fazla tensörü girdi olarak alır ve çıktı olarak bir tensör üretir. Bir düğüm türü constant’dır. Tüm TensorFlow sabitleri gibi, hiçbir giriş gerektirmez ve dahili olarak depoladığı bir değeri çıkarır. İki kayan nokta(float) Tensörü node1 ve node2’yi aşağıdaki gibi oluşturabiliriz:


node1 = tf.constant(3.0, dtype=tf.float32)
node2 = tf.constant(4.0) # also tf.float32 implicitly
print(node1, node2)

Çıktısı:


Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)

Düğümlerin yazdırılmasının beklediğiniz gibi 3.0 ve 4.0 değerlerini vermediğine dikkat edin. Bunun yerine, bunlar değerlendirildiğinde sırasıyla 3.0 ve 4.0 üretecek düğümlerdir. Gerçekten de düğümleri değerlendirmek için bir session hesaplama çizgesini çalıştırmamız gerekir. Bir session, TensorFlow çalışma zamanının denetimini ve durumunu kapsar.

Aşağıdaki kod bir Session nesnesi oluşturur ve ardından node1 ve node2 değerlerini hesaplamak için yeterli hesaplama çizgesini çalıştırmak için run metodunu çağırır. Hesaplamalı Çizgeyi bir session’da aşağıdaki gibi çalıştırarak:

 

sess = tf.Session()
print(sess.run([node1, node2]))

Beklenen 3.0 ve 4.0 değerlerini görüyoruz:

[3.0, 4.0]

Tensor düğümlerini operasyonlarla birleştirerek daha karmaşık hesaplamalar yapabiliriz (operasyonlar da düğümlerdir). Örneğin, iki sabit düğümümüzü birbirine ekleyebiliriz ve aşağıdaki gibi yeni bir çizge oluşturabiliriz:

 

node3 = tf.add(node1, node2)
print("node3: ", node3)
print("sess.run(node3): ",sess.run(node3))

Çıktısı:

 

node3: Tensor("Add:0", shape=(), dtype=float32)
sess.run(node3): 7.0

TensorFlow, hesaplama çizgesinin resmini görüntüleyebilen TensorBoard adlı bir yardımcı programı sağlar. TensorBoard’ın çizgeyi nasıl görselleştirdiğini gösteren bir ekran görüntüsü:
TensorBoard screenshot
Bu çizge, aslında ilginç değildir çünkü her zaman sabit bir sonuç üretir. Bir çizge, placeholders olarak bilinen harici girdileri kabul etmek için parametrelendirilebilir. Placeholder, daha sonra bir değer sağlamak için bir söz gibidir.

 

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b # + provides a shortcut for tf.add(a, b)

Önceki üç satır, biraz iki fonksyion parametresine ya da iki girdi parametresini (a ve b) tanımlayan bir lambda’ya benzemektedir ve bunlarla ilgili bir işlemdir. Bu placeholder’lara somut değerler sağlayan Tensörleri belirtmek için feed_dict parametresini kullanarak birden fazla girdi içeren bu çizgeyi değerlendirebiliriz:

 

print(sess.run(adder_node, {a: 3, b:4.5}))
print(sess.run(adder_node, {a: [1,3], b: [2, 4]}))

Sonuçta çıktı:

 

7.5
[ 3. 7.]

TensorBoard’da çizge şöyledir:

TensorBoard screenshot

Başka bir işlem ekleyerek hesaplama çizgesini daha karmaşık hale getirebiliriz. Örneğin,


add_and_triple = adder_node * 3.

print(sess.run(add_and_triple, {a: 3, b:4.5}))

Çıktıyı üretir

 

22.5

Önceki hesaplama çizgesi TensorBoard’da şu şekilde görünecektir:

TensorBoard screenshot

Makine öğrenmesinde tipik olarak, yukarıdaki gibi keyfi girdileri alabilen bir model isteyeceğiz. Modeli eğitilebilir yapmak için, aynı girdiyle yeni çıktılar elde etmek için çizgeyi değiştirebilmeliyiz. Variables, bir çizgede eğitilebilir parametreleri eklememizi sağlar. Bir tür ve başlangıç ​​değeri ile oluşturulmuştur:


W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b

tf.constant‘ı çağırdığınızda sabitler başlatılır ve değerleri asla değiştirilemez. Tf.Variable çağrıldığında aksine, değişkenler başlatılamaz. Bir TensorFlow programındaki tüm değişkenleri başlatmak için, aşağıdaki gibi özel bir operasyonu  çağırmalısınız:


init = tf.global_variables_initializer()
sess.run(init)

init tüm genel değişkenleri başlatan TensorFlow alt çizgesinin bir tanıtıcısı(initializer) olduğunu fark ediniz. sess.run‘ı çağırana kadar değişkenler başlatılmamıştır.

X bir yer tutucu olduğundan, lineer_model‘i x’in çeşitli değerleri için eşzamanlı olarak aşağıdaki gibi değerlendirebiliriz:

 print(sess.run(linear_model, {x:[1,2,3,4]}))

Çıktısı:

 

[ 0. 0.30000001 0.60000002 0.90000004]

Bir model yarattık, ancak bunun ne kadar iyi olduğunu bilmiyoruz. Eğitim verilerindeki modeli değerlendirmek için, istenen değerleri sağlamak için bir placeholder’a ihtiyacımız vardır ve bir loss(kayıp) fonksiyonu yazmamız gerekir.

Bir kayıp fonksiyonu, mevcut modelin verilen veriden ne kadar uzakta olduğunu ölçer. Mevcut model ile sağlanan veriler arasındaki deltaların karelerini toplayan lineer regresyon için standart bir kayıp modeli kullanacağız. Linear_model – y, her bir öğenin ilgili örnekte hata deltası olan bir vektör oluşturur. Bu hatayı kareler için tf.square olarak adlandırırız. Ardından, karelenmiş tüm hataları, tüm örneklerin hatalarını tf.reduce_sum kullanarak özetleyen tek bir skalayı oluşturmak için toplarız:


y = tf.placeholder(tf.float32)
squared_deltas = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

Kayıp değerinin üretilmesi:


23.66

W ve b değerlerini -1 ve 1’e yani mükemmel değerlerine yeniden atayarak bunu manuel olarak geliştirebiliriz. Bir değişken, tf.Variable ile başlatılır. Değişken, tf.assign gibi işlemler kullanılarak değiştirilebilir. Örneğin, W = -1 ve b = 1 modelimiz için en uygun parametrelerdir. Buna göre W ve b’yi değiştirebiliriz:


fixW = tf.assign(W, [-1.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

Sonuç, kaybın şimdi sıfır olduğunu gösterir.


0.0

W ve b’nin “mükemmel” değerlerini tahmin ettik, ancak makine öğrenmesinin tüm amacı doğru model parametrelerini otomatik olarak bulmaktır. Bunu bir sonraki bölümde nasıl gerçekleştireceğimizi göstereceğiz.

tf.train API

Makine öğrenmesi ile ilgili herhangi bir tartışma bu dersin kapsamı dışındadır. Bununla birlikte, TensorFlow, kayıp fonksiyonunu en aza indirgemek için her değişkeni yavaşça değiştiren optimizers sağlar. En basit optimizer gradient descent’dir. Her değişkeni, o değişkene göre kayıp türevinin büyüklüğüne göre değiştirir. Genel olarak, sembolik türevleri manuel olarak hesaplamak sıkıcı ve hataya sebebiyet verebilir. Sonuç olarak, TensorFlow tf.gradients fonksiyonunu kullanarak modelin sadece bir açıklaması verildiğinde türevleri otomatik olarak üretebilir. Basitleştirmek için, optimizatörler genellikle sizin için bunu yapar. Örneğin,


optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

sess.run(init) # reset values to incorrect defaults.
for i in range(1000):
sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})

print(sess.run([W, b]))

Çıktı model parametreleriyle sonuçlanır:


[array([-0.9999969], dtype=float32), array([ 0.99999082],
dtype=float32)]

Şimdi gerçek makine öğrenimi yaptık. Bu basit doğrusal regresyonda çok fazla TensorFlow Core kodu gerekmiyor olsa da, modelinize veri beslemek için daha karmaşık modeller ve yöntemler daha fazla kod gerektirir. Böylece, TensorFlow, ortak kalıplar, yapılar ve işlevsellik için daha üst düzey soyutlamalar sağlar. Bir sonraki bölümde bu soyutlamaların bazılarını nasıl kullanacağımızı öğreneceğiz.

Örnek Programın Tamamı

Eğitilebilir doğrusal regresyon modeli burada gösterilmiştir:


import numpy as np
import tensorflow as tf

# Model parameters
W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)
# Model input and output
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)
# loss
loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares
# optimizer
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# training data
x_train = [1,2,3,4]
y_train = [0,-1,-2,-3]
# training loop
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
sess.run(train, {x:x_train, y:y_train})

# evaluate training accuracy
curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x:x_train, y:y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))

Programı çalıştırdığımızda çıktısı:


W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11

Kaybın çok küçük bir sayı olduğuna dikkat edin (sıfıra yakın). Bu programı çalıştırırsanız kaybınız tamamen aynı olmayacaktır, çünkü model rasgele değerlerle başlatılmıştır.

Bu karmaşık program hala TensorBoard’da görselleştirilebilir

TensorBoard final model visualization

tf.contrib.learn

tf.contrib.learn, makine öğrenmesi mekanizmasını basitleştiren aşağıdakiler dahil olmak üzere üst düzey bir TensorFlow kütüphanesidır:

  • Eğitim Döngülerini Çalıştırabilir
  • Değerlendirme Döngülerini Çalıştırabilir
  • Veri Setlerini Yönetebilir
  • Beslemeleri Yönetebilir

tf.contrib.learn birçok yaygın model tanımlar.

Temel Kullanımı

Doğrusal regresyon programının tf.contrib.learn ile ne kadar basitleştiğine dikkat edin:

import tensorflow as tf
# NumPy is often used to load, manipulate and preprocess data.
import numpy as np

# Declare list of features. We only have one real-valued feature. There are many
# other types of columns that are more complicated and useful.
features = [tf.contrib.layers.real_valued_column("x", dimension=1)]

# An estimator is the front end to invoke training (fitting) and evaluation
# (inference). There are many predefined types like linear regression,
# logistic regression, linear classification, logistic classification, and
# many neural network classifiers and regressors. The following code
# provides an estimator that does linear regression.
estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)

# TensorFlow provides many helper methods to read and set up data sets.
# Here we use two data sets: one for training and one for evaluation
# We have to tell the function how many batches
# of data (num_epochs) we want and how big each batch should be.
x_train = np.array([1., 2., 3., 4.])
y_train = np.array([0., -1., -2., -3.])
x_eval = np.array([2., 5., 8., 1.])
y_eval = np.array([-1.01, -4.1, -7, 0.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x":x_train}, y_train,
 batch_size=4,
 num_epochs=1000)
eval_input_fn = tf.contrib.learn.io.numpy_input_fn(
 {"x":x_eval}, y_eval, batch_size=4, num_epochs=1000)

# We can invoke 1000 training steps by invoking the method and passing the
# training data set.
estimator.fit(input_fn=input_fn, steps=1000)

# Here we evaluate how well our model did.
train_loss = estimator.evaluate(input_fn=input_fn)
eval_loss = estimator.evaluate(input_fn=eval_input_fn)
print("train loss: %r"% train_loss)
print("eval loss: %r"% eval_loss)

Çalıştırıldığında çıktısı:


train loss: {'global_step': 1000, 'loss': 4.3049088e-08}
 eval loss: {'global_step': 1000, 'loss': 0.0025487561}

Eval kaybı yüksek bir değer ama hala sıfıra yakın. Yani düzgün öğreniyoruz demektir.

Özel Bir Model

tf.contrib.learn sizi önceden tanımlanmış modellere kilitlemez. TensorFlow’a yerleşik olmayan özel bir model oluşturmak istediğimizi varsayalım. tf.contrib.learn’in veri setinin, beslemenin, eğitimin vb. Üst düzeyde soyutlamasını hala elimizde tutuyoruz. Örnekleme için, daha düşük seviyeli TensorFlow API’sı hakkındaki bilgilerimizi kullanarak LinearRegressor’a kendi eşdeğer modelimizi nasıl uygulayacağımızı göstereceğiz.

tf.contrib.learn ile çalışan özel bir model tanımlamak için tf.contrib.learn.Estimator kullanmamız gerekir. tf.contrib.learn.LinearRegressor aslında tf.contrib.learn.Estimator‘ın alt sınıfıdır. Alt sınıflandırma Estimator yerine, yalnızca
Tahminci, tahminler, eğitim adımları ve kayıpları nasıl değerlendirebildiğini tf.contrib.learn‘a bildiren bir model_fn fonksiyonudur. Kod şu şekildedir:


import numpy as np
import tensorflow as tf
# Declare list of features, we only have one real-valued feature
def model(features, labels, mode):
 # Build a linear model and predict values
 W = tf.get_variable("W", [1], dtype=tf.float64)
 b = tf.get_variable("b", [1], dtype=tf.float64)
 y = W*features['x'] + b
 # Loss sub-graph
 loss = tf.reduce_sum(tf.square(y - labels))
 # Training sub-graph
 global_step = tf.train.get_global_step()
 optimizer = tf.train.GradientDescentOptimizer(0.01)
 train = tf.group(optimizer.minimize(loss),
 tf.assign_add(global_step, 1))
 # ModelFnOps connects subgraphs we built to the
 # appropriate functionality.
 return tf.contrib.learn.ModelFnOps(
 mode=mode, predictions=y,
 loss=loss,
 train_op=train)

estimator = tf.contrib.learn.Estimator(model_fn=model)
# define our data sets
x_train = np.array([1., 2., 3., 4.])
y_train = np.array([0., -1., -2., -3.])
x_eval = np.array([2., 5., 8., 1.])
y_eval = np.array([-1.01, -4.1, -7, 0.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x": x_train}, y_train, 4, num_epochs=1000)

# train
estimator.fit(input_fn=input_fn, steps=1000)
# Here we evaluate how well our model did.
train_loss = estimator.evaluate(input_fn=input_fn)
eval_loss = estimator.evaluate(input_fn=eval_input_fn)
print("train loss: %r"% train_loss)
print("eval loss: %r"% eval_loss)

Çıktısı:

 

train loss: {'global_step': 1000, 'loss': 4.9380226e-11}
eval loss: {'global_step': 1000, 'loss': 0.01010081}

Özel model() fonksiyonunun içeriğinin alt düzey API’tan manuel model eğitim döngüsüne nasıl çok benzer olduğunu fark edin.

Programcı Kılavuzu

Değişkenler: Oluşturma, Başlatma, Kaydetme ve Yükleme

Bir modeli eğittiğinizde, parametreleri tutmak ve güncellemek için değişkenleri kullanırsınız. Değişkenler tensör içeren bellek içi tamponlardır. Açıkça başlatılmaları (initialize edilmeleri) gerekir ve eğitim sırasında ve sonrasında diske kaydedilebilirler. Modelle egzersiz yapmak veya modeli analiz etmek için daha sonra kaydedilmiş değerleri geri yükleyebilirsiniz.

Bu belge aşağıdaki TensorFlow sınıflarını referans alır. API’lerinin tam bir açıklaması için referans kılavuzunun bağlantılarını izleyin:

Oluşturma

Bir Değişken oluşturduğunuzda, Tensor’u başlangıç değeri olarak Variable() constructor’ına iletirsiniz. TensorFlow, sabitler veya rastgele değerlerden başlatma için sıklıkla kullanılan tensörler üreten bir ops koleksiyonu sağlar.

Tüm bu işlemlerin tensörlerin şeklini belirlemenizi gerektirdiğini unutmayın. Bu şekil otomatik olarak değişkeninizin şekli haline gelir. Değişkenler genellikle sabit bir şekle sahiptir, ancak TensorFlow değişkenleri yeniden biçimlendirmek için gelişmiş mekanizmalar sağlar.


# Create two variables.
weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),
name="weights")
biases = tf.Variable(tf.zeros([200]), name="biases")

tf.Variable() öğesinin çağrılması, çizgeye çeşitli ops’ler ekler:

  • Değişken değeri tutan variable op
  • Değişkeni başlangıç değerine ayarlayan bir başlatıcı fonksiyonu, tf.assign op
  • Örnekteki zeros op gibi biases değişkeni için başlangıç değerinin op’leri de çizgeye eklenir

tf.Variable() değeri tarafından döndürülen değer, tf.Variable Python sınıfının bir instance’dır(örneğidir).

Cihaz Yerleşimi

Bir değişken, bir tf.device(…): bloğu kullanılarak bir aygıt oluşturulduğunda sabitlenebilir:


# Pin a variable to CPU.
with tf.device("/cpu:0"):
v = tf.Variable(...)

# Pin a variable to GPU.
with tf.device("/gpu:0"):
v = tf.Variable(...)

# Pin a variable to a particular parameter server task.
with tf.device("/job:ps/task:7"):
v = tf.Variable(...)

Not tf.Variable.assign, bir tf.train.Optimizer‘deki parametre güncelleme işlemleri gibi bir değişkene mutasyon yapan işlemler, değişkenle aynı aygıta uygulanmalıdır. Uyuşmayan cihaz yerleşimi yönergeleri bu işlemleri oluştururken göz ardı edilir.

Cihaz yerleşimi, çoğaltılmış bir ayarda çalışırken özellikle önemlidir. Çoğaltılmış bir model için aygıtların yapılandırmasını basitleştirebilecek bir aygıt işlevinin ayrıntıları için tf.train.replica_device_setter‘e bakın.

Başlatma

Modelinizdeki diğer opların çalıştırılabilmesi için değişken başlatıcıların açıkça çalıştırılması gerekir. Bunu yapmanın en kolay yolu, tüm değişken başlatıcıları çalıştıran bir op eklemek ve bu op’yı modeli kullanmadan önce çalıştırmaktır.

Alternatif olarak, bir denetim noktası dosyasındaki değişken değerleri geri yükleyebilirsiniz, aşağıya bakın.

Değişken başlatıcıları çalıştırmak için bir op eklemek için tf.global_variables_initializer() kullanın. Modelinizi tamamen oluşturduktan ve bir oturumda(session’da) başlattıktan sonra o op’u çalıştırın.


# Create two variables.
weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),
name="weights")
biases = tf.Variable(tf.zeros([200]), name="biases")
...
# Add an op to initialize the variables.
init_op = tf.global_variables_initializer()

# Later, when launching the model
with tf.Session() as sess:
# Run the init operation.
sess.run(init_op)
...
# Use the model
...

Başka bir Değişkenden Başlatma

Bazen bir değişkeni başka bir değişkenin başlangıç değerinden başlatmanız gerekebilir. tf.global_variables_initializer() tarafından eklenen op tüm değişkenleri paralel olarak başlatırken, bunu yaparken dikkatli olmalısınız.

Yeni bir değişkenin değerini başka bir değişkenin değerinden başlatmak için diğer değişkenin initialized_value() özelliğini kullanın. Initialize edilen değeri doğrudan yeni değişkenin başlangıç değeri olarak kullanabilirsiniz veya yeni değişkenin değerini hesaplamak için bunu herhangi bir tensör olarak kullanabilirsiniz.


# Create a variable with a random value.
weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),
name="weights")
# Create another variable with the same value as 'weights'.
w2 = tf.Variable(weights.initialized_value(), name="w2")
# Create another variable with twice the value of 'weights'
w_twice = tf.Variable(weights.initialized_value() * 2.0, name="w_twice")

Özel Başlatma

tf.global_variables_initializer() kolaylık sağlayan bu fonksiyon modeldeki tüm değişkenleri başlatmak için bir op ekler. tf.variables_initializer fonksiyonunu başlatmak için değişkenlerin açık bir listesini de iletebilirsiniz.

Kaydetme ve Geri Yükleme

Bir modeli kaydetmek ve geri yüklemek için en kolay yol, bir tf.train.Saver nesnesi kullanmaktır. Constructor, çizgeye değişkenlerin tümünü veya belirtilen bir listesini çizgeye save ve restore ops’si ekler. Saver nesnesi, kontrol noktalarının yazılması veya okunması için yollar belirterek bu op’ları çalıştırmak için yöntemler sağlar.

Bir model kontrol noktasını grafiksiz olarak geri yüklemek için önce meta çizge dosyasından (normal uzantı .meta) çizgeyi almalısınız. Bu  tf.train.import_meta_graph ile yapılır ve restore’u gerçekleştirebileceğiniz bir Saver döndürür.

Kontrol Noktası Dosyaları

Değişkenler kabaca değişken adlardan tensor değerlerine bir eşleme içeren(map) ikili dosyalar olarak kaydedilir.

Bir Saver nesnesi oluştururken, isteğe bağlı olarak denetim noktası dosyalarındaki değişkenler için adlar seçebilirsiniz. Varsayılan olarak, her değişken için tf.Variable.name özelliğinin değerini kullanır.

Değişkenleri Kaydetme

Modeldeki tüm değişkenleri yönetmek için tf.train.Saver() ile bir Saver oluşturun.

Bir denetim noktasında hangi değişkenlerin olduğunu anlamak için, inspect_checkpoint kitaplığını ve özellikle de print_tensors_in_checkpoint_file fonksiyonunu kullanabilirsiniz.


# Create some variables.
v1 = tf.Variable(..., name="v1")
v2 = tf.Variable(..., name="v2")
...
# Add an op to initialize the variables.
init_op = tf.global_variables_initializer()

# Add ops to save and restore all the variables.
saver = tf.train.Saver()

# Later, launch the model, initialize the variables, do some work, save the
# variables to disk.
with tf.Session() as sess:
sess.run(init_op)
# Do some work with the model.
..
# Save the variables to disk.
save_path = saver.save(sess, "/tmp/model.ckpt")
print("Model saved in file: %s" % save_path)

Değişkenleri Geri Yükleme

Değişkenleri geri yüklemek için aynı Saver nesnesi kullanılır. Değişkenlerden bir dosyadan geri yüklediğinizde bunları önceden başlatmanız gerekmez.


# Create some variables.
v1 = tf.Variable(..., name="v1")
v2 = tf.Variable(..., name="v2")
...
# Add ops to save and restore all the variables.
saver = tf.train.Saver()

# Later, launch the model, use the saver to restore variables from disk, and
# do some work with the model.
with tf.Session() as sess:
# Restore variables from disk.
saver.restore(sess, "/tmp/model.ckpt")
print("Model restored.")
# Do some work with the model

...

Hangi Değişkenlerin Kaydedileceğini ve Geri Yükleneceğini Seçme

tf.train.Saver() fonksiyonuna herhangi bir argüman vermezseniz, çizgedeki tüm değişkenleri işler. Her biri, değişken oluşturulduğunda kabul edilen adın altında kaydedilir.

Kontrol noktası dosyalarındaki değişkenler için adları açıkça belirtmek bazen yararlıdır. Örneğin, “params” adında yeni bir değişkende değerini geri yüklemek istediğiniz “weights” adlı bir değişkene sahip bir modeli eğitmiş olabilirsiniz.

Bazen sadece bir model tarafından kullanılan değişkenlerin bir alt kümesini kaydetmek veya geri yüklemek de yararlıdır. Örneğin, 5 katmanlı bir sinir ağı eğitmiş olabilirsiniz ve artık önceden eğitilmiş modelin 5 katmanından yeni modelin ilk 5 katına parametreleri geri yükleyerek 6 katmanlı yeni bir model üretmek istiyorsunuz.

# Create some variables.
v1 = tf.Variable(..., name="v1")
v2 = tf.Variable(..., name="v2")
...
# Add ops to save and restore only 'v2' using the name "my_v2"
saver = tf.train.Saver({"my_v2": v2})
# Use the saver object normally after that.
...

 

 

 

Portions of this page are modifications based on work created and shared by Google and used according to terms described in the Creative Commons 3.0 Attribution License.

https://www.tensorflow.org

%d blogcu bunu beğendi: