TensorFlow Otomatik Kodlayıcı: Derin Öğrenme Örneği ile Veri Kümesi

Otomatik kodlayıcı nedir?

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ı etmek için eğiterek boyut azaltma için veri setlerinin temsilini öğrenmenize yardımcı olan bir tür yapay sinir ağıdır. Bir girdiyi yeniden oluşturmak için harika bir araçtır.

Basit bir deyişle, makine, diyelim ki bir görüntü alıyor ve yakından ilişkili bir resim üretebiliyor. Bu tür bir sinir ağındaki girdi etiketsizdir, yani ağ denetimsiz olarak öğrenebilir. Daha doğrusu, girdi ağ tarafından yalnızca en kritik özelliğe odaklanmak için kodlanır. Bu, otomatik kodlayıcının boyut azaltma için popüler olmasının nedenlerinden biridir. Ayrıca, otomatik kodlayıcılar üretken öğrenme modelleri üretmek için kullanılabilir . Örneğin, sinir ağı bir dizi yüzle eğitilebilir ve ardından yeni yüzler üretebilir.

Bu TensorFlow Otomatik Kodlayıcı eğitiminde şunları öğreneceksiniz:

• Otomatik kodlayıcı nedir?
• Autoencoder nasıl çalışır?
• Yığınlanmış Otomatik Kodlayıcı Örneği
• TensorFlow ile bir Otomatik Kodlayıcı oluşturun
• Görüntü ön işleme
• Veri Kümesi Tahmincisini Ayarla
• Ağı kurun

Autoencoder nasıl çalışır?

Bir otomatik kodlayıcının amacı, yalnızca temel özelliklere odaklanarak girişin yaklaşık bir değerini üretmektir. Çıktı üretmek için neden yalnızca girdiyi kopyalayıp yapıştırmayı öğrenmediğini düşünebilirsiniz. Aslında, bir otomatik kodlayıcı, ağı yalnızca çıktıyı kopyalamaktan farklı olarak 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ş, kodlayıcı adı verilen ilk bloğa gider . Bu dahili gösterim, girdinin boyutunu sıkıştırır (küçültür). İkinci blokta, girişin yeniden yapılandırılması meydana gelir. Bu, kod çözme aşamasıdır.

Autoencoder'ın Çalışması

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, 50x50 (yani 250 piksel) boyutunda bir resim ve yüz nörondan oluşan tek bir gizli katmana sahip bir sinir ağı hayal edin. Öğrenme, girişten iki kat daha küçük olan bir özellik haritası üzerinde yapılır. Bu, ağın sadece 100'e eşit bir nöron vektörü ile 250 pikseli yeniden inşa etmenin bir yolunu bulması gerektiği anlamına gelir.

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

Bu Otomatik Kodlayıcı eğitiminde, yığınlanmış bir otomatik kodlayıcının nasıl kullanılacağını öğreneceksiniz. Mimari, geleneksel bir sinir ağına benzer. Girdi, 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 yakın bir çıktı görüntüsü üretmektir. Model, görevini bir dizi kısıtlama altında, yani daha düşük bir boyutla gerçekleştirmenin bir yolunu öğrenmelidir.

Günümüzde, Derin Öğrenmedeki Otomatik Kodlayıcılar çoğunlukla bir görüntüyü denoize etmek için kullanılmaktadır. Çizikli bir görüntü düşünün; bir insan hala içeriği tanıyabilir. Otomatik kodlayıcıyı engelleme fikri, ağı verilerin arkasındaki modeli öğrenmeye zorlamak için resme gürültü eklemektir.

Autoencoder Deep Learning'in diğer kullanışlı ailesi varyasyonel otomatik kodlayıcıdır. Bu tür bir ağ, yeni görüntüler oluşturabilir. Bir erkek imajıyla bir ağ eğittiğinizi hayal edin; böyle bir ağ yeni yüzler üretebilir.

TensorFlow ile bir Otomatik Kodlayıcı oluşturun

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

60000 32x32 renkli görüntü içeren CIFAR-10 veri kümesini kullanacaksınız. Autoencoder veri kümesi, eğitim için 50000 görüntü ve test için 10.000 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örüntüleri indirmeniz ve sıkıştırmayı açmanız gerekir. 10-batches-py klasörü, her biri rasgele sırada 10000 görüntü içeren beş grup veri içerir.

Modelinizi oluşturmadan ve eğitmeden önce, bazı veri işleme uygulamanız gerekir. Aşağıdaki gibi ilerleyeceksiniz:

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şturun
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 kod ile yükleyebilirsiniz. Otomatik kodlayıcı kodu, verileri veri ve etiketle birlikte bir sözlüğe yükleyecektir . Kodun bir işlev olduğuna dikkat edin.

