Abstractive Methods
Abstractive metin özetleme teknikleri verilen bir dataset üzerinde eğitildikten sonra verilen ilk kelimeden sonra ki kelimeyi tahmin ederek cümle üretilmesine dayanan tekniklerdir. Cümle üretimi için seq2seq modellemesi geliştiriyor olacağız. Seq2Seq mimarisi daha önce de değinildiği gibi Encoder ve Decoder yapılarından oluşuyor. Encoder’a giriş değeri veriliyor sonrasında Encoder bir Context Vektorü oluşturuyor. Context Vectorü Decoder’a “initial state” olarak veriliyor. Training aşamasında Decoder’a datasetimizdeki gerçek özet verilerini veriyoruz. Sonrasında Decoder, Encoder’a verilen metnin özetini çıktı olarak oluşturuyor.
Seq2Seq Architecture
Encoder’ın yapısını incelersek, input olarak özeti çıkarılacak olan metni veriyoruz. Metin üzerinde işlem yapılabilmesi için verilen metne tokenizing işlemi uygulamamız gerekiyor. Tokenize işleminden sonra kelimeler sayısal değerlere çeviriliyor. Embedding Layer‘ında tokenize işleminden geçen her bir kelime için bir kelime vektörü bulunuyor. Embedding Matrisi için Glove kullanıldı. Embedding Matrisinde ki girişimizdeki kelimelere karşılık gelen vektörleri RNN ünitelerine input olarak veriyoruz. RNN olarak GRU yapısı kullanıldı. Ayrıca Seq2Seq içinde 3 layerdan oluşan RNN yapıları kullanıldı. RNN ünitelerine başlangıç değeri olarak 0 veriyoruz. İlk zaman adımında bu koşullarda başlamış oluyor. RNN üniteleri her zaman adımında verilerle karşılaştıkça hidden statelerini güncelliyor. Encoder da hesaplama bittiğinde bir Context vektörü oluşturuluyor. Dekoder’ın yapısıda Encoder’la benzer şekilde başlangıç durumu olarak Encoder’dan Context vektörü alınıyor. Input olarak ise metne başlarken bir başlangıç tokenı ve cümle bitirilirken bitiş tokenı veriliyor. Başlangıç ve bitiş tokenları sayesinde modelimiz cümleye başlaması gerektiğini aynı şekilde bitirmesi gerektiğini öğrenmiş oluyor.
Başlangıç ve bitiş tokenlarını biz belirliyoruz. Bu seçimi yaparken bu tokenların Embedding Matrisi içerisinde bulunmayacak kelimelerden seçmemiz gerekir. Bu şekilde seçilmediğinde eğitim düzgün bir şekilde gerçekleşmiyor ve hataya sebep olabiliyor. Decoder’a verilmesi gereken başlangıç tokeninin embedding matrisi içerisinde bir vektörü bulunuyor diğer kelimelerde olduğu gibi. Başlangıç tokenindeki kelime vektörünü Encoderdan alınan Context vektörünü RNN layerlarına veriyoruz. Modelimiz aldığı bu bilgilere göre bir kelime üretiyor. Amacımız modelimizin doğru kelimeleri seçerek özet çıkarması. Encoder eğitim ve test aşamalarında aynı şekilde çalışıyor fakat Decoder’a test aşamasında gerçek özet textler veriliyor. Output olarak decoder ne üretirse üretsin doğru kelimeyi veriyoruz. Bu şekilde eğitiliyor. Test aşamasında ise modele sadece başlangıç tokeni ve encoderdan gelen context vektörü veriliyor ilerleyen zaman adımlarında üretilen kelimeyi tekrar input olarak vererek doğru kelimeleri tahmin edebilmesini bekliyoruz.
Tokenizing
Tokenleştirme işlemi Keras kütüphanesinde bulunan Tokenizer objesi tanımlanarak ile yapılıyor. Tokenizer fonksiyonunda num_words parametresini kullanmazsak datasetinde ki tüm kelimeler kullanılır. Tokenizer sınıfında ki fit_on_texts fonksiyonunu kullanarak metinlerimizi tokenizer’a yüklemiş oluyoruz. texts_to_sequences fonksiyonuyla tokenizera verdiğimiz her kelime için bir sayı üretiliyor. Rnn ünitelerine verilen inputlar aynı boyutta olmak zorunda olduğundan farklı uzunluklarda olan cümleleri aynı uzunluğa getirmemiz gerekiyor. Elimizdeki token listesinin ortalamasını ve standart sapmasını alarak bir uzunluk belirliyoruz. Cümleler belirlediğimiz uzunluktan kısa veya uzun olabilir. Cümleler belirlediğimiz uzunluktan kısa ise aynı boyuta getirebilmek için cümleye sıfır ekliyoruz. Bu işleme padding deniyor. Cümlenin başına padding eklersek prepadding sonuna padding eklersek ise postpadding ismi veriliyor. Encoder için prepadding Decoder için postpadding uyguluyoruz. Belirlediğimiz input boyutunu aşan bir cümle olduğunda ise fazla olan kısmı kesiyoruz. Bu işleme truncating deniyor. Cümlenin başından kelimeleri kesilirse pretruncating sonunda ki kelimeler kesilirse posttruncating deniyor. Bu işlem data kaybına sebep olabiliyor. Cümlenin ilk kısmı son kısmına göre daha önemlidir. Cümledeki ilk kelimelerin kesilmesini önlemek için cümleyi ters çeviriyoruz. Bu işlemin başka bir avantajı Encoder cümlenin başını en son gördüğü için Context vectorine daha başarılı yansıtabiliyor. Decoder da cümle üretmeye ilk kelimeden başlayacağı için daha tutarlı işlem yapılabiliyor. Reversed fonksiyonuyla cümleleri tersine çevirme işlemi uygulayabiliyoruz. Padding işlemi pad_sequences fonksiyonuyla yapılıyor. Pad_sequences fonksiyonuna tokenlarımızı belirlediğimiz maximum token lengthini, padding işleminin prepadding veya postpadding işlemi mi olduğunu, truncating işleminin pretruncating veya posttruncating olduğunu parametre olarak veriyoruz.Pad_sequences fonksiyonundan dönen değeri ise tokens_padded propertysine assign etmemiz gerekiyor.
Aşağıda prepadding uygulanmış bir cümle örneği görülüyor.
Verilen metne düzgün bir şekilde tokenizing uygulandığını anlayabilmek için tokens_to_word ve tokens_to_string fonksiyonları yazıldı. Tokens_to_word fonksiyonunda parametre olarak token alınıyor. Parametre olarak alınan token index_to_word sözlüğünden kelimeyi buluyor ve bu kelimeyi döndürüyor. Tokens_to_string fonksiyonu ise verilen tokenlardan cümle oluşturuyor. Parametre olarak alınan kelimere karşılık gelen kelimeyi sözlükten buluyor (değeri 0 olan tokenlar hariç),sonrasında bulunan kelimelerden bir liste oluşturuyor. Listedeki elamanlar birleştirilip bir string olarak bir cümle döndürülüyor. Text_to_tokens fonksiyonunu ise model eğitildikten sonra modele text vererek denemek için kullanıyoruz. Fonksiyon verilen meni tokenlara dönüştürmekte.
Text_to_tokens fonksiyonu parametre olarak tokenizer nesnesi text padding türü, cümlenin ters çevrilmesi ilgili boolean değer olarak reverse parametresini alıyor. Alınan text text_to_sequences fonksiyonuyla tokenlara dönüştürülüyor. Tokenlar numpy array çevirilerek reverse parametresindeki seçime göre ters çevirebiliyor. Ters çevirme işlemi numpy kütüphanesinin flip metodu kullanılıyor. Flip metodundaki axis parametresi 1 olmasıyla satırların ters çevrilmesini istediğimizi bildiriyoruz. Eğer ilgili parametreye 0 verilseydi sutunlar üzerinde işlem yapılacaktı. Reverse parametresinin seçimine göre truncating post veya pre olduğunu atıyoruz. Ardından pad_sequences fonksiyonuyla padding işlemini tokenlara uyguluyoruz.
Encoder – Decoder Input ve Output
Seq2Seq metin özetleme mimarisini hatırlarsak, encoder’a input olarak özetlenecek metinler veriliyor. Encoder statelerden oluşan bir context vectorü üretiyor ve bu vector decodere aktarılıyor. Context vectorü decoder için başlangıç durumunu oluşturuyor. Decoder context vectorüyle birlikte başlangıç tokeni alıyor,bu iki inputu kullanarak sonraki gelmesi gereken kelimeyi tahmin etmeye çalışıyor. Decodere eğtim aşamasında olması gereken gerçek özet textindeki kelimeyi verdiğimiz için gerçek değerlere bakılıp tahmin edilen yanlışsa bitiş tokenine kadar optimize edilerek güncelleniyor. Bu durumda decodere verilen input ve output aynı oluyor. Input ile output arasında ki tek fark, input outputun bir kaydırılmış bir hali olmasıdır. Böylelikle text başlangıç tokeni olmadan output olarak verilmiş oluyor.Tokenizer sınıfının tokens_to_string fonksiyonunu kullanarak tokenleri stringe dönüştürerek input ve output metinleri kontrol edebiliriz.
Cümleler üzerinden decoder’e verilen input ve output’ları değerlendirirsek, eğitim esnasında decoder’a encoder’ın ürettiği context vectorünü ve başlangıç tokeni olan ssstarttokenı veriyoruz. Decoder aldığı başlangıç koşullarına göre bir kelime üretiyor. Beklentimiz Bosch kelimesini üretmesi yada şirket, marka gibi yakın kelimeler kullanması. Sonraki zaman adımında bosch kelimesi input olarak sisteme veriliyor. Beklentimiz output olarak makes kelimesini üretiyor olması. Bu şekilde bitiş tokenı olan eeendtokenına kadar devam ediliyor. Her zaman adımında bir loss değeri hesaplanıp gerçekte olması gereken değerle karşılaştırıldıktan sonra optimize edilecek.
Word Embedding
Metin Özetleme uygulamasında kelime vektörleri için GloVe kullanıldı. Standford üniversitesi tarafından eğitilen glove kelime vektörleri 400000 kelime ve bu kelimelere karşılık gelen vektörleri barındırıyor. Glove da bulunan 400000 kelimenin hepsini kullanmak yerine kelime haznemizde bulunan kelimelere karşılık gelen vektörleri glovedan alıyoruz. Kelime haznemizde 98137 tane metin ve 43661 tane metin özeti bulunuyor. Kelime haznemizdeki kelime bulunan kelimelerde bulunmayabilir bu sebeple embedding matrisini rastgele değerlerle oluşturuyoruz. Eğer glove vektörleri içerisinde kelime haznemizdeki bir kelime bulunuyorsa glovedaki ilgili vektörü kendi embedding matrisimize transfer ediyoruz. Böylelikle embedding matrisinin büyük çoğunluğu daha önce eğiltilmiş olan glove vektörlerinden oluşuyor. Embedding matrisimizin boyutu Glove kelime vektörlerinin boyutuyla aynı olmalı. Bu yüzden embedding size olarak 100 verildi. Word2vec oluşturduğumuz boş sözlüğün ismini belirtiyor. Glove vektörlerini txt dosyasından okumamız gerekiyor. Glove dosyasının ismi glove.6B.100d.txt dosya ismindeki 6B 6 milyar token üzrinde eğiltildiğini 100d ise kelime vektörlerinin boyutunu gösteriyor. Python dosya okuma yöntemlerini kullanarak dosyayı okuyoruz. Dosyada her bir satırda bir kelime ve bu kelimelere karşılık gelen vektörler bulunuyor. Glove içeriğini word2vec sözlüğüne aktarmak için her satırda döngü ile dolaşarak kelimeyi ve kelimelerin değerleri olan vektörleri alıyoruz.
word2vec[word] = vec şeklinde belirterek sözlüğe anahtar olarak kelimeleri değer olarak ise ilgili kelimenin vektörlerini yazdırıyoruz. Sonuç olarak 400000 elemandan oluşan bir sözlük elde ediyoruz. Sonrasında rastgele değerlerle bir embedding matrisi oluşturmamız gerekiyor. Buradaki amacımız kelime haznesinde ki kelimelere karşılık gelen glove vektörlerini kendi embedding matrisimize aktarabilmek. Rastgele değerler oluşturabilmek için numpy kütüphanesinin random fonksiyonunu kullanıyoruz. Rastgele atayacağımız değerler –1 ve 1 arasında olacak. Bu kısım seçime göre değişebilir. Embedding matris boyutunu ise kelime sayısına ve vektörlerin boyutuna göre belirliyoruz.Kelime haznesindeki kelimelerle glovedan elde edilen kelimeleri eşleştirebilmek için döngü oluşturuyoruz. Eğer kelime haznesindeki bir kelime word2vec glove sözlüğündeki bir kelime ile eşleşiyorsa Embedding matrisindeki rastgele sayılarla atanmış vektörün yerine word2vec sözlüğünde ki ilgili vektörler değiştirilecek. Eğer kelime haznemizdeki kelime glove vektörleri arasında yoksa rastgele oluşturulmuş sayılarla kalacak. Oluşturulan embedding matrisinin boyutunu shape propertysi ile görebiliyoruz.
Encoder
Modeli oluşturmaya encoderi oluşturarak başlıyoruz. Encoder için öncellikle input layer tanımlıyoruz.
Input objesi shape ve name parametreleri alıyor. Shape inputun boyutunu belirliyor. None verildiği için input farklı boyutlarda olabiliyor. Name parametresi ise inputun ismini belirlemek için kullanılıyor. Oluşturulan encoder inputuna tokenleştirilen değerler veriliyor. Ardından encoder için embedding layerını Kerasta Embedding objesini kullanarak tanımlıyoruz.
Embedding objesi parametre olarak input_dim, output_dim,weights,trainable ve name parametrelerini alıyor. Input_dim encodera verilecek toplam kelime sayısı, output_dim parametresine embedding_size veriliyor. Embedding size’ı 100 olacak şekilde belirlemiştik. Weights parametresine oluşturduğumuz embedding matrisini atıyoruz. Bu şekilde kerasa embedding matrisimizi yüklemiş oluyoruz. Trainable parametresine true vererek bu modelin eğitilebilir olduğunu bildirmiş oluyoruz. Glove’ın eğitilmiş kelime vektörlerini kullandığımız için bu parametreye False da verilebilir. Embedding matrisinde glove da bulunamayan kelimeler için rastgele değerler kullanıldığından bu parametreye True verilmesi faydalıdır. Name parametresi ise embedding layerına isim verebilmemizi sağlamakta.
Encoder için RNN tipi olarak GRU kullanıldı. Encoder GRU layerına oluşturmadan önce bir state_size state_size 256 olarak belirliyoruz. State_size parametresini tüm GRU layerlarında kullanıyoruz. Bu parametre sayesinde tüm GRU layerlar 256 boyutlu output üretiyor olacak. Standart GRU üniteleri yerine CuDNNGRU kullanıyoruz. CuDNNGRU CPU yerine GPU da eğitildiği için eğitim süresi daha kısa sürüyor. Encoder için 3 katmanlı GRU layerlardan oluşuyor.
Name parametresiyle gru layerına isim veriyoruz. Return_sequences parametresi ise işlenen sequences bir sonraki GRU ünitesine aktarılmasına izin veriyor. Son GRU ünitesi return_sequences False olarak tanımlandı. Son encoder layerının tek bir output üretmesini istediğimiz için return_sequences parametresini False tanımladık. Encoder bu sayede Context vektörünü oluşturuyor. GRU layerlarının çalışabilmesi için birbirine bağlanması gerekiyor.
Connect_encoder fonksiyonu encoder için tanımlanan GRU layerlarını ve embedding layerını birbirine bağlanmasını sağlıyor. Layerların birbirine bağlanma işlemi input layerının layer değişkenine atanmasıyla başlıyor. Encoder_input atandıktan sonra layer değişkenini encoder_embedding nesnesine geçiriyoruz ve tekrardan layer değişkenine atıyoruz. Benzer şekilde 3 GRU layerınıda layer değişkenine atayarak bağlamış oluyoruz. Son olarak atanan output encoder outputu olarak döndürüyoruz. Fonksiyonu çağırdığımızda decodera vereceğimiz context vectorunu elde etmiş oluyoruz.
Decoder
Decoder daha önce de değinildiği gibi input olarak encoder son gru layerından gelen context vectorunu ve başlangıç kelime tokenı sonrasında gerçek özet tokenlarını alıyor. Öncellikle decoder için bu inputları tanımlamamız gerekiyor.
Encoder state_size boyutunda bir context vectorü üretiyor. Decoder’in initial statelerini alacağı input bu yüzden state_size boyutunda. Encoder inputuna benzer şekilde decoder içinde input tanımlıyoruz. Alacağı vektörün uzunluğunu None yaptığımız için input olarak herhangi bir uzunlukta vektörü kabul edildiğini bildiriyoruz. Encoder için yapılan embedding layerına benzer şekilde decoder içinde embedding layer oluşturuyoruz.
input_dim parametresine decodera verilecek kelime sayısını veriyoruz. Output_dim parametresine embedding_size değişkenini veriyoruz. Embedding_size değişkenini 100 olarak tanımlamıştık. Glove vektörlerini kullandığımız için vektör uzunluğu da Glove ile aynı olmalı bu nedenle 100 olarak belirliyoruz. Name parametresi ile de decoder embedding layerına isim veriyoruz.
Encoder GRU layerlarına benzer şekilde decoder GRU layerlarına da tanımlıyoruz. state_size 256 olarak belirlenmişti. Bir önceki decoder layerından dönen değerler sonraki decoder layerlarına aktarılabilmesi için return_sequences parametresini True yapıyoruz. Encoderdan farklı olarak son decoder layerında return_sequences parametresini de True olarak tanımlıyoruz. Encoder layerında sadece context vektörü döndürülmesini beklediğimiz için False değeri verilmişti. Decoderin çalışması sonucu bir cümle üretmesini beklediğimiz için son layerdaki return_sequences True olarak belirlendi. Decoder son gru layerından 256 uzunluğunda vektörler üretiliyor. Üretilen vektörleri kelimelere dönüştürebilmek için Dense layer oluşturulması gerekiyor. Dense layer gru layerından çıkan vektörleri one hot türünden vektörlere dönüştürüyor.
Dense layerına parametre olarak decodera verilen kelime sayısı veriyoruz. Aktivasyon fonksiyonu olarak linear aktivasyon kulanıldı. Linear aktivasyon fonksiyonu decoder outputunu aynı şekilde işlem yapılmadan aktarmak için kullanılıyor. Dense layer linear aktivasyon fonksiyonunun yerine Softmax gibi farklı aktivasyon fonksiyonları da kullanılabilir. Name dense layerına isim olarak decoder_output parametresi veriliyor. Encoderda da olduğu gibi layerları birbirine bağlayabilmek için connect_decoder isminde bir fonksiyon oluşturuyoruz. Fonksiyon initial_state isminde bir parametre alıyor. Initial_state parametresi encoder da oluşturulan context vectorunu temsil ediyor. Bu parametreyi decoder gru layerlarına veriyoruz. Layerları birbirine bağlama işlemi encoderla benzer şekilde gerçekleşiyor. Öncelikle decoder inputunu, sonrasında embedding layerını bağlıyoruz. Ardından sırasıyla gru layerlarını diğer layerlarla entegre ediyoruz. Değinildiği gibi initial_states parametresini decoder gru layerına parametre olarak gönderiyoruz. Son olarak tanımladığımız dense layerına tanımladığımız tüm layerları bağlıyoruz. Dense layer sonucu dönen değeri ise return ediyoruz. Oluşturulan fonksiyonu çağırarak decoder_output değişkinine aktarıyoruz.
Model Training
Encoder ve decoder layerları tanımlandı. Fakat modelin uçtan uca eğitilebilmesini sağlamak için encoder ve decoder layerlarınıda birbirine bağlayan bir model oluşturmak gerekiyor.
Eğitimde kullanılan modelin yanında test aşamasında kullanılmak üzere iki model daha kullanıyoruz.
Encoder modeli input olarak daha önce tanımladığımız encoder_input alıyor. Output olarakta encoder_output alıyor. Test sırasında encodera özetini çıkarılmasını istediğmiz texti veriyoruz. Output olarak encoder context vektörü döndürecek. Benzer şekilde testte kullanacağımız decoder modelini de oluşturuyoruz. Decoder modeli input olarak liste içerisinde decoder_inputunu ve encoderden gelen context vectorünü decoder_initial_state parametresi olarak alıyor. Decoderden output olarak encodere verilen textin özetini cümle halinde üretmesini bekliyoruz.
Oluşturduğumuz modelin test edebilmemiz için öncelikle bir loss hesaplama fonksiyonu oluşturmamız gerekiyor. Loss hesaplama yöntemi olarak tensorflowun sparse_softmax_cross_entropy_with_logits fonksiyonu kullanıldı. Fonksiyon iki tane parameter almakta, ilk parametre y_true gerçek değerler, ikinci parameter ise y_pred ise tahmin edilen değerler.
Alınan parametreler sparse_softmax_cross_entropy_with_logits fonksiyonuna veriliyor. Fonksiyon eğitim esnasında belirlediğimiz batch uzunluğu kadar loss değeri döndürüyor. Başka bir deyişle modelimizi 128 uzunluğunda batchler halinde eğitiyorsak, verilen inputun loss değerleride 128 adet oluyor. Tek bir loss değeri hesaplayabilmemiz için loss değerlerinin ortalama değerini buluyoruz. Daha sonra bulunan ortalama loss değerini döndürüyoruz.Optimizer olarak RMSprop kullanıldı. RMSprop RNN kullanarak yapılmış uygulamalarda daha iyi sonuç veriyor. RMSpropa alternatif olarak Adam optimizerda kullanılabilir.
Keras compile fonksiyonu kullanılarak modelimizi compile ediyoruz. Daha önce belirlediğimiz gibi eğitim işlemini model_train üzerinde yapılıyor.
Optimizer parametresine daha önce tanımladığımız gibi RMSprop olarak atıyoruz. Loss fonksiyonu olarak sparse_cross_entropy kullanıldı. Tanımladığımız fonksiyonu loss parametresine işaret ediyoruz. Target_tensors parametresine decoder_target isimli int32 tipli bir tensorflow placeholderı assign ediyoruz. Bu şekilde modeli eğitime hazır hale getirmiş oluyoruz. Model eğitim süreleri çok uzun sürdüğü için, modeli kaydetmek isteyebiliriz. Bu durumda ModelCheckpoint nesnesinden yararlanarak modelin weight ve biaslerini diskimizde saklayabiliriz. Bu değerleri kullanarak modeli eğitmeye devam etmek zaman kazandıracaktır.
Model eğitimi için fit fonksiyonu kullanılıyor. Öncesinde fit fonksiyonuna vereceğimiz parametreleri hazırlıyoruz.
x_data ya encoder_inputunu ve decoder_inputunu tanımlıyoruz. Y_data değişkenine ise decoder_outputunu tanıtıyoruz.Fit fonksiyonundaki x parametresine tanımladığımız x_data değişkenini, y parametresine ise tanımladığımız y_data değişkenini atıyoruz. Bilgisayar gücüne göre bir batch_size belirliyoruz. Batch_size verilen dataların kaçlık gruplar halinde eğitileceğini belirleyen bir parametre. Batch_size 128 olarak belirlendi. Epoch parametresi modelin kaç iterasyonda eğitileceğini bildiriyor.
Epochsa 10 vererek modeli 10 kez eğitimden geçirmek istediğimizi bildiriyoruz. Callbacks parametresi ise checkpointimizi atıyoruz. Bu sayede eğitilen modelin nereye kaydedileceğini bildirmiş oluyoruz. Model her eğitildiğinde bir checkpoint oluşturuluyor bunu kaydetdikten sonra, bu değerleri eğtime baştan başlamak yerine checkpoint üzerinden kaydedilen weight değerlerini bildirirsek, eğitim kaydedilen model weight değerleri üzerinden devam ediyor.
Belirlediğimiz şartlarda eğitim gerçekleşiyor.
Model Test
Model eğitildikten sonra test edebilmek için summarize fonksiyonu kullanılıyor. Summarize fonksiyonu özeti çıkarılması istenen texti alıyor. Text daha önce tokenizing işlemine tabi tutuluyor. Bu işlem için tokenizer nesnesinin text_to_tokens fonksiyonu kullanılıyor. Modeli eğitilmeden önce yapıldığı gibi verilen texti ters çevirip padding uyguluyoruz. model_encoder modeli için predict fonksiyonunu tokenizing işlemi yapılmış parametreyle çağırınca, encoder için tahminler üretiliyor sonuç olarak encoder modeli bir context vektörünü output olarak veriyor. Context vektörünü initial_state değişkeninde tutuyoruz. Decoderin sonsuz döngüye girmesini önlemek amacıyla max_tokens belirliyoruz.
Maksimum token sayısına decodere verdiğimiz kelime sayısını veriyoruz. Decoder kelime üretirken bu sayıya ulaştığında artık kelime üretmeyecek. Decoder’e input olarak vermek amacıyla boş bir array oluşturuyoruz. Kelime üretimi yapabilmek için döngü oluşturmamız gerekiyor. Döngü bitiş tokenini alana kadar ve max_tokensa kadar dönecek. Her döngü sonucunda bir kelime elde edip üretilen kelimeyi text çevireceğiz. Döngü ilk adımda oluşturduğumuz decoder_input_data isimli boş arraya başlangıç tokenini atayacak. Bilindiği gibi decodere iki input veriliyor ilki initial_state isminde context vector, ikincisi ise decoder_input_data isimli array. decoder_input_data arrayin ilk döngüde sadece başlangıç tokenini barındırıyor. Decoder için hazırladığımız iki değişkeni x_data değişkenine atayarak decodere input olarak veriyoruz. Decoder modeli bir sonraki kelimeyi predict fonksiyonunu kullanarak tahmin ediyor. Döngüde her adımda önceki adımlarda elde edilen kelimeleri de decodere veriyoruz. Context vektörü ise sabit kalıyor. Döngü devam ettikçe yeni bir kelime tahmin ediliyor ve listeye ekleniyor. Dönen değerleri token dan texte çevirerek stringe ekliyoruz ve çıktı olarak döndürüyoruz.
Sonuçları sonraki yazımda paylaşacağım 🙂 Murat
