Örnekle TensorFlow'da Otomatik Kodlayıcı

Derin Öğrenmede Otomatik Kodlayıcı Nedir?

An Otomatik kodlayıcı veri kodlamayı denetimsiz bir şekilde verimli bir şekilde öğrenmek için bir araçtır. Sinir ağını sinyal gürültüsünü göz ardı edecek şekilde eğiterek, boyut azaltımı için veri setlerinin temsilini öğrenmenize yardımcı olan bir tür yapay sinir ağıdır. Bir girişi yeniden oluşturmak için harika bir araçtır.

Basit bir ifadeyle, makine diyelim ki bir görüntü alır ve onunla yakından ilişkili bir resim üretebilir. Bu tür sinir ağlarındaki girdiler etiketlenmemiştir; bu da ağın denetim olmadan öğrenme yeteneğine sahip olduğu anlamına gelir. Daha doğrusu, girdi ağ tarafından yalnızca en kritik özelliğe odaklanacak şekilde kodlanır. Otomatik kodlayıcının boyut azaltma konusunda popüler olmasının nedenlerinden biri de budur. Ayrıca, otomatik kodlayıcılar üretmek için kullanılabilir. üretken öğrenme modelleri. Örneğin sinir ağı bir dizi yüzle eğitilip daha sonra yeni yüzler üretilebilir.

TensorFlow Otomatik Kodlayıcı nasıl çalışır?

Otomatik kodlayıcının amacı, yalnızca temel özelliklere odaklanarak girişin yaklaşık bir tahminini üretmektir. Çıktıyı üretmek için neden yalnızca girdiyi kopyalayıp yapıştırmayı öğrenmediğinizi düşünebilirsiniz. Aslında bir otomatik kodlayıcı, yalnızca çıktıyı kopyalamaktan farklı olarak ağı verileri temsil etmenin yeni yollarını öğrenmeye zorlayan bir dizi kısıtlamadır.

Tipik bir otomatik kodlayıcı bir giriş, bir dahili gösterim ve bir çıkış (girişin yaklaşık değeri) ile tanımlanır. Öğrenme, iç temsile eklenen katmanlarda gerçekleşir. Aslında geleneksel bir sinir ağına benzeyen iki ana katman bloğu vardır. Küçük fark, çıktıyı içeren katmanın girdiye eşit olması gerektiğidir. Aşağıdaki resimde orijinal giriş, adı verilen ilk bloğa gidiyor. kodlayıcı. Bu dahili gösterim, girişin boyutunu sıkıştırır (küçütür). İkinci blokta girişin yeniden yapılandırılması gerçekleşir. Bu kod çözme aşamasıdır.

Model, kayıp fonksiyonunu en aza indirerek ağırlıkları güncelleyecektir. Yeniden yapılandırma çıktısı girdiden farklıysa model cezalandırılır.

Somut olarak, 50×50 (yani 250 piksel) boyutunda bir resim ve yüz nörondan oluşan tek bir gizli katmanı olan bir sinir ağı hayal edin. Öğrenme, girişten iki kat daha küçük bir özellik haritası üzerinde yapılır. Bu, ağın yalnızca 250'e eşit nöronlardan oluşan bir vektörle 100 pikseli yeniden yapılandırmanın bir yolunu bulması gerektiği anlamına geliyor.

Yığılmış Otomatik Kodlayıcı Örneği

Bu Autoencoder eğitiminde, yığılmış bir autoencoder'ı nasıl kullanacağınızı öğreneceksiniz. Mimarisi geleneksel bir sinir ağına benzer. Giriş, sıkıştırılmak veya boyutunu küçültmek için gizli bir katmana gider ve ardından yeniden yapılandırma katmanlarına ulaşır. Amaç, orijinaline olabildiğince yakın bir çıktı görüntüsü üretmektir. Model, bir dizi kısıtlama altında, yani daha düşük bir boyutla görevini başarmanın bir yolunu öğrenmelidir.

Günümüzde Otomatik Kodlayıcılar Derin Öğrenme esas olarak bir görüntünün gürültüsünü gidermek için kullanılır. Çiziklerin olduğu bir görüntü hayal edin; bir insan hâlâ içeriği tanıyabilmektedir. Otomatik kodlayıcının gürültüsünü gidermenin amacı, ağı verinin arkasındaki modeli öğrenmeye zorlamak için resme gürültü eklemektir.