import numpy as npimport tensorflow as tfimport pickledef unpickle(file):import picklewith 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ı için, verileri gri tonlamaya dönüştüreceksiniz. Yani, renkli görüntü için üçe karşı yalnızca bir boyutla. Sinir ağının çoğu yalnızca bir boyut girdisi ile ç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 grupları 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. Dikkatlice kontrol ederseniz, verileri içeren unzip dosyası 1'den 5'e kadar bir sayı ile data_batch_ olarak adlandırılır. Dosyalar üzerinde döngü oluşturabilir ve verilere ekleyebilirsiniz.

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

# Load the data into memorydata, labels = [], []## Loop over the bfor 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 konumuna değiştirin. Örneğin Windows makinesi için yol dosyaadı = 'E: \ cifar-10-batches-py \ data_batch_' + str (i) olabilir.

Adım 4) Eğitim veri setini oluşturun

Eğitimi daha hızlı ve daha kolay hale getirmek için, yalnızca at görüntüleri üzerinde bir model eğiteceksiniz. Atlar, etiket verilerindeki yedinci sınıftır. CIFAR-10 veri kümesinin belgelerinde belirtildiği gibi, her sınıf 5000 görüntü içerir. Aşağıdaki TensorFlow Otomatik Kodlayıcı örnek adımında gösterildiği gibi 1024 sütunlu 5.000 görüntü olduğunu doğrulamak için verilerin şeklini yazdırabilirsiniz.

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. Otomatik kodlayıcıdan yeniden oluşturulmuş görüntüyü yazdırmak için bu işleve ihtiyacınız olacaktır.

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

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

İşlev 3 argüman alır:

• Resim: girdi
• Şekil: liste, görüntünün boyutu
• Cmap: 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

Pekala, 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 tahmin edicisini kullanalım.

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

• from_tensor_slices
• tekrar et
• parti

Veri kümesini oluşturmak için tam kod:

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

X'in aşağıdaki şekle sahip bir yer tutucu olduğunu unutmayın:

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

Ayrıntılar için lütfen doğrusal regresyon hakkındaki eğiticiye bakın.

Bundan sonra, yineleyiciyi oluşturmanız gerekir. Bu kod satırı olmadan, boru hattından hiçbir veri geçmez.

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 (yani, at üstündeki bir adam).

Veri kümesini yalnızca bir resimle beslemek istediğiniz için toplu iş boyutunu 1 olarak ayarlarsınız. Verilerin boyutunu print (sess.run (features) .shape) ile görebilirsiniz. (1, 1024) 'e eşittir. 1, her biri 1024 olan yalnızca bir resmin beslendiği anlamına gelir. Toplu iş boyutu ikiye ayarlanırsa, ardışık düzen boyunca iki görüntü geçecektir. (Toplu iş boyutunu değiştirmeyin. Aksi takdirde hata verir. Plot_image () işlevine her seferinde yalnızca bir resim gidebilir.

## Parametersn_inputs = 32 * 32BATCH_SIZE = 1batch_size = tf.placeholder(tf.int64)# using a placeholderx = tf.placeholder(tf.float32, shape=[None,n_inputs])## Datasetdataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()## Print the imagewith tf.Session() as sess:# feed the placeholder with datasess.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ğı kurun

Ağı kurmanın zamanı geldi. Yığınlanmış bir otomatik kodlayıcı, yani birden çok gizli katmana sahip bir ağ eğiteceksiniz.

Ağınız, görüntünün şekli olan 32x32 gibi 1024 noktalı bir giriş katmanına sahip olacaktır.

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

Autoencoder için ağ oluşturma

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 ardışık düzen oluşturmayı öğrendiniz, böylece veri kümesini bir kez daha oluşturmanıza gerek kalmaz. Dört katmanlı bir otomatik kodlayıcı oluşturacaksınız. Xavier başlatmayı kullanıyorsunuz. Bu, başlangıç ​​ağırlıklarını hem girdinin hem de çıktının varyansına eşit ayarlamaya yönelik bir tekniktir. Son olarak, elu aktivasyon işlevini kullanırsınız. L2 düzenleyici ile kayıp fonksiyonunu düzenlersiniz.

Adım 1) Parametreleri tanımlayın

İlk adım, her katmandaki nöron sayısını, öğrenme oranını ve düzenleyicinin hiper parametresini tanımlamayı ima eder.

Bundan önce, işlevi kısmen içe aktarırsınız. Yoğun katmanların parametrelerini tanımlamak daha iyi bir yöntemdir. Aşağıdaki kod, otomatik kodlayıcı mimarisinin değerlerini tanımlar. Daha önce listelendiği gibi, otomatik kodlayıcının ilk katmanda 300 nöron ve ikinci katmanda 150 olmak üzere iki katmanı vardır. Değerleri n_hidden_1 ve n_hidden_2'de saklanır.

Öğrenme oranını ve L2 hiper parametresini tanımlamanız gerekir. Değerler learning_rate ve l2_reg'de saklanır

from functools import partial## Encodern_hidden_1 = 300n_hidden_2 = 150 # codings## Decodern_hidden_3 = n_hidden_1n_outputs = n_inputslearning_rate = 0.01l2_reg = 0.0001

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

