TensorFlow ile Doğrusal Regresyon Eğitimi [Örnekler]
Evelyn Clarke
Doğrusal Regresyon nedir?
Doğrusal regresyon iki değişken arasındaki ilişkileri modellemek için istatistikte bir yaklaşımdır. Bu modelleme, skaler bir yanıt ile bir veya daha fazla açıklayıcı değişken arasında yapılır. Bir açıklayıcı değişkenle olan ilişkiye basit doğrusal regresyon, birden fazla açıklayıcı değişken için ise çoklu doğrusal regresyon adı verilir.
TensorFlow, hesaplamalar üzerinde tam kontrole sahip olmanızı sağlayacak araçlar sağlar. Bu, düşük seviyeli API ile yapılır. Üstelik TensorFlow, birçok işlemi gerçekleştirmek için çok çeşitli API'lerle donatılmıştır. makine öğrenme algoritmalar. Bu üst düzey API'dir. TensorFlow bunları tahminci olarak adlandırıyor
- Düşük seviyeli API: Mimariyi oluşturun, modelin optimizasyonunu sıfırdan yapın. Yeni başlayanlar için karmaşıktır
- Üst düzey API: Algoritmayı tanımlayın. Daha kolay kullanımlıdır. TensorFlow, şu adla bir araç kutusu sağlar: tahminci inşa etmek, eğitmek, değerlendirmek ve tahminde bulunmak.
Bu eğitimde şunları kullanacaksınız: yalnızca tahminciler. Hesaplamalar daha hızlıdır ve uygulanması daha kolaydır. Öğreticinin ilk bölümünde TensorFlow'da Doğrusal regresyonu eğitmek için degrade iniş optimize edicinin nasıl kullanılacağı açıklanmaktadır. İkinci bölümde, TensorFlow tahmin aracını kullanarak bir evin fiyatını tahmin etmek için Boston veri setini kullanacaksınız.
Doğrusal regresyon modeli nasıl eğitilir
Modeli eğitmeye başlamadan önce doğrusal regresyonun ne olduğuna bir bakalım.
İki değişkeniniz olduğunu düşünün, x ve y ve göreviniz değerini bilmenin değerini tahmin etmektir. Verileri çizerseniz, bağımsız değişkeniniz x ile bağımlı değişkeniniz y arasında pozitif bir ilişki görebilirsiniz.
Eğer x=1,y ise kabaca 6'ya eşit olacak ve eğer x=2,y ise 8.5 civarında olacaktır.
Bu çok doğru bir yöntem değildir ve özellikle yüzbinlerce noktaya sahip bir veri kümesinde hataya açıktır.
Doğrusal bir regresyon bir denklemle değerlendirilir. Y değişkeni bir veya daha fazla ortak değişkenle açıklanır. Örneğinizde yalnızca bir bağımlı değişken var. Bu denklemi yazmanız gerekirse, şöyle olacaktır:
İle:
önyargıdır. yani eğer x=0 ise, y=
x ile ilişkili ağırlıktır
modelin kalıntısı veya hatasıdır. Modelin verilerden öğrenemeyeceği şeyleri içerir
Modele uyduğunuzu ve aşağıdaki çözümü bulduğunuzu hayal edin:
- = 3.8
- = 2.78
Bu sayıları denklemde değiştirebilirsiniz ve sonuç şu şekilde olur:
y= 3.8 + 2.78x
Artık y'nin değerlerini bulmanın daha iyi bir yolu var. Yani x'i, y'yi tahmin etmek istediğiniz herhangi bir değerle değiştirebilirsiniz. Aşağıdaki resimde denklemdeki x'i veri kümesindeki tüm değerlerle değiştirdik ve sonucu çizdik.
Kırmızı çizgi uygun değeri, yani her x değeri için y değerlerini temsil eder. Y'yi tahmin etmek için x'in değerini görmenize gerek yok, her x için kırmızı çizgiye ait olan bir tane var. Ayrıca x'in 2'den büyük değerlerini de tahmin edebilirsiniz!
Doğrusal regresyonu daha fazla ortak değişkene genişletmek istiyorsanız modele daha fazla değişken ekleyerek bunu yapabilirsiniz. Geleneksel analiz ile doğrusal regresyon arasındaki fark, doğrusal regresyonun bağımsız olarak alınan her x değişkeni için y'nin nasıl tepki vereceğine bakmasıdır.
Bir örnek görelim. Bir dondurma dükkanının satışlarını tahmin etmek istediğinizi düşünün. Veri seti, hava durumu (yağmurlu, güneşli, bulutlu), müşteri bilgileri (maaş, cinsiyet, medeni durum gibi) gibi farklı bilgileri içermektedir.
Geleneksel analiz, diyelim ki her değişkenin ortalamasını hesaplayarak satışı tahmin etmeye çalışacak ve farklı senaryolar için satışı tahmin etmeye çalışacaktır. Bu, kötü tahminlere yol açacak ve analizi seçilen senaryoyla sınırlandıracaktır.
Doğrusal regresyon kullanırsanız şu denklemi yazabilirsiniz:
Algoritma ağırlıklar için en iyi çözümü bulacaktır; bu, maliyeti (takılı çizgi ile veri noktaları arasındaki farkı) en aza indirmeye çalışacağı anlamına gelir.
Algoritma nasıl çalışır?
Algoritma her biri için rastgele bir sayı seçecektir. 
ve 
ve y'nin tahmin edilen değerini elde etmek için x'in değerini değiştirin. Veri kümesinde 100 gözlem varsa algoritma 100 tahmin edilen değeri hesaplar.
Belirtilen hatayı hesaplayabiliriz 
modelin tahmin edilen değeri ile gerçek değeri arasındaki farktır. Pozitif hata, modelin y tahminini olduğundan düşük tahmin ettiği anlamına gelir; negatif hata ise modelin y tahminini olduğundan fazla tahmin ettiği anlamına gelir.
Amacınız hatanın karesini en aza indirmektir. Algoritma karesel hatanın ortalamasını hesaplar. Bu adıma hatanın en aza indirilmesi adı verilir. Doğrusal regresyon için Ortalama Kare HatasıMSE olarak da adlandırılır. Matematiksel olarak:
Nerede:
ağırlıklar öyle mi 
tahmin edilen değeri ifade eder- y gerçek değerlerdir
- m gözlem sayısıdır
tahmin edilen değeri ifade ederBunu not et 
matrislerin devriğini kullandığı anlamına gelir. 
ortalamanın matematiksel gösterimidir.
Amaç en iyiyi bulmak 
MSE'yi en aza indiren
Ortalama hatanın büyük olması modelin kötü performans gösterdiği ve ağırlıkların doğru seçilmediği anlamına gelir. Ağırlıkları düzeltmek için bir optimize edici kullanmanız gerekir. Geleneksel optimize ediciye denir Dereceli alçalma.
Gradyan inişi türevi alır ve ağırlığı azaltır veya arttırır. Türev pozitif ise ağırlık azalır. Türev negatifse ağırlık artar. Model ağırlıkları güncelleyecek ve hatayı yeniden hesaplayacaktır. Bu işlem hata değişmeyene kadar tekrarlanır. Her sürece bir denir tekrarlama. Ayrıca gradyanlar öğrenme oranıyla çarpılır. Öğrenmenin hızını gösterir.
Öğrenme oranı çok küçükse, algoritmanın yakınsaması çok uzun zaman alacaktır (yani çok sayıda yineleme gerektirir). Öğrenme oranı çok yüksekse algoritma hiçbir zaman yakınsamayabilir.
Yukarıdaki resimden de görebileceğiniz gibi, model ağırlıklar için sabit bir değer bulmak amacıyla işlemi yaklaşık 20 kez tekrarlıyor, dolayısıyla en düşük hataya ulaşıyor.
Bunu not et, hata sıfıra eşit değildir ancak 5 civarında sabitlenir. Bu, modelin tipik 5 hata yaptığı anlamına gelir. Hatayı azaltmak istiyorsanız modele daha fazla değişken gibi daha fazla bilgi eklemeniz veya farklı tahminciler kullanmanız gerekir. .
İlk denklemi hatırlıyorsun
Nihai ağırlıklar 3.8 ve 2.78'dir. Aşağıdaki video, bu ağırlıkları bulmak için degrade inişin kayıp fonksiyonunu nasıl optimize ettiğini gösterir.
TensorFlow ile Doğrusal Regresyon nasıl eğitilir
Artık arka planda neler olduğunu daha iyi anladığınıza göre, TensorFlow kullanarak ilk doğrusal regresyonunuzu eğitmek için TensorFlow tarafından sağlanan tahmin aracı API'sini kullanmaya hazırsınız.
Aşağıdaki değişkenleri içeren Boston Veri Setini kullanacaksınız
| suç | Şehirlere göre kişi başına düşen suç oranı |
|---|---|
| zn | 25,000 metrekarenin üzerindeki parseller için imar edilen konut arazilerinin oranı. |
| indus | kasaba başına perakende olmayan iş alanı oranı. |
| nox | nitrik oksit konsantrasyonu |
| rm | konut başına ortalama oda sayısı |
| yaş | 1940'tan önce inşa edilen, sahibi tarafından kullanılan birimlerin oranı |
| dis | beş Boston istihdam merkezine olan ağırlıklı mesafeler |
| vergi | Dolar başına tam değerli emlak vergisi oranı 10,000 |
| ptratio | şehre göre öğrenci-öğretmen oranı |
| Medv | Sahibi tarafından kullanılan evlerin ortalama değeri bin dolar |
Üç farklı veri kümesi oluşturacaksınız:
| veri kümesi | nesnel | şekil |
|---|---|---|
| Eğitim | Modeli eğitin ve ağırlıkları alın | 400, 10 |
| Değerlendirme | Modelin görünmeyen veriler üzerindeki performansını değerlendirin | 100, 10 |
| Tahmin | Yeni verilere göre evin değerini tahmin etmek için modeli kullanın | 6, 10 |
Amaç, evin değerini tahmin etmek için veri setinin özelliklerini kullanmaktır.
Eğitimin ikinci bölümünde, verileri içe aktarmak için TensorFlow'u üç farklı yöntemle nasıl kullanacağınızı öğreneceksiniz:
- Pandalarla
- İle Dizi
- Sadece TF
Tüm seçeneklerin aynı sonuçları sağlar.
TensorFlow doğrusal regresyon modelini oluşturmak, eğitmek ve değerlendirmek için üst düzey API'yi nasıl kullanacağınızı öğreneceksiniz. Düşük seviyeli API kullanıyorsanız aşağıdakileri elle tanımlamanız gerekiyordu:
- Kayıp fonksiyonu
- Optimize Etme: Gradyan iniş
- Matris çarpımı
- Grafik ve tensör
Bu yeni başlayanlar için sıkıcı ve daha karmaşıktır.
Pandalar
Modeli eğitmek için gerekli kütüphaneleri içe aktarmanız gerekir.
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools
) 1 Adım Verileri şununla içe aktarın: panda.
Sütun adlarını tanımlarsınız ve SÜTUNLAR'da saklarsınız. Verileri içe aktarmak için pd.read_csv() öğesini kullanabilirsiniz.
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
"dis", "tax", "ptratio", "medv"]
training_set = pd.read_csv(“E:/boston_train.csv”, skipinitialspace=Doğru, atlanan satırlar=1, adlar=SÜTUNLAR)
test_set = pd.read_csv(“E:/boston_test.csv”, skipinitialspace=Doğru, atlanan satırlar=1, adlar=SÜTUNLAR)
tahmin_set = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=Doğru, atlanan satırlar=1, adlar=SÜTUNLAR)
Verilerin şeklini yazdırabilirsiniz.
print(training_set.shape, test_set.shape, prediction_set.shape)
Çıktı
(400, 10) (100, 10) (6, 10)
Etiketin, yani y'nizin veri kümesine dahil edildiğini unutmayın. Yani iki liste daha tanımlamanız gerekiyor. Biri yalnızca özellikleri içerir, diğeri ise yalnızca etiketin adını içerir. Bu iki liste tahmincinize veri kümesindeki özelliklerin neler olduğunu ve etiketin sütun adının ne olduğunu söyleyecektir
Aşağıdaki kod ile yapılıyor.
FEATURES = ["crim", "zn", "indus", "nox", "rm",
"age", "dis", "tax", "ptratio"]
LABEL = "medv"
) 2 Adım Verileri dönüştür
Sayısal değişkenleri uygun formatta dönüştürmeniz gerekir. Tensorflow sürekli değişkeni dönüştürmek için bir yöntem sağlar: tf.feature_column.numeric_column().
Önceki adımda modele dahil etmek istediğiniz bir özelliğin listesini tanımlarsınız. Artık bunları sayısal verilere dönüştürmek için bu listeyi kullanabilirsiniz. Modelinizdeki özellikleri hariç tutmak istiyorsanız, feature_cols'u oluşturmadan önce ÖZELLİKLER listesine bir veya daha fazla değişkeni bırakmaktan çekinmeyin.
kullanacağınızı unutmayın Python feature_cols adında yeni bir liste oluşturmak için ÖZELLİKLER listesiyle liste kavrama. Dokuz kez tf.feature_column.numeric_column() yazmaktan kaçınmanıza yardımcı olur. Liste kavrama, yeni listeler oluşturmanın daha hızlı ve daha temiz bir yoludur
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
) 3 Adım Tahminciyi tanımlayın
Bu adımda tahminciyi tanımlamanız gerekir. Tensorflow şu anda sınıflandırma görevi için 6 ve TensorFlow regresyon görevi için 3 dahil olmak üzere 3 önceden oluşturulmuş tahmin edici sunmaktadır:
- Regresör
- DNNRegresör
- DoğrusalRegresör
- DNNLineaBirleşikRegresör
- sınıflandırmak
- DNN Sınıflandırıcısı
- Doğrusal Sınıflandırıcı
- DNNLineaBirleşik Sınıflandırıcı
Bu derste Doğrusal Regresörü kullanacaksınız. Bu fonksiyona erişmek için tf.estimator'ı kullanmanız gerekir.
Fonksiyonun iki argümana ihtiyacı vardır:
- feature_columns: Modele dahil edilecek değişkenleri içerir
- model_dir: grafiğin saklanacağı yol, model parametrelerinin kaydedileceği vb.
Tensorflow, çalışma dizininizde otomatik olarak train adlı bir dosya oluşturacaktır. Aşağıdaki TensorFlow regresyon örneğinde gösterildiği gibi Tensorboard'a erişmek için bu yolu kullanmanız gerekir.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_cols,
model_dir="train")
Çıktı
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a215dc550>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
TensorFlow'un zorlu kısmı modeli beslemenin yoludur. Tensorflow, paralel hesaplama ve çok büyük veri kümeleriyle çalışacak şekilde tasarlanmıştır. Makine kaynaklarının sınırlı olması nedeniyle modelin tüm verilerle aynı anda beslenmesi mümkün değildir. Bunun için her seferinde bir grup veriyi beslemeniz gerekir. Milyonlarca veya daha fazla kaydın bulunduğu devasa bir veri setinden bahsettiğimizi unutmayın. Toplu eklemezseniz, bir bellek hatasıyla karşılaşırsınız.
Örneğin, verileriniz 100 gözlem içeriyorsa ve toplu iş boyutunu 10 olarak tanımlarsanız bu, modelin her yinelemede 10 gözlem göreceği anlamına gelir (10*10).
Model tüm verileri gördüğünde birini bitirir çağ. Dönem, modelin verileri kaç kez görmesini istediğinizi tanımlar. Bu adımı hiçbiri olarak ayarlamak ve modelin yineleme sayısını gerçekleştirmesine izin vermek daha iyidir.
Eklenecek ikinci bilgi, her yinelemeden önce verileri karıştırmak isteyip istemediğinizdir. Eğitim sırasında, modelin veri kümesinin belirli bir modelini öğrenmemesi için verileri karıştırmak önemlidir. Model, verilerin altta yatan modelinin ayrıntılarını öğrenirse, görülmemiş veriler için tahmini genelleştirmekte zorluk çekecektir. Buna denir aşırı oturma. Model, eğitim verileri üzerinde iyi performans gösterir ancak görünmeyen veriler için doğru tahminde bulunamaz.
TensorFlow bu iki adımı gerçekleştirmeyi kolaylaştırır. Veriler boru hattına gittiğinde, kaç gözleme (toplu) ihtiyaç duyduğunu ve verileri karıştırmanın gerekip gerekmediğini bilir.
Tensorflow'a modeli nasıl besleyeceğini öğretmek için pandas_input_fn'yi kullanabilirsiniz. Bu nesnenin 5 parametreye ihtiyacı var:
- x: özellik verileri
- y: etiket verileri
- toplu iş_boyutu: toplu iş. Varsayılan olarak 128
- num_epoch: Dönem sayısı, varsayılan olarak 1
- Karıştır: Verileri karıştırır veya karıştırmaz. Varsayılan olarak Yok
Modeli birçok kez beslemeniz gerekir, böylece bu işlemi tekrarlayacak bir fonksiyon tanımlarsınız. tüm bu işlevler get_input_fn.
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
return tf.estimator.inputs.pandas_input_fn(
x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
y = pd.Series(data_set[LABEL].values),
batch_size=n_batch,
num_epochs=num_epochs,
shuffle=shuffle)
Bir modelin performansını değerlendirmenin genel yöntemi şudur:
- Modeli eğitin
- Modeli farklı bir veri kümesinde değerlendirin
- Tahmin etmek
Tensorflow tahmincisi bu üç adımı kolaylıkla gerçekleştirmek için üç farklı fonksiyon sunar.
) 4 Adım: Modeli eğitin
Modeli değerlendirmek için tahmin aracı dizisini kullanabilirsiniz. Tren tahmincisinin bir input_fn'ye ve bir dizi adıma ihtiyacı vardır. Modeli beslemek için yukarıda oluşturduğunuz fonksiyonu kullanabilirsiniz. Daha sonra modele 1000 kez yineleme yapması talimatını verirsiniz. Dönem sayısını belirtmediğinizi, modelin 1000 kez yinelenmesine izin verdiğinizi unutmayın. Dönem sayısını 1 olarak ayarlarsanız model 4 kez yinelenir: Eğitim setinde 400 kayıt vardır ve toplu iş boyutu 128'dir.
- 128 satır
- 128 satır
- 128 satır
- 16 satır
Bu nedenle, çağ sayısını yok olarak ayarlamak ve yineleme sayısını aşağıdaki TensorFlow sınıflandırma örneğinde gösterildiği gibi tanımlamak daha kolaydır.
estimator.train(input_fn=get_input_fn(training_set,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
Çıktı
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into train/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 238.616 INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec) INFO:tensorflow:global_step/sec: 314.293 INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec) INFO:tensorflow:global_step/sec: 303.863 INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec) INFO:tensorflow:global_step/sec: 308.782 INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec) INFO:tensorflow:global_step/sec: 244.969 INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec) INFO:tensorflow:global_step/sec: 155.966 INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec) INFO:tensorflow:global_step/sec: 263.256 INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec) INFO:tensorflow:global_step/sec: 254.112 INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec) INFO:tensorflow:global_step/sec: 292.405 INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec) INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt. INFO:tensorflow:Loss for final step: 5925.9873.
Aşağıdaki komutu kullanarak Tensorboard'u kontrol edebilirsiniz:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train
) 5 Adım Modelinizi değerlendirin
Aşağıdaki kod ile modelinizin test setine uyumunu değerlendirebilirsiniz:
ev = estimator.evaluate(
input_fn=get_input_fn(test_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
Çıktı
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896
Kaybı aşağıdaki kodla yazdırabilirsiniz:
loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))
Çıktı
Loss: 3215.895996
Modelde 3215 kayıp bulunmaktadır. Hatanın ne kadar büyük olduğuna dair fikir edinmek için özet istatistiği inceleyebilirsiniz.
training_set['medv'].describe()
Çıktı
count 400.000000 mean 22.625500 std 9.572593 min 5.000000 25% 16.600000 50% 21.400000 75% 25.025000 max 50.000000 Name: medv, dtype: float64
Yukarıdaki özet istatistikten biliyorsunuz bir evin ortalama fiyatı 22 bin, minimum fiyatı 9 bin, maksimum 50 bin. Model 3 bin dolarlık tipik bir hata yapıyor.
) 6 Adım Tahmini yap
Son olarak, 6 Boston evinin değerini tahmin etmek için TensorFlow tahmin tahmin aracını kullanabilirsiniz.
y = estimator.predict(
input_fn=get_input_fn(prediction_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
Tahmini değerlerini yazdırmak için bu kodu kullanabilirsiniz:
predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))
Çıktı
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]
Model aşağıdaki değerleri tahmin etti:
| ev | Tahmin | |
|---|---|---|
| 1 | 32.29 | |
| 2 | 18.96 | |
| 3 | 27.27 | |
| 4 | 29.29 | |
| 5 | 16.43 | |
| 7 | 21.46 |
Gerçek değerini bilmediğimizi unutmayın. Derin öğrenme eğitiminde doğrusal modeli aşmaya çalışacaksınız
Numpy Çözümü
Bu bölümde, verileri beslemek için bir numpy tahmincisi kullanılarak modelin nasıl eğitileceği açıklanmaktadır. Yöntem, numpy_input_fn tahmincisini kullanacağınız yöntem ile aynıdır.
training_set_n = pd.read_csv(“E:/boston_train.csv”).values
test_set_n = pd.read_csv(“E:/boston_test.csv”).değerler
tahmin_set_n = pd.read_csv(“E:/boston_predict.csv”).values
) 1 Adım Verileri içeri aktarın
Öncelikle özellik değişkenlerini etiketten ayırmanız gerekir. Eğitim verileri ve değerlendirme için bunu yapmanız gerekir. Verileri bölmek için bir işlev tanımlamak daha hızlıdır.
def prepare_data(df):
X_train = df[:, :-3]
y_train = df[:,-3]
return X_train, y_train
Etiketi eğitme/değerlendirme veri kümesinin özelliklerinden ayırmak için bu işlevi kullanabilirsiniz.
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n)
Yalnızca NaN içerdiğinden tahmin veri kümesinin son sütununu hariç tutmanız gerekir
x_predict = prediction_set_n[:, :-2]
Dizinin şeklini onaylayın. Etiketin bir boyutu olmaması gerektiğini unutmayın, bu (400,) anlamına gelir.
print(X_train.shape, y_train.shape, x_predict.shape)
Çıktı
(400, 9) (400,) (6, 9)
Özellik sütunlarını aşağıdaki gibi oluşturabilirsiniz:
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
Tahminci daha önce olduğu gibi tanımlanır; özellik sütunlarına ve grafiğin nereye kaydedileceğine talimat verirsiniz.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_columns,
model_dir="train1")
Çıktı
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a218d8f28>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Verileri modele beslemek ve ardından modeli eğitmek için numpy tahminini kullanabilirsiniz. Okunabilirliği kolaylaştırmak için input_fn fonksiyonunu daha önce tanımladığımızı unutmayın.
# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(
x={"x": X_train},
y=y_train,
batch_size=128,
shuffle=False,
num_epochs=None)
estimator.train(input_fn = train_input,steps=5000)
Çıktı
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into train1/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 490.057 INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec) INFO:tensorflow:global_step/sec: 788.986 INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec) INFO:tensorflow:global_step/sec: 736.339 INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec) INFO:tensorflow:global_step/sec: 383.305 INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec) INFO:tensorflow:global_step/sec: 859.832 INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec) INFO:tensorflow:global_step/sec: 804.394 INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec) INFO:tensorflow:global_step/sec: 753.059 INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec) INFO:tensorflow:global_step/sec: 402.165 INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec) INFO:tensorflow:global_step/sec: 344.022 INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec) INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt. INFO:tensorflow:Loss for final step: 5925.985. Out[23]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>
Modelinizi değerlendirmek için aynı adımı farklı bir tahminciyle tekrarlarsınız
eval_input = tf.estimator.inputs.numpy_input_fn(
x={"x": X_test},
y=y_test,
shuffle=False,
batch_size=128,
num_epochs=1)
estimator.evaluate(eval_input,steps=None)
Çıktı
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945
Out[24]:
{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}
Son olarak tahmini hesaplayabilirsiniz. Pandalara benzer olmalı.
test_input = tf.estimator.inputs.numpy_input_fn(
x={"x": x_predict},
batch_size=128,
num_epochs=1,
shuffle=False)
y = estimator.predict(test_input)
predictions = list(p["predictions"] for p in itertools.islice(y, 6))
print("Predictions: {}".format(str(predictions)))
Çıktı
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]
Tensorflow çözümü
Son bölüm TensorFlow çözümüne ayrılmıştır. Bu yöntem diğerine göre biraz daha karmaşıktır.
Dikkat edin, eğer kullanırsanız Jupyter defterBu oturumu çalıştırmak için çekirdeği yeniden başlatmanız ve temizlemeniz gerekir.
TensorFlow verileri boru hattına aktarmak için harika bir araç geliştirdi. Bu bölümde input_fn fonksiyonunu kendiniz oluşturacaksınız.
) 1 Adım Verinin yolunu ve biçimini tanımlayın
Öncelikle csv dosyasının yolu ile iki değişken bildirirsiniz. Biri eğitim seti, diğeri test seti için olmak üzere iki dosyanız olduğunu unutmayın.
import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"
Daha sonra csv dosyasından kullanmak istediğiniz sütunları tanımlamanız gerekiyor. Tamamını kullanacağız. Bundan sonra değişkenin türünü bildirmeniz gerekir.
Floats değişkeni [0.] ile tanımlanır.
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
"dis", "tax", "ptratio", "medv"]RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]]
) 2 Adım input_fn işlevini tanımlayın
İşlev üç bölüme ayrılabilir:
- Verileri içeri aktarın
- Yineleyiciyi oluştur
- Verileri tüketin
Aşağıda işlevi tanımlamak için genel kod verilmiştir. Kod daha sonra açıklanacak
def input_fn(data_file, batch_size, num_epoch = None):
# Step 1
def parse_csv(value):
columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)
features = dict(zip(COLUMNS, columns))
#labels = features.pop('median_house_value')
labels = features.pop('medv')
return features, labels
# Extract lines from input files using the
Dataset API. dataset = (tf.data.TextLineDataset(data_file) # Read text file
.skip(1) # Skip header row
.map(parse_csv))
dataset = dataset.repeat(num_epoch)
dataset = dataset.batch(batch_size)
# Step 3
iterator = dataset.make_one_shot_iterator()
features, labels = iterator.get_next()
return features, labels
**Verileri içe aktar**
Bir csv dosyası için veri kümesi yöntemi her seferinde bir satır okur. Veri kümesini oluşturmak için nesneyi kullanmanız gerekir TextLineVeri kümesi. Veri kümenizin bir başlığı var, dolayısıyla ilk satırı atlamak için skip(1) komutunu kullanmanız gerekiyor. Bu noktada yalnızca verileri okursunuz ve başlığı işlem hattında hariç tutarsınız. Modeli beslemek için özellikleri etiketten ayırmanız gerekir. Verilere herhangi bir dönüşümü uygulamak için kullanılan yöntem haritadır.
Bu yöntem, verinin nasıl dönüştürüleceğini öğretmek için oluşturacağınız bir fonksiyonu çağırır. TextLineVeri kümesi nesnesi, başlığı hariç tutun ve bir fonksiyon tarafından talimat verilen bir dönüşümü uygulayın.Kod açıklaması
- tf.data.TextLineDataset(data_file): Bu satır csv dosyasını okur
- .skip(1): başlığı atla
- .map(parse_csv)): kayıtları tensörlere ayrıştırın Harita nesnesine talimat vermek için bir fonksiyon tanımlamanız gerekir. Bu işlevi parse_csv olarak çağırabilirsiniz.
Bu fonksiyon csv dosyasını tf.decode_csv metoduyla ayrıştırır ve özellikleri ve etiketi bildirir. Özellikler bir sözlük veya bir tuple olarak bildirilebilir. Daha kullanışlı olduğu için sözlük metodunu kullanırsınız.Kod açıklaması
- tf.decode_csv(value, Record_defaults= RECORDS_ALL): decode_csv yöntemi, çıktıyı kullanır. TextLineCSV dosyasını okumak için veri kümesi. Record_defaults, TensorFlow'a sütun türü hakkında talimat verir.
- dict(zip(_CSV_COLUMNS, sütunlar)): Sözlüğü bu veri işleme sırasında çıkarılan tüm sütunlarla doldurun
- feature.pop('median_house_value'): Hedef değişkeni özellik değişkeninden hariç tutun ve bir etiket değişkeni oluşturun
Veri Kümesinin Tensörleri yinelemeli olarak beslemek için daha fazla öğeye ihtiyacı vardır. Aslında, veri kümesinin modeli beslemeye süresiz olarak devam etmesine izin vermek için yöntem tekrarını eklemeniz gerekir. Yöntemi eklemezseniz model yalnızca bir kez yinelenir ve ardından ardışık düzende daha fazla veri beslenmediğinden hata atar.
Bundan sonra toplu iş yöntemini kullanarak toplu iş boyutunu kontrol edebilirsiniz. Bu, veri kümesine her yineleme için ardışık düzende kaç veri iletmek istediğinizi söylemeniz anlamına gelir. Büyük bir toplu iş boyutu ayarlarsanız model yavaş olacaktır.
Adım 3) Yineleyiciyi oluşturun
Artık ikinci adıma hazırsınız: veri kümesindeki öğeleri döndürecek bir yineleyici oluşturun.
Operatör oluşturmanın en basit yolu make_one_shot_iterator yöntemidir.
Bundan sonra yineleyiciden özellikleri ve etiketleri oluşturabilirsiniz.
Adım 4) Verileri tüketin
input_fn işleviyle ne olduğunu kontrol edebilirsiniz. Verileri tüketmek için işlevi bir oturumda çağırmanız gerekir. 1'e eşit bir parti boyutuyla deneyin.
Özellikleri bir sözlükte ve etiketi bir dizi olarak yazdırdığını unutmayın.
CSV dosyasının ilk satırını gösterecektir. Bu kodu farklı toplu iş boyutlarıyla birçok kez çalıştırmayı deneyebilirsiniz.
next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)
with tf.Session() as sess:
first_batch = sess.run(next_batch)
print(first_batch)
Çıktı
({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))
) 4 Adım Özellik sütununu tanımlayın
Sayısal sütunları aşağıdaki gibi tanımlamanız gerekir:
X1= tf.feature_column.numeric_column('crim')
X2= tf.feature_column.numeric_column('zn')
X3= tf.feature_column.numeric_column('indus')
X4= tf.feature_column.numeric_column('nox')
X5= tf.feature_column.numeric_column('rm')
X6= tf.feature_column.numeric_column('age')
X7= tf.feature_column.numeric_column('dis')
X8= tf.feature_column.numeric_column('tax')
X9= tf.feature_column.numeric_column('ptratio')
Tüm değişkenleri bir grupta birleştirmeniz gerektiğini unutmayın
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
) 5 Adım Modeli oluşturun
Modeli LinearRegressor tahmincisi ile eğitebilirsiniz.
model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')
Çıktı
INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': 'train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820a010f0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Argümanın inpu_fn işlevine yazılmasına izin vermek için bir lambda işlevi kullanmanız gerekir. Eğer bir lambda işlevimodeli eğitemezsiniz.
# Train the estimatormodel.train(steps =1000,
input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))
Çıktı
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into train3/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 72.5646 INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec) INFO:tensorflow:global_step/sec: 101.355 INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec) INFO:tensorflow:global_step/sec: 109.293 INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec) INFO:tensorflow:global_step/sec: 102.235 INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec) INFO:tensorflow:global_step/sec: 104.656 INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec) INFO:tensorflow:global_step/sec: 106.697 INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec) INFO:tensorflow:global_step/sec: 118.454 INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec) INFO:tensorflow:global_step/sec: 114.947 INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec) INFO:tensorflow:global_step/sec: 111.484 INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec) INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt. INFO:tensorflow:Loss for final step: 5925.9873. Out[8]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>
Aşağıdaki kod ile modelinizin test setine uyumunu değerlendirebilirsiniz:
results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))
for key in results:
print(" {}, was: {}".format(key, results[key]))
Çıktı
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896 average_loss, was: 32.158958435058594 loss, was: 3215.89599609375 global_step, was: 1000
Son adım, özelliklerin matrislerine göre değerini tahmin etmektir. Tahmin etmek istediğiniz değerleri içeren bir sözlük yazabilirsiniz. Modelinizde 9 özellik bulunduğundan her birine bir değer vermeniz gerekir. Model her biri için bir tahmin sağlayacaktır.
Aşağıdaki kodda df_predict csv dosyasında bulunan her özelliğin değerini yazdınız.
Veri setinde etiket olmadığı için yeni bir input_fn fonksiyonu yazmanız gerekiyor. API from_tensor'u Veri Kümesinden kullanabilirsiniz.
prediction_input = {
'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],
'zn': [75.0,0.0,25.0,33.0,0.0,0.0],
'indus': [2.95,18.10,5.13,2.18,18.10,9.90],
'nox': [0.428,0.713,0.453,0.472,0.700,0.544],
'rm': [7.024,6.297,6.762,7.236,5.390,5.782],
'age': [15.8,91.8,43.4,41.1,98.9,71.7],
'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],
'tax': [252,666,284,222,666,304],
'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]
}
def test_input_fn():
dataset = tf.data.Dataset.from_tensors(prediction_input)
return dataset
# Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn)
Son olarak tahminleri yazdırırsınız.
for pred in enumerate(pred_results): print(pred)
Çıktı
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
(0, {'predictions': array([32.297546], dtype=float32)})
(1, {'predictions': array([18.96125], dtype=float32)})
(2, {'predictions': array([27.270979], dtype=float32)})
(3, {'predictions': array([29.299236], dtype=float32)})
(4, {'predictions': array([16.436684], dtype=float32)})
(5, {'predictions': array([21.460876], dtype=float32)})
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})
ÖZET
Bir modeli eğitmek için şunları yapmanız gerekir:
- Özellikleri tanımlayın: Bağımsız değişkenler: X
- Etiketi tanımlayın: Bağımlı değişken: y
- Bir eğitim/test seti oluşturun
- Başlangıç ağırlığını tanımlayın
- Kayıp fonksiyonunu tanımlayın: MSE
- Modeli optimize edin: Gradyan iniş
- tanımlayın:
- Öğrenme oranı
- Dönem sayısı
- Parti boyutu
Bu eğitimde, doğrusal regresyon TensorFlow tahmincisi için üst düzey API'nin nasıl kullanılacağını öğrendiniz. Tanımlamanız gerekir:
- Özellik sütunları. Sürekli ise: tf.feature_column.numeric_column(). Bir listeyi python liste anlayışıyla doldurabilirsiniz
- Tahmin edici: tf.estimator.LinearRegressor(feature_columns, model_dir)
- Verileri, parti boyutunu ve dönemi içe aktarmak için bir işlev: input_fn()
Bundan sonra train(), Evaluation() ve Predict() ile eğitim vermeye, değerlendirmeye ve tahmin yapmaya hazırsınız.