Otomatik Kodlayıcı Derin Öğrenmenin diğer kullanışlı ailesi değişken otomatik kodlayıcıdır. Bu tür ağlar yeni görüntüler oluşturabilir. Bir ağı bir erkek imajıyla eğittiğinizi hayal edin; böyle bir ağ yeni yüzler üretebilir.

TensorFlow ile Otomatik Kodlayıcı Nasıl Oluşturulur

Bu eğitimde, bir görüntüyü yeniden oluşturmak için yığılmış bir otomatik kodlayıcının nasıl oluşturulacağını öğreneceksiniz.

kullanacaksın CIFAR-10 veri kümesi 60000 adet 32×32 renkli görsel içeren. Autoencoder veri kümesi halihazırda eğitim için 50000 görüntü ve test için 10000 görüntü arasında bölünmüştür. En fazla on sınıf vardır:

• Uçak
• Otomobil
• Kuş
• Kedi
• Geyik
• Köpek
• Kurbağa
• at
• Gemi
• kamyon

https://www.cs.toronto.edu/~kriz/cifar.html URL'sindeki görselleri indirmeniz ve sıkıştırmasını açmanız gerekir. -10-batch-py klasörü, her biri rastgele sırada 10000 görüntü içeren beş veri kümesi içerir.

Modelinizi oluşturup eğitmeden önce bazı veri işlemlerini uygulamanız gerekir. Aşağıdaki gibi ilerleyeceksin:

1. Verileri içeri aktarın
2. Verileri siyah beyaz formata dönüştürün
3. Tüm grupları ekle
4. Eğitim veri kümesini oluşturma
5. Bir görüntü görselleştirici oluşturun

Görüntü ön işleme

Adım 1) Verileri içe aktarın

Resmi web sitesine göre, verileri aşağıdaki kodla yükleyebilirsiniz. Autoencoder kodu, verileri bir sözlüğe yükleyecektir. veri ve etiket. Kodun bir fonksiyon olduğunu unutmayın.

import numpy as np
import tensorflow as tf
import pickle
def unpickle(file):
    import pickle
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='latin1')
    return dict

Adım 2) Verileri siyah beyaz formata dönüştürün

Basit olması açısından verileri gri tonlamaya dönüştüreceksiniz. Yani, renkli görüntü için üç boyuta karşı yalnızca bir boyut vardır. Sinir ağlarının çoğu yalnızca tek boyutlu girişle çalışır.

def grayscale(im):
    return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

Adım 3) Tüm partileri ekleyin

Artık her iki işlev de oluşturulduğuna ve veri kümesi yüklendiğine göre, verileri belleğe eklemek için bir döngü yazabilirsiniz. Dikkatli bir şekilde kontrol ederseniz, verileri içeren sıkıştırılmış dosyanın adı data_batch_ olarak adlandırılır ve 1'den 5'e kadar bir sayıdır. Dosyalar üzerinde döngü yapabilir ve bunu verilere ekleyebilirsiniz.

Bu adım tamamlandığında renk verilerini gri tonlamalı formata dönüştürürsünüz. Gördüğünüz gibi verinin şekli 50000 ve 1024'tür. 32*32 piksel artık 2014'e düzleştirilmiştir.

# Load the data into memory
data, labels = [], []
## Loop over the b
for i in range(1, 6):
    filename = './cifar-10-batches-py/data_batch_' + str(i)
    open_data = unpickle(filename)
    if len(data) > 0:
        data = np.vstack((data, open_data['data']))
        labels = np.hstack((labels, open_data['labels']))
    else:
        data = open_data['data']
        labels = open_data['labels']

data = grayscale(data)
x = np.matrix(data)
y = np.array(labels)
print(x.shape)
(50000, 1024)

Not: './cifar-10-batches-py/data_batch_' dosyasını dosyanızın gerçek konumuyla değiştirin. Örneğin Windows yol dosya adı = 'E:\cifar-10-batches-py\data_batch_' + str(i) olabilir

Adım 4) Eğitim veri kümesini oluşturun

Eğitimi daha hızlı ve kolay hale getirmek için yalnızca at görselleri üzerinde bir model eğiteceksiniz. Atlar etiket verilerinde yedinci sınıftır. CIFAR-10 veri setinin dokümantasyonunda belirtildiği gibi her sınıf 5000 görüntü içermektedir. Aşağıda gösterildiği gibi 5.000 sütunlu 1024 görselin olduğunu doğrulamak için verinin şeklini yazdırabilirsiniz. TensorFlow Otomatik kodlayıcı örnek adımı.

horse_i = np.where(y == 7)[0]
horse_x = x[horse_i]
print(np.shape(horse_x)) 
(5000, 1024)

Adım 5) Bir görüntü görselleştirici oluşturun

Son olarak, görüntüleri çizmek için bir işlev oluşturursunuz. Yeniden oluşturulan görüntüyü otomatik kodlayıcıdan yazdırmak için bu işleve ihtiyacınız olacaktır.

Görüntüleri yazdırmanın kolay bir yolu, matplotlib kütüphanesindeki imshow nesnesini kullanmaktır. Verinin şeklini 1024'ten 32*32'ye (yani görüntünün formatı) dönüştürmeniz gerektiğini unutmayın.

# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
def plot_image(image, shape=[32, 32], cmap = "Greys_r"):
    plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")
    plt.axis("off")   

Fonksiyon 3 argüman alır:

• Resim: girdi
• Shape: liste, görüntünün boyutu
• C haritası:renk haritasını seçin. Varsayılan olarak gri

Veri kümesindeki ilk görüntüyü çizmeyi deneyebilirsiniz. At üstünde bir adam görmelisin.

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")

Veri Kümesi Tahmincisini Ayarla

Tamam, artık veri seti kullanıma hazır olduğuna göre Tensorflow'u kullanmaya başlayabilirsiniz. Modeli oluşturmadan önce ağı beslemek için Tensorflow'un Veri Kümesi tahmincisini kullanalım.

TensorFlow tahmincisi ile bir Veri Kümesi oluşturacaksınız. Zihninizi yenilemek için şunları kullanmanız gerekir:

• from_tensor_slices
• tekrar et
• yığın

Veri kümesini oluşturmak için gereken kodun tamamı şöyledir:

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

Dikkat edin, x aşağıdaki şekle sahip bir yer tutucudur:

• [None,n_inputs]: Ağa gönderilen görüntü sayısı toplu iş boyutuna eşit olduğundan Yok olarak ayarlayın.

Ayrıntılar için lütfen şu eğitime bakın: doğrusal regresyon.

Bundan sonra yineleyiciyi oluşturmanız gerekir. Bu kod satırı olmadan hiçbir veri işlem hattından geçemez.

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()

Artık boru hattı hazır olduğuna göre, ilk görüntünün öncekiyle aynı olup olmadığını kontrol edebilirsiniz (ör. at üzerindeki bir adam).

Toplu boyutu 1 olarak ayarladınız çünkü veri setine yalnızca bir görüntü beslemek istiyorsunuz. Verilerin boyutunu print(sess.run(features).shape) ile görebilirsiniz. (1, 1024) değerine eşittir. 1, her birine yalnızca 1024'lük bir görüntünün beslendiği anlamına gelir. Toplu boyut ikiye ayarlanırsa, o zaman iki görüntü işlem hattından geçer. (Toplu boyutu değiştirmeyin. Aksi takdirde, bir hata verir. Bir seferde yalnızca bir görüntü plot_image() fonksiyonuna gidebilir.

## Parameters
n_inputs = 32 * 32
BATCH_SIZE = 1
batch_size = tf.placeholder(tf.int64)

# using a placeholder
x = tf.placeholder(tf.float32, shape=[None,n_inputs])
## Dataset
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
iter = dataset.make_initializable_iterator() # create the iterator
features = iter.get_next()

## Print the image
with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iter.initializer, feed_dict={x: horse_x,
                                         batch_size: BATCH_SIZE}) 
    print(sess.run(features).shape) 
    plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")
(1, 1024)

Ağı oluşturun

Ağı kurmanın zamanı geldi. Yığılmış bir otomatik kodlayıcıyı, yani birden fazla gizli katmana sahip bir ağı eğiteceksiniz.

Ağınızda 1024 noktalı, yani 32×32, görüntünün şekline sahip bir giriş katmanı bulunacaktır.

Kodlayıcı bloğu, 300 nöronlu bir üst gizli katmana ve 150 nöronlu bir merkezi katmana sahip olacaktır. Kod çözücü bloğu kodlayıcıya simetriktir. Aşağıdaki resimde ağı görselleştirebilirsiniz. Gizli ve merkezi katmanların değerlerini değiştirebileceğinizi unutmayın.

Otomatik kodlayıcı oluşturmak diğer derin öğrenme modellerine çok benzer.

Modeli şu adımları izleyerek oluşturacaksınız:

1. Parametreleri tanımlayın
2. Katmanları tanımlayın
3. Mimariyi tanımlayın
4. Optimizasyonu tanımlayın
5. Modeli çalıştırın
6. Modeli değerlendirin

Önceki bölümde, modeli beslemek için bir boru hattının nasıl oluşturulacağını öğrendiniz, böylece veri kümesini bir kez daha oluşturmaya gerek kalmaz. Dört katmanlı bir otomatik kodlayıcı oluşturacaksınız. Xavier başlatmayı kullanırsınız. Bu, başlangıç ​​ağırlıklarını hem girdinin hem de çıktının varyansına eşitleyen bir tekniktir. Son olarak elu aktivasyon fonksiyonunu kullanırsınız. Kayıp fonksiyonunu L2 düzenleyici ile düzenlersiniz.

) 1 Adım Parametreleri tanımlayın

İlk adım, her katmandaki nöron sayısını, öğrenme hızını ve düzenleyicinin hiperparametresini tanımlamayı gerektirir.

Ondan önce, fonksiyonu kısmen içe aktarırsınız. Yoğun katmanların parametrelerini tanımlamak daha iyi bir yöntemdir. Aşağıdaki kod, otokoder mimarisinin değerlerini tanımlar. Daha önce listelendiği gibi, otokoderin iki katmanı vardır, ilk katmanlarda 300 nöron ve ikinci katmanlarda 150 nöron vardır. Değerleri n_hidden_1 ve n_hidden_2'de saklanır.

Öğrenme oranını ve L2 hiperparametresini tanımlamanız gerekir. Değerler öğrenme_oranı ve l2_reg'de saklanır

from functools import partial

## Encoder
n_hidden_1 = 300
n_hidden_2 = 150  # codings

## Decoder
n_hidden_3 = n_hidden_1
n_outputs = n_inputs

learning_rate = 0.01
l2_reg = 0.0001

Xavier başlatma tekniği, tahminci katkısından gelen xavier_initializer nesnesiyle çağrılır. Aynı tahmincide, düzenleyiciyi l2_regularizer ile ekleyebilirsiniz.

## Define the Xavier initialization
xav_init =  tf.contrib.layers.xavier_initializer()
## Define the L2 regularizer
l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

) 2 Adım Katmanları tanımlayın

Yoğun katmanların tüm parametreleri ayarlandı; kısmi nesneyi kullanarak her şeyi yoğun_katman değişkenine paketleyebilirsiniz. ELU aktivasyonunu, Xavier başlatmayı ve L2 düzenlemesini kullanan yoğun_katman.

## Create the dense layer
dense_layer = partial(tf.layers.dense,
                         activation=tf.nn.elu,
                         kernel_initializer=xav_init,
                         kernel_regularizer=l2_regularizer)

) 3 Adım Mimariyi tanımlayın

Mimarinin resmine bakarsanız, ağın bir çıktı katmanıyla üç katmanı istiflediğini fark edersiniz. Aşağıdaki kodda, uygun katmanları birbirine bağlarsınız. Örneğin, ilk katman giriş matris özellikleri ile 300 ağırlığı içeren matrisler arasındaki nokta çarpımını hesaplar. Nokta çarpımı hesaplandıktan sonra, çıktı Elu aktivasyon fonksiyonuna gider. Çıktı bir sonraki katmanın girdisi olur, bu yüzden bunu hidden_2'yi hesaplamak için kullanırsınız ve benzeri. Matris çarpımı her katman için aynıdır çünkü aynı aktivasyon fonksiyonunu kullanırsınız. Son katman olan çıktıların bir aktivasyon fonksiyonu uygulamadığını unutmayın. Bu mantıklıdır çünkü bu yeniden yapılandırılmış girdidir