## Define the Xavier initializationxav_init = tf.contrib.layers.xavier_initializer()## Define the L2 regularizerl2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

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

Yoğun katmanların tüm parametreleri ayarlanmıştır; kısmi nesneyi kullanarak yoğun_katman değişkenindeki her şeyi paketleyebilirsiniz. ELU aktivasyonunu, Xavier başlatmayı ve L2 regülasyonunu kullanan yoğun_katman.

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

Adım 3) Mimariyi tanımlayın

Mimarinin resmine bakarsanız, ağın bir çıktı katmanı ile üç katmanı istiflediğini görürsünüz. Aşağıdaki kodda, uygun katmanları bağlarsınız. Örneğin, birinci katman, girdi matrisi özellikleri ile 300 ağırlığı içeren matrisler arasındaki iç çarpımı hesaplar. Nokta ürün hesaplandıktan sonra, çıktı Elu aktivasyon işlevine gider. Çıktı bir sonraki katmanın girdisi olur, bu yüzden onu hidden_2 vb. Hesaplamak için kullanırsınız. Aynı etkinleştirme işlevini kullandığınız için matris çarpımı her katman için aynıdır. Son katman olan çıktıların bir etkinleştirme işlevi uygulamadığına dikkat edin. Mantıklı çünkü bu yeniden yapılandırılmış girdi

## Make the mat mulhidden_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)

Adım 4) Optimizasyonu tanımlayın

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

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

Ardından, kayıp işlevini optimize etmeniz gerekir. Degradeleri hesaplamak için Adam optimizer'ı kullanırsınız. Amaç, kaybı en aza indirmektir.

## Optimizeloss = 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 toplu iş boyutu kullanmak istiyorsunuz, yani ardışık düzeni her yinelemede 150 görüntü ile besleyin. Yineleme sayısını manuel olarak hesaplamanız gerekir. Bunu yapmak önemsizdir:

Her seferinde 150 görüntü iletmek istiyorsanız ve veri kümesinde 5000 görüntü 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 sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33

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

Son olarak, modeli eğitin. Modeli 100 dönemle eğitiyorsunuz. Yani model, görüntüleri optimize edilmiş ağırlıklara göre 100 kat daha fazla görecek.

Tensorflow'da bir model eğitmek için gereken kodları zaten biliyorsunuz. Küçük fark, eğitimi çalıştırmadan önce verileri yönlendirmektir. Bu şekilde model daha hızlı eğitilir.

Modelin bir şeyler öğrenip öğrenmediğini görmek için on dönem sonra kaybı yazdırmakla ilgileniyorsunuz (yani, kayıp azalıyor). Eğitim, makinenizin donanımına bağlı olarak 2 ila 5 dakika sürer.

## Set paramsn_epochs = 100## Call Saver to save the model and re-use it later during evaluationsaver = tf.train.Saver()with tf.Session() as sess:sess.run(tf.global_variables_initializer())# initialise iterator with train datasess.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 shownprint("\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.45510 Train MSE: 1672.67620 Train MSE: 1514.70930 Train MSE: 1404.311840 Train MSE: 1425.05850 Train MSE: 1479.063160 Train MSE: 1609.525970 Train MSE: 1482.322380 Train MSE: 1445.703590 Train MSE: 1453.8597Model saved in path: ./model.ckpt

Adım 6) Modeli değerlendirin

Artık modelinizi eğittiğinize göre, onu değerlendirme zamanı. 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 makinesi için kod, test_data = unsickle (r "E: \ cifar-10-batches-py \ test_batch") olur

Bir at olan görüntüleri 13 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 işlev tanımladığınızı unutmayın. Model sadece atlarda daha iyi çalışmalıdır.

İşlev iki argüman alır:

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

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

1. Resmi doğru boyuta (ör. 1, 1024) yeniden şekillendirin
2. Modeli görünmeyen görüntü ile 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, 1024x_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 imagewith 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 imageoutputs_val = outputs.eval()print(outputs_val.shape)fig = plt.figure()# Plot realax1 = fig.add_subplot(121)plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")# Plot estimatedax2 = 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 yapılandırılmış on üç numaralı görüntüye bir göz atabilirsiniz.

reconstruct_image(df =test_x, image_number = 13) 

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

Özet

Bir otomatik kodlayıcının birincil amacı, girdi verilerini sıkıştırmak ve ardından onu orijinal verilere çok benzeyen bir çıktıya açmaktır.

Merkezi katman olarak adlandırılan bir pivot katmanı ile simetrik bir otomatik kodlayıcının mimarisi.

Otomatik kodlayıcıyı aşağıdakileri kullanarak oluşturabilirsiniz:

• Kısmi: tipik ayar ile yoğun katmanları oluşturmak için:

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

• dense_layer (): matris çarpımını yapmak için

kayıp fonksiyonunu ve optimizasyonu şu şekilde tanımlayabilirsiniz:

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

Modeli eğitmek için son olarak bir oturum çalıştırın.