DNN tabanlı metin sınıflandırması uygulamak için TensorFlow'u nasıl kullanacağınızı öğretin
Leifeng.com'un notu: Bu makale, Leifeng.com tarafından derlenen bir veri bilimi geliştiricisinin kişisel blogundan gelmektedir.
Birçok geliştirici acemilere öneriyor: Makine öğrenimine başlamak istiyorsanız, önce bazı temel algoritmaların çalışma ilkelerini anlamalı ve ardından uygulamalı uygulamaya başlamalısınız. Ama ben öyle düşünmüyorum.
Bence pratik teoriden daha yüksek. Bir aceminin yapması gereken ilk şey, tüm modelin iş akışını anlamak, verilerin kabaca nasıl aktığını, hangi anahtar düğümlerin geçtiğini, nihai sonuçları nereden elde edeceğini ve hemen uygulamaya ve kendilerini inşa etmeye başlamaktır. Makine öğrenimi modeli. Algoritmaların ve işlevlerin dahili uygulama mekanizmasına gelince, tüm süreci anladıktan sonra pratikte daha derinlemesine öğrenebilir ve ustalaşabilirsiniz.
Öyleyse soru şu ki, yeni başlayan biri olarak algoritmanın ayrıntılarına hakim olmanıza gerek olmadığı için, modeli uygulama sürecinde ilgili algoritmaları kullanmanız gerektiğine göre, ne yapmalıyım? Cevap, TensorFlow gibi İnternette uygulanan işlev kitaplıklarının yardımıyla.
Bu makalede, TensorFlow'u derin bir sinir ağına (DNN) dayalı bir metin sınıflandırma modeli uygulamak için kullanacağız. acemi Yardımcı olur. Makalede yer alan kodun tamamı GitHub'da açık kaynaklıdır ve ilgilenen arkadaşlar aşağıdaki bağlantıdan indirebilirler:
Resmi eğitim içeriği aşağıdadır:
TensorFlow hakkında
TensorFlow, Google'ın sahibi olduğu açık kaynaklı bir makine öğrenimi çerçevesidir. İsminden, bu çerçevenin temel çalışma prensibini görebilirsiniz: çok boyutlu bir diziden oluşan bir tensör, girdiden çıktıya, grafik düğümleri arasında yönlü olarak akar.
TensorFlow'da, her işlem bir veri akışı grafiğiyle temsil edilebilir. Her veri akış diyagramı aşağıdaki iki önemli unsura sahiptir:
İşlemin kendisini temsil eden bir tf.Operation nesneleri grubu;
Üzerinde çalıştırılan verileri temsil eden bir dizi tf.Tensor nesnesi.
Aşağıdaki şekilde gösterildiği gibi, burada hesaplama akış grafiğinin nasıl çalıştığını göstermek için basit bir örnek kullanıyoruz.
Şekilde x = ve y = olduğunu varsayalım. Tf.Tensor işlem verilerini temsil etmek için kullanıldığından, TensorFlow'da verileri depolamak için önce iki tf.Tensor sabit nesnesi tanımlayacağız. Ardından, grafikte toplama işlemini tanımlamak için tf.Operation nesnesini kullanın. Spesifik kod aşağıdaki gibidir:
tensorflow'u tf olarak içe aktar
x = tf.constant ()
y = tf.constant ()
op = tf.add (x, y)
Artık veri akış grafiğinin iki önemli öğesini tanımladığımıza göre: tf.Operation ve tf.Tensor, grafiğin kendisinin nasıl oluşturulacağı, özel kod aşağıdaki gibidir:
tensorflow'u tf olarak içe aktar
my_graph = tf.Graph
my_graph.as_default ile:
x = tf.constant ()
y = tf.constant ()
op = tf.add (x, y)
Şimdiye kadar veri akış grafiğinin tanımını tamamladık.TensorFlow'da, yalnızca grafik önce tanımlanır, sonraki hesaplama işlemleri (yani, verileri grafiğin düğümleri arasında yönlü olarak akmasını sağlar). Burada TensorFlow ayrıca sonraki hesaplamaları gerçekleştirmek için tf.Session aracılığıyla tek tip olarak yönetilmesi gerektiğini şart koşar, bu yüzden bir oturum olan bir tf.Session nesnesi de tanımlamamız gerekir.
TensorFlow'da, tf.Session özellikle tf.Operation'ın tf.Tensor temelinde yürüttüğü işletim ortamını kapsüllemek için kullanılır. Bu nedenle, tf.Session nesnesini tanımlarken, ilgili veri akış grafiğini de iletmeniz gerekir (bu grafik parametresinden geçirilebilir) Bu örnekteki özel kod aşağıdaki gibidir:
tensorflow'u tf olarak içe aktar
my_graph = tf.Graph
tf.Session (grafik = my_graph) oturum olarak:
x = tf.constant ()
y = tf.constant ()
op = tf.add (x, y)
Tf.Session'ı tanımladıktan sonra, ilgili veri akış grafiğini tf.Session.run metodu ile çalıştırabiliriz. Run yöntemi, karşılık gelen tf.Operation nesnesini fetches parametresi aracılığıyla iletebilir ve tf.Operation ile ilgili tüm tf.Tensor nesnelerini içe aktarabilir ve ardından geçerli tf.Operation'a bağlı tüm işlemleri yinelemeli olarak yürütebilir. Bu örnekte, toplama işlemi özel olarak gerçekleştirilir ve uygulama kodu aşağıdaki gibidir:
tensorflow'u tf olarak içe aktar
my_graph = tf.Graph
tf.Session (grafik = my_graph) oturum olarak:
x = tf.constant ()
y = tf.constant ()
op = tf.add (x, y)
sonuç = sess.run (getirmeler = op)
baskı (sonuç)
> > >
Operasyonun sonucunun olduğunu görebilirsiniz.
Tahmine dayalı modeller hakkında
TensorFlow'un temel ilkelerini anladıktan sonra, aşağıdaki görev tahmine dayalı bir modelin nasıl oluşturulacağıdır. Basitçe söylemek gerekirse, makine öğrenimi algoritması + verileri tahmine dayalı modele eşittir. Tahmine dayalı bir model oluşturma süreci aşağıdaki şekilde gösterilmektedir:
Şekilde gösterildiği gibi, veriler üzerinde eğitilen makine öğrenme algoritması modeldir. Bir modeli eğittikten sonra, karşılık gelen tahmin sonuçlarını almak için tahmin edilecek verileri girin. Genel süreç aşağıdaki şekilde gösterilmektedir:
Bu örnekte, oluşturacağımız modelin girdi metnine göre karşılık gelen kategorileri çıkarması, yani metin sınıflandırma çalışmasını tamamlaması gerekir. Bu nedenle, buradaki girdi metin olmalı ve çıktı kategori olmalıdır. Daha spesifik olarak, bu örnekte, etiketlenmiş verileri önceden elde ettik (yani, kategorilerle işaretlenmiş bazı metin bölümleri) ve ardından bu verileri algoritmayı eğitmek için kullandık ve son olarak yeni metni sınıflandırmak için eğitimli modeli kullandık. Bu süreç genellikle denetimli öğrenme olarak adlandırılır. Ayrıca görevimiz metin verilerini sınıflandırmak olduğu için sınıflandırma problemleri kategorisine de girmektedir.
Metin sınıflandırma modelini oluşturmak için, bazı temel sinir ağları bilgisine ihtiyacımız var.
Sinir ağları hakkında
Özünde, bir sinir ağı bir tür hesaplama modelidir. (Not: Buradaki sözde hesaplama modeli, sistemi matematiksel dil ve matematiksel kavramlar aracılığıyla tanımlama yöntemini ifade eder) Ve bu hesaplama modeli ayrıca öğrenmeyi ve eğitimi hassas programlama olmadan otomatik olarak tamamlayabilir.
En ilkel ve temel sinir ağı algoritma modeli, Perceptron modelidir (Perceptron). Algılayıcı modeline ayrıntılı bir giriş için lütfen şu bloga bakın:
Sinir ağı modeli insan beyninin ve sinir sisteminin organizasyon yapısını simüle etmek için önerildiğinden, insan beyni sinir ağına benzer bir yapıya sahiptir.
Yukarıdaki şekilde gösterildiği gibi, genel sinir ağı yapısı üç katmana ayrılabilir: giriş katmanı, gizli katman ve çıktı katmanı.
Sinir ağının nasıl çalıştığını anlamak için, TensorFlow'u kullanarak kendi kendimize bir sinir ağı modeli oluşturmamız gerekiyor. İşte özel bir örnek. (Bu örnekteki içeriğin bir kısmı GitHub'daki bir açık kaynak kod parçasından gelmektedir: link)
Bu örnekte, iki gizli katmanımız var (gizli katman sayısının seçimi başka bir konudur, daha ayrıntılı içerik şunlara başvurabilir: bağlantı). Özetle, gizli katmanın ana işlevi, girdi katmanının verilerini çıktı katmanının daha kullanışlı bir biçimine dönüştürmektir.
Şekilde gösterildiği gibi, bu örnekte, giriş katmanının her bir düğümü, giriş metnindeki bir kelimeyi ve ardından ilk gizli katmanı temsil eder. Burada, ilk gizli katmandaki düğüm sayısının seçilmesinin de genellikle özellik seçimi olarak adlandırılan önemli bir görev olduğu belirtilmelidir.
Grafikteki her düğüm (nöron olarak da adlandırılır) bir ağırlık ile ilişkilendirilecektir. Aşağıdaki sözde eğitim süreci, aslında modelin gerçek çıktısının beklenen çıktıyla daha fazla eşleşmesini sağlamak için bu ağırlık değerlerini sürekli olarak ayarlama sürecidir. Elbette ağırlığa ek olarak tüm ağa bir önyargı değeri eklenmelidir. (Sapmanın ayrıntılı açıklaması için bkz: bağlantı)
Her düğüm ağırlıklandırıldıktan ve bir sapma değeri eklendikten sonra, bir sonraki katmana çıkarılmadan önce etkinleştirme işlevi tarafından işlenmesi gerekir. Aslında, buradaki aktivasyon işlevi her bir düğümün nihai çıktısını belirler ve tüm modele doğrusal olmayan öğeler ekler. Metafor olarak bir masa lambası kullanırsanız, etkinleştirme işlevi bir anahtara eşdeğerdir. Gerçek araştırmada, uygulamanın spesifik senaryolarına ve özelliklerine göre seçilebilecek çeşitli aktivasyon fonksiyonları vardır.Burada ReLu fonksiyonu koruma katmanı olarak seçilir.
Ek olarak, şekil aynı zamanda ikinci gizli katmanı da göstermektedir.İşlevi esasen birinci katmandan farklı değildir.Tek fark, girdisinin birinci katmanın çıktısı olması ve birinci katmanın girdisinin orijinal veriler olmasıdır.
Son olarak, çıktı katmanı Bu örnekte, sonuçları sınıflandırmak için tek sıcak kodlama kullanılmıştır. Buradaki sözde tek sıcak kodlama, her vektördeki yalnızca bir öğenin 1 ve diğerlerinin 0 olduğu bir kodlama yöntemini ifade eder. Örneğin, metin verilerini üç kategoriye (spor, havacılık ve bilgisayar grafikleri) ayırmak istiyorsak, kodlama sonucu:
Buradaki tek sıcak kodlamanın avantajı, çıktı düğümlerinin sayısının çıktı kategorilerinin sayısına tam olarak eşit olmasıdır. Ek olarak, çıktı katmanı önceki gizli katman yapısına benzer.Ayrıca her düğüm için bir ağırlık değeri eşleştirmemiz, uygun bir sapma eklememiz ve son olarak aktivasyon fonksiyonunu geçmemiz gerekiyor.
Bununla birlikte, bu örnekteki çıktı katmanının aktivasyon fonksiyonu, gizli katmanın aktivasyon fonksiyonundan farklıdır. Çünkü bu örneğin nihai amacı, her bir metne karşılık gelen kategori bilgisini çıkarmaktır ve burada tüm kategoriler birbirini dışlar. Bu özelliklere dayanarak, çıktı katmanında aktivasyon işlevi olarak Softmax işlevini seçtik. Bu fonksiyonun özelliği, çıktı değerinin 0-1 arasında bir ondalık değere dönüştürülebilmesi ve bu ondalık değerlerin toplamının 1 olmasıdır. Yani her kategorinin olasılık dağılımını temsil etmek için sadece bu ondalık sayılar kullanılabilir. Az önce bahsedilen üç kategorinin orijinal çıktı değerleri 1.2, 0.9 ve 0.4 ise, Softmax fonksiyonu ile işlendikten sonra elde edilen sonuç şu şekildedir:
Bu üç ondalık sayının toplamının tam olarak 1 olduğunu görebilirsiniz.
Şimdiye kadar, sinir ağının veri akış diyagramını açıklığa kavuşturduk.Aşağıda spesifik kod uygulaması verilmiştir:
# Ağ Parametreleri
n_hidden_1 = 10 # 1. katman özellik sayısı
n_hidden_2 = 5 # 2. katman özellik sayısı
n_input = total_words # Kelime içindeki kelime
n_classes = 3 # Kategoriler: grafikler, uzay ve beyzbol
def multilayer_perceptron ( input_tensor, ağırlıklar, önyargılar ):
layer_1_multiplication = tf.matmul (input_tensor, ağırlıklar)
layer_1_addition = tf.add (layer_1_multiplication, önyargılar)
layer_1_activation = tf.nn.relu (layer_1_addition)
# RELU aktivasyonlu gizli katman
layer_2_multiplication = tf.matmul (layer_1_activation, ağırlıklar)
layer_2_addition = tf.add (layer_2_multiplication, önyargılar)
layer_2_activation = tf.nn.relu (layer_2_addition)
# Doğrusal aktivasyonlu çıktı katmanı
out_layer_multiplication = tf.matmul (layer_2_activation, ağırlıklar)
out_layer_addition = out_layer_multiplication + önyargılar
return_layer_addition
Sinir ağı eğitimi
Daha önce bahsedildiği gibi, model eğitiminde çok önemli bir görev, düğümlerin ağırlıklarını ayarlamaktır. Bu bölümde, bu sürecin TensorFlow'da nasıl uygulanacağını tanıtacağız.
TensorFlow'da düğüm ağırlıkları ve önyargı değerleri, değişkenler, yani tf.Variable nesneler şeklinde saklanır. Veri akış grafiği çalıştırma işlevini çağırdığında, bu değerler değişmeden kalacaktır. Genel bir makine öğrenimi senaryosunda, ağırlık değerinin başlangıç değerleri ve sapma değeri, normal dağılımla belirlenir. Özel kod aşağıda gösterilmiştir:
ağırlıklar = {
'h1': tf.Variable (tf.random_normal ()),
'h2': tf.Variable (tf.random_normal ()),
'out': tf.Variable (tf.random_normal ())
}
önyargılar = {
'b1': tf.Variable (tf.random_normal ()),
'b2': tf.Variable (tf.random_normal ()),
'out': tf.Variable (tf.random_normal ())
}
Sinir ağını başlangıç değeriyle çalıştırdıktan sonra, gerçek bir çıktı değeri z elde edilecek ve beklenen çıktı değerimiz bekleniyor.Bu anda yapmamız gereken, ikisi arasındaki hatayı hesaplamak ve ağırlığı ve diğer parametreleri ayarlayarak en aza indirmek. . Genellikle hatayı hesaplamanın birçok yolu vardır.Burada, sınıflandırma problemi ile uğraştığımız için çapraz entropi hatası kullanılır. (Sınıflandırma problemleri için çapraz entropinin neden kullanıldığı hakkında, bakınız: Bağlantı)
TensorFlow'da, tf.nn.softmax_cross_entropy_with_logits işlevini çağırarak çapraz entropi hatasını hesaplayabiliriz, çünkü buradaki etkinleştirme işlevimiz Softmax'ı seçer, böylece softmax_ öneki hata işlevinde görünür. Spesifik kod aşağıdaki gibidir (kodda ortalama hatayı hesaplamak için tf.reduced_mean () işlevini de çağırıyoruz):
# Modeli oluştur
tahmin = multilayer_perceptron (input_tensor, ağırlıklar, önyargılar)
# Kaybı tanımla
entropy_loss = tf.nn.softmax_cross_entropy_with_logits (logits = tahmin, etiketler = output_tensor)
kayıp = tf.reduce_mean (entropy_loss)
Hatayı aldıktan sonra, aşağıdaki görev nasıl en aza indirileceğidir. Burada seçtiğimiz yöntem, en yaygın kullanılan stokastik gradyan iniş yöntemidir ve sezgisel şematik diyagramı aşağıdaki gibidir:
Benzer şekilde, gradyan inişini hesaplamak için kullanılan birçok yöntem vardır.Burada, uyarlamalı moment tahmininin optimizasyon yöntemi olan Uyarlanabilir Moment Tahmin (Adam) optimizasyon yöntemini kullanıyoruz.TensorFlow'daki özel düzenleme, tf.train.AdamOptimizer'dır (learning_rate). minimize (kayıp) işlevi. Burada gradyan hesaplanırken adım uzunluğunu belirlemek için learning_rate parametresini geçmemiz gerekir.
Çok uygun bir nokta, AdamOptimizer işlevinin iki işlevi sarmalamasıdır: biri gradyanı hesaplamak, diğeri de gradyanı güncellemektir. Başka bir deyişle, bu işlevi çağırmak yalnızca gradyan değerini hesaplamakla kalmaz, aynı zamanda hesaplama sonucunu tüm tf.Variables nesnelerine güncelleyerek programlama karmaşıklığını büyük ölçüde azaltır.
Spesifik model eğitim bölümünün kodu aşağıdaki gibidir:
learning_rate = 0.001
# Modeli oluştur
tahmin = multilayer_perceptron (input_tensor, ağırlıklar, önyargılar)
# Kaybı tanımla
entropy_loss = tf.nn.softmax_cross_entropy_with_logits (logits = tahmin, etiketler = output_tensor)
kayıp = tf.reduce_mean (entropy_loss)
optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (kayıp)
veri işleme
Bu örnekte, elde ettiğimiz orijinal veriler birçok İngilizce metin parçasıdır.Bu verileri modele aktarmak için orijinal veriler üzerinde gerekli ön işlemleri yapmamız gerekir. Özellikle iki bölüm var:
Her kelimeyi kodlayın;
Her metin parçası için karşılık gelen bir tensör temsili oluşturun; burada 1 sayısı belirli bir kelimeyi temsil eder ve 0 böyle bir kelimeyi temsil etmez.
Spesifik uygulama kodu aşağıdaki gibidir:
numpy olarak np #numpy, bilimsel bilgi işlem için bir pakettir
koleksiyonlardan ithalat Sayacı
kelime = Sayaç
text = "Brezilya'dan Merhaba"
# Tüm kelimeleri al
text.split ('') içindeki kelime için:
kelime + = 1
# Kelimeleri dizinlere dönüştürün
def get_word_2_index (kelime):
word2index = {}
i için, numaralandırılan kelime (kelime):
word2index = i
word2index döndür
# Şimdi bir dizinimiz var
word2index = get_word_2_index (kelime)
total_words = len (kelime)
# Bu, bir numpy dizisini (matrisimizi) nasıl oluşturduğumuzdur
matrix = np.zeros ((toplam_sözlük), dtype = float)
# Şimdi değerleri dolduruyoruz
text.split içindeki kelime için:
matris + = 1
baskı (matris)
> > >
Yukarıdaki koddan da görülebileceği gibi, giriş metni "Brezilya'dan Merhaba" olduğunda, çıktı matrisi şeklindedir. Ve yalnızca giriş metni "Merhaba" olduğunda, belirli kod ve sonuçlar aşağıdaki gibidir:
matrix = np.zeros ((toplam_sözlük), dtype = float)
text = "Merhaba"
text.split içindeki kelime için:
matris + = 1
baskı (matris)
> > >
Gördüğünüz gibi, şu andaki çıktı .
Buna uygun olarak, kategori bilgilerini de kodlayabiliriz, ancak bu sefer tek sıcak kodlama kullanıyoruz:
y = np.zeros ((3), dtype = float)
kategori == 0 ise:
y = 1. #
elif kategorisi == 1:
y = 1. #
Başka:
y = 1. #
Modeli çalıştırın ve tahmin edin
Şimdiye kadar TensorFlow, sinir ağı modelleri, model eğitimi ve veri ön işleme hakkında bir ön anlayışa sahibiz. Aşağıda bu bilgiyi gerçek verilere nasıl uygulayacağımızı göstereceğiz.
Burada veri kaynağımız, 18.000 basın bültenini içeren, 20 kategoriyi kapsayan, açık kaynaklı ve ücretsiz 20 Haber Grubu ve indirme adresi:
Öncelikle, bu veri setlerini içe aktarmak için scikit-learn kütüphanesini kullanmamız gerekiyor. Ayrıca, Python diline dayalı, özellikle makine öğrenimi ile ilgili veri işleme görevleri için açık kaynaklı bir işlev kitaplığıdır. Bu örnekte, yalnızca üç tanesini kullandık: comp.graphics, sci.space ve rec.sport.baseball.
Nihai veriler, biri veri eğitim seti ve diğeri test seti olmak üzere iki alt gruba ayrılacaktır. Buradaki tavsiye, test verilerini önceden kontrol etmemek en iyisidir. Test verilerini önceden görüntülemek, model parametreleri seçimimizi etkileyeceğinden, modelin çok yönlülüğünü bilinmeyen diğer verilere göre etkileyecektir.
Belirli veri içe aktarma kodu aşağıdaki gibidir:
sklearn.datasets'den fetch_20newsgroups içe aktar
kategoriler =
newsgroups_train = fetch_20newsgroups (alt küme = 'tren', kategoriler = kategoriler)
habergrupları_test = fetch_20newsgroups (alt küme = 'test', kategoriler = kategoriler)
Sinir ağı terimlerinde, bir çağ süreci, bir ileri geçişin tam bir döngüsü artı tüm eğitim verileri için bir geri geçiştir. Burada ileri, mevcut ağırlığa göre gerçek çıktı değerini elde etme sürecini ve geriye doğru ise, hata sonucuna göre sırayla ağırlığı ayarlama işlemini ifade eder. Aşağıda tf.Session.run işlevine odaklanıyoruz, aslında tam çağrı formu aşağıdaki gibidir:
tf.Session.run (getirmeler, feed_dict = Yok, seçenekler = Yok, run_metadata = Yok)
Makalenin başında bu işlevi tanıtırken, toplama işlemini yalnızca getirme parametresi üzerinden geçtik, ancak aslında aynı anda birden fazla işlemi geçirmeyi de destekliyor. Gerçek veriler için model eğitim bağlantısında, iki işlem tanıttık: biri hata hesaplaması (yani stokastik gradyan inişi) ve diğeri bir optimizasyon fonksiyonudur (yani uyarlamalı moment tahmini).
Run fonksiyonundaki bir diğer önemli parametre de feed_dict'dir. Model tarafından işlenen girdi verilerini her seferinde bu parametre üzerinden geçiririz. Veri girmek için önce tf.placeholders'ı tanımlamalıyız.
Resmi belgenin açıklamasına göre, buradaki yer tutucu, modele aktarılacak verilere atıfta bulunmak için kullanılan bir Airbus'tır, başlatılmasına veya gerçek verilerin depolanmasına gerek yoktur. Bu örnekte tf.placeholders'ı tanımlayan kod aşağıdaki gibidir:
n_input = total_words # Kelime içindeki kelime
n_classes = 3 # Kategoriler: grafikler, sci.space ve beyzbol
input_tensor = tf.placeholder (tf.float32, name = "input")
output_tensor = tf.placeholder (tf.float32, name = "output")
Gerçek model eğitiminden önce, verilerin gruplara bölünmesi gerekir, yani bir seferde işlenen veri miktarı hesaplanır. Şu anda, önceki tf.placeholders tanımının faydaları yansıtılır, yani değişken boyutlara sahip bir toplu iş, yer tutucu tanımındaki "Yok" parametresi aracılığıyla belirtilebilir. Başka bir deyişle, partinin belirli boyutu daha sonra kullanıldığında belirlenebilir. Burada model eğitim aşamasında daha büyük bir grup halinde geçiyoruz ve test aşamasında bazı değişiklikler yapılabilir, bu nedenle değişken parti kullanmamız gerekiyor. Eğitimin ilerleyen bölümlerinde, her seferinde işlenen gerçek metin verilerini almak için get_batches işlevini kullanıyoruz. Spesifik model eğitim bölümünün kodu aşağıdaki gibidir:
training_epochs = 10
# Grafiği başlatın
tf.Session olarak oturum:
sess.run (init) # değişkenleri doldurur (normal dağılım, hatırlıyor musun?)
# Eğitim döngüsü
aralıktaki dönem için (eğitim_epoları):
avg_cost = 0.
total_batch = int (len (habergrupları_train.data) / batch_size)
# Tüm gruplar üzerinde döngü
aralıktaki i için (toplam_batch):
batch_x, batch_y = get_batch (haber grupları_train, i, batch_size)
# Optimizasyon işlemini (backprop) ve maliyet işlemini (kayıp değeri elde etmek için) çalıştırın
c, _ = sess.run (, feed_dict = {input_tensor: batch_x, output_tensor: batch_y})
Şimdiye kadar gerçek veriler için model eğitimini tamamladık ve şimdi modeli test verileriyle test etme zamanı. Test sürecinde, önceki eğitim bölümüne benzer şekilde, işlemler ve veriler dahil olmak üzere grafik öğelerini de tanımlamamız gerekiyor. Modelin doğruluğunu hesaplamak için ve sonuca tek sıcak kodlama eklediğimiz için, aynı anda doğru çıktının dizinini ve tahmin edilen çıktının dizinini almalı ve eşit olup olmadıklarını kontrol etmeliyiz, değilse, karşılık gelen ortalama hatayı hesaplamalıyız. . Spesifik uygulama kodu ve sonuçları aşağıdaki gibidir:
# Test modeli
index_prediction = tf.argmax (tahmin, 1)
index_correct = tf.argmax (output_tensor; 1)
right_prediction = tf.equal (index_prediction, index_correct)
# Doğruluğu hesaplayın
doğruluk = tf.reduce_mean (tf.cast (right_prediction, "float"))
total_test_data = len (newsgroups_test.target)
batch_x_test, batch_y_test = get_batch (habergrupları_test, 0, toplam_test_data)
print ("Doğruluk:", doğruluk.eval ({input_tensor: batch_x_test, output_tensor: batch_y_test}))
> > > Dönem: 0001 kayıp = 1133.908114347
Dönem: 0002 kayıp = 329.093700409
Dönem: 0003 kayıp = 111.876660109
Dönem: 0004 kayıp = 72.552971845
Dönem: 0005 kayıp = 16.673050320
Dönem: 0006 kayıp = 16.481995190
Dönem: 0007 kayıp = 4.848220565
Dönem: 0008 kayıp = 0,759822878
Epoch: 0009 kayıp = 0.000000000
Dönem: 0010 kayıp = 0,079848485
Optimizasyon Tamamlandı!
Doğruluk: 0.75
Sonunda, modelimizin% 75'lik bir tahmin doğruluğuna sahip olduğunu görebiliriz ki bu, yeni başlayanlar için iyidir. Şimdiye kadar, TensorFlow aracılığıyla bir sinir ağı modeline dayalı bir metin sınıflandırma görevi uyguladık.
Kaynak: ortam, Leifeng.com tarafından derlenmiştir