## Make the mat mul
hidden_1 = dense_layer(features, n_hidden_1)
hidden_2 = dense_layer(hidden_1, n_hidden_2)
hidden_3 = dense_layer(hidden_2, n_hidden_3)
outputs = dense_layer(hidden_3, n_outputs, activation=None)

) 4 Adım Optimizasyonu tanımlayın

Son adım, optimize ediciyi oluşturmaktır. Ortalama Kare Hatasını kayıp fonksiyonu olarak kullanırsınız. Doğrusal regresyon hakkındaki öğreticiyi hatırlarsanız, MSE'nin tahmin edilen çıktı ile gerçek etiket arasındaki farkla hesaplandığını bilirsiniz. Burada etiket özelliktir çünkü model girişi yeniden yapılandırmaya çalışır. Bu nedenle, tahmin edilen çıktı ile girdi arasındaki karelerin toplamının ortalamasını istiyorsunuz. TensorFlow ile kayıp fonksiyonunu aşağıdaki gibi kodlayabilirsiniz:

loss = tf.reduce_mean(tf.square(outputs - features))

Daha sonra kayıp fonksiyonunu optimize etmeniz gerekir. Degradeleri hesaplamak için Adam optimizer'ı kullanırsınız. Amaç fonksiyonu kaybı en aza indirmektir.

## Optimize
loss = tf.reduce_mean(tf.square(outputs - features))
optimizer = tf.train.AdamOptimizer(learning_rate)
train  = optimizer.minimize(loss)

Modeli eğitmeden önce bir ayar daha. 150'lik bir toplu iş boyutu kullanmak, yani ardışık düzeni her yinelemede 150 görüntüyle beslemek istiyorsunuz. Yineleme sayısını manuel olarak hesaplamanız gerekir. Bunu yapmak önemsizdir:

Her seferinde 150 resim geçirmek istiyorsanız ve veri setinde 5000 resim olduğunu biliyorsanız, yineleme sayısı eşittir. Python'da aşağıdaki kodları çalıştırabilir ve çıktının 33 olduğundan emin olabilirsiniz:

BATCH_SIZE = 150
### Number of batches :  length dataset / batch size
n_batches = horse_x.shape[0] // BATCH_SIZE
print(n_batches)
33

) 5 Adım Modeli çalıştırın

Son fakat bir o kadar da önemlisi, modeli eğitin. Modeli 100 dönemle eğitiyorsunuz. Yani model, görüntülerin optimize edilmiş ağırlıklara göre 100 katını görecektir.

Tensorflow'da bir modeli eğitmeye yönelik kodlara zaten aşinasınız. Küçük fark, eğitimi çalıştırmadan önce verileri aktarmaktır. Bu şekilde model daha hızlı eğitilir.

Modelin bir şeyler öğrenip öğrenmediğini (yani kaybın azalıp azalmadığını) görmek için on dönem sonrasındaki kaybı yazdırmakla ilgileniyorsunuz. Eğitim, makine donanımınıza bağlı olarak 2 ila 5 dakika sürer.

## Set params
n_epochs = 100

## Call Saver to save the model and re-use it later during evaluation
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # initialise iterator with train data
    sess.run(iter.initializer, feed_dict={x: horse_x,
                                          batch_size: BATCH_SIZE})
    print('Training...')
    print(sess.run(features).shape) 
    for epoch in range(n_epochs):       
        for iteration in range(n_batches):
            sess.run(train)
        if epoch % 10 == 0:
            loss_train = loss.eval()   # not shown
            print("\r{}".format(epoch), "Train MSE:", loss_train) 
        #saver.save(sess, "./my_model_all_layers.ckpt") 
    save_path = saver.save(sess, "./model.ckpt")    
    print("Model saved in path: %s" % save_path)  
Training...
(150, 1024)
0 Train MSE: 2934.455
10 Train MSE: 1672.676
20 Train MSE: 1514.709
30 Train MSE: 1404.3118
40 Train MSE: 1425.058
50 Train MSE: 1479.0631
60 Train MSE: 1609.5259
70 Train MSE: 1482.3223
80 Train MSE: 1445.7035
90 Train MSE: 1453.8597
Model saved in path: ./model.ckpt

) 6 Adım Modeli değerlendirin

Artık modelinizi eğittiğinize göre, onu değerlendirmenin zamanı geldi. Test sertifikasını /cifar-10-batches-py/ dosyasından içe aktarmanız gerekir.

test_data = unpickle('./cifar-10-batches-py/test_batch')
test_x = grayscale(test_data['data'])
#test_labels = np.array(test_data['labels'])

NOT: Bir Windows makinede kod şu şekilde olur: test_data = unpicle(r”E:\cifar-10-batches-py\test_batch”)

Bir at olan 13 numaralı görseli yazdırmayı deneyebilirsiniz.

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")

Modeli değerlendirmek için bu görüntünün piksel değerini kullanacak ve kodlayıcının 1024 piksel küçülttükten sonra aynı görüntüyü yeniden oluşturup oluşturamayacağını göreceksiniz. Modeli farklı resimler üzerinde değerlendirmek için bir fonksiyon tanımladığınızı unutmayın. Model yalnızca atlarda daha iyi çalışmalıdır.

İşlev iki bağımsız değişken alır:

• df: Test verilerini içe aktarın
• resim_numarası: hangi görüntünün içe aktarılacağını belirtin

İşlev üç bölüme ayrılmıştır:

1. Görüntüyü doğru boyuta, yani 1, 1024'e yeniden şekillendirin
2. Modeli görünmeyen görüntüyle besleyin, görüntüyü kodlayın/kodunu çözün
3. Gerçek ve yeniden oluşturulmuş görüntüyü yazdırın

def reconstruct_image(df, image_number = 1):
    ## Part 1: Reshape the image to the correct dimension i.e 1, 1024
    x_test = df[image_number]
    x_test_1 = x_test.reshape((1, 32*32))
    
    ## Part 2: Feed the model with the unseen image, encode/decode the image
    with tf.Session() as sess:     
        sess.run(tf.global_variables_initializer()) 
        sess.run(iter.initializer, feed_dict={x: x_test_1,
                                      batch_size: 1})
    ## Part 3:  Print the real and reconstructed image
      # Restore variables from disk.
        saver.restore(sess, "./model.ckpt")  
        print("Model restored.")
      # Reconstruct image
        outputs_val = outputs.eval()
        print(outputs_val.shape)
        fig = plt.figure()
      # Plot real
        ax1 = fig.add_subplot(121)
        plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")
      # Plot estimated
        ax2 = fig.add_subplot(122)
        plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")
        plt.tight_layout()
        fig = plt.gcf()

Artık değerlendirme işlevi tanımlandığına göre, yeniden oluşturulmuş on üç numaralı görüntüye göz atabilirsiniz.

reconstruct_image(df =test_x, image_number = 13)

INFO:tensorflow:Restoring parameters from ./model.ckpt
Model restored.
(1, 1024)

ÖZET

• Otomatik kodlayıcının birincil amacı, giriş verilerini sıkıştırmak ve ardından bu sıkıştırmayı açarak orijinal verilere çok benzeyen bir çıktıya dönüştürmektir.
• Merkezi katman adı verilen bir pivot katmana sahip simetrik bir otokodlayıcının mimarisi.
• Aşağıdakileri kullanarak otomatik kodlayıcıyı oluşturabilirsiniz:

Kısmi: Tipik ayarlarla yoğun katmanlar oluşturmak için:

  	tf.layers.dense,                         
  	activation=tf.nn.elu,                         
  	kernel_initializer=xav_init,                         
  	kernel_regularizer=l2_regularizer

yoğun_katman(): matris çarpımını yapmak için

• Kayıp fonksiyonunu ve optimizasyonu aşağıdakilerle tanımlayabilirsiniz:

loss = tf.reduce_mean(tf.square(outputs - features))
optimizer = tf.train.AdamOptimizer(learning_rate)
train  = optimizer.minimize(loss)

• Son olarak modeli eğitmek için bir oturum çalıştırın.