Gensim - Hızlı Kılavuz

Bu bölüm, Gensim'in tarihini ve özelliklerini, kullanımları ve avantajları ile birlikte anlamanıza yardımcı olacaktır.

Gensim nedir?

Gensim = “Generate Similar”denetimsiz konu modellemesi için kullanılan popüler bir açık kaynak doğal dil işleme (NLP) kitaplığıdır. Aşağıdakiler gibi çeşitli karmaşık görevleri gerçekleştirmek için en iyi akademik modelleri ve modern istatistiksel makine öğrenimini kullanır:

• Belge veya kelime vektörleri oluşturma
• Corpora
• Konu tanımlamanın gerçekleştirilmesi
• Belge karşılaştırması yapmak (anlamsal olarak benzer belgeleri almak)
• Anlamsal yapı için düz metin belgelerini analiz etme

Yukarıdaki karmaşık görevleri yerine getirmenin yanı sıra, Python ve Cython'da uygulanan Gensim, veri akışını ve artımlı çevrimiçi algoritmaları kullanarak büyük metin koleksiyonlarını işlemek için tasarlanmıştır. Bu, onu yalnızca bellek içi işlemeyi hedefleyen makine öğrenimi yazılım paketlerinden farklı kılar.

Tarih

2008 yılında Gensim, Çek Dijital Matematiği için çeşitli Python komut dosyalarının bir koleksiyonu olarak yola çıktı. Orada, belirli bir makaleye en çok benzeyen makalelerin kısa bir listesini oluşturmaya hizmet etti. Ancak 2009'da RARE Technologies Ltd. ilk sürümünü yayınladı. Ardından, Temmuz 2019'un sonlarında, kararlı sürümünü (3.8.0) aldık.

Çeşitli Özellikler

Aşağıda Gensim tarafından sunulan özellik ve yeteneklerden bazıları verilmiştir -

Ölçeklenebilirlik

Gensim, artan çevrimiçi eğitim algoritmalarını kullanarak büyük ve web ölçekli kurumları kolayca işleyebilir. Doğası gereği ölçeklenebilirdir, çünkü tüm girdi bütününün herhangi bir zamanda tamamen Rasgele Erişim Belleğinde (RAM) kalmasına gerek yoktur. Başka bir deyişle, tüm algoritmaları, külliyat boyutuna göre bellekten bağımsızdır.

güçlü

Gensim, doğası gereği sağlamdır ve çeşitli sistemlerde çeşitli kişiler ve kuruluşlar tarafından 4 yılı aşkın süredir kullanılmaktadır. Kendi girdi külliyatımızı veya veri akışımızı kolayca bağlayabiliriz. Diğer Vektör Uzayı Algoritmaları ile genişletmek de çok kolaydır.

Agnostik Platform

Python'un çok yönlü bir dil olduğunu bildiğimiz gibi Python Gensim, Python ve Numpy'yi destekleyen tüm platformlarda (Windows, Mac OS, Linux gibi) çalışır.

Verimli Çok Çekirdekli Uygulamalar

Gensim, makine kümelerinde işlemeyi ve geri almayı hızlandırmak için çeşitli popüler algoritmaların verimli çok çekirdekli uygulamalarını sağlar. Latent Semantic Analysis (LSA), Latent Dirichlet Allocation (LDA), Random Projections (RP), Hierarchical Dirichlet Process (HDP).

Açık Kaynak ve Bol Topluluk Desteği

Gensim, hem kişisel hem de ticari kullanım için ücretsiz olarak kullanılmasına izin veren OSI onaylı GNU LGPL lisansı altında lisanslanmıştır. Gensim'de yapılan herhangi bir değişiklik, sırayla açık kaynaklıdır ve bol miktarda topluluk desteğine sahiptir.

Gensim'in Kullanım Alanları

Gensim, binden fazla ticari ve akademik uygulamada kullanılmış ve alıntılanmıştır. Ayrıca çeşitli araştırma makaleleri ve öğrenci tezlerinde de alıntılanmıştır. Aşağıdakilerin akışlı paralelleştirilmiş uygulamalarını içerir -

fastText

FastText, kelime gömme için bir sinir ağı kullanır, kelime gömme ve metin sınıflandırmayı öğrenmek için bir kütüphanedir. Facebook'un AI Araştırma (FAIR) laboratuvarı tarafından oluşturulmuştur. Bu model, temelde, sözcükler için vektör temsilleri elde etmek için denetimli veya denetimsiz bir algoritma oluşturmamıza izin verir.

Word2vec

Kelime gömme üretmek için kullanılan Word2vec, bir grup sığ ve iki katmanlı sinir ağı modelidir. Modeller temel olarak kelimelerin dilsel bağlamlarını yeniden yapılandırmak için eğitilmiştir.

LSA (Gizli Anlamsal Analiz)

Bir dizi belge ile bunların kapsadığı terimler arasındaki ilişkileri analiz etmemize izin veren NLP'de (Doğal Dil İşleme) bir tekniktir. Belgeler ve terimlerle ilgili bir dizi kavram üreterek yapılır.

LDA (Gizli Dirichlet Tahsisi)

NLP'de gözlem setlerinin gözlemlenmemiş gruplar tarafından açıklanmasına izin veren bir tekniktir. Bu gözlemlenmemiş gruplar, verilerin bazı kısımlarının neden benzer olduğunu açıklıyor. Nedeni bu, üretken bir istatistiksel model.

tf-idf (terim frekans-ters belge sıklığı)

Bilgi erişiminde sayısal bir istatistik olan tf-idf, bir kelimenin derlemedeki bir belge için ne kadar önemli olduğunu yansıtır. Genellikle arama motorları tarafından, bir kullanıcı sorgusu verilen bir belgenin alaka düzeyini puanlamak ve sıralamak için kullanılır. Ayrıca, metin özetleme ve sınıflandırmada durdurma sözcükleri filtrelemesi için de kullanılabilir.

Hepsi sonraki bölümlerde detaylı olarak anlatılacaktır.

Avantajlar

Gensim, konu modelleme yapan bir NLP paketidir. Gensim'in önemli avantajları aşağıdaki gibidir -

• Konu modelleme ve kelime yerleştirme olanaklarını diğer paketlere alabiliriz. ‘scikit-learn’ ve ‘R’ancak konu modelleri oluşturmak ve kelime yerleştirmek için Gensim tarafından sağlanan olanaklar benzersizdir. Ayrıca metin işleme için daha uygun olanaklar sağlar.

• Gensim'in bir diğer önemli avantajı, tüm dosyayı belleğe yüklemeden bile büyük metin dosyalarını işlememize izin vermesidir.

• Gensim, denetimsiz modeller kullandığı için maliyetli ek açıklamalara veya belgelerin elle etiketlenmesine gerek duymaz.

Bu bölüm, Gensim'i kurmanın ön koşulları, temel bağımlılıkları ve mevcut sürümü hakkında bilgiler hakkında aydınlatıyor.

Önkoşullar

Gensim'i kurmak için bilgisayarlarımızda Python kurulu olmalıdır. Www.python.org/downloads/ bağlantısına gidebilir ve işletim sisteminiz için en son sürümü, yani Windows ve Linux / Unix'i seçebilirsiniz. Python ile ilgili temel eğitim için www.tutorialspoint.com/python3/index.htm bağlantısına başvurabilirsiniz . Gensim, Linux, Windows ve Mac OS X için desteklenmektedir.

Kod Bağımlılıkları

Gensim, destekleyen herhangi bir platformda çalışmalıdır. Python 2.7 or 3.5+ ve NumPy. Aslında aşağıdaki yazılıma bağlıdır -

Python

Gensim, Python 2.7, 3.5, 3.6 ve 3.7 sürümleriyle test edilmiştir.

Dizi

NumPy, Python ile bilimsel hesaplama için bir paket olduğunu bildiğimiz gibi. Aynı zamanda verimli, çok boyutlu bir jenerik veri kabı olarak da kullanılabilir. Gensim, numara hesaplama için NumPy paketine bağlıdır. Python ile ilgili temel eğitim için www.tutorialspoint.com/numpy/index.htm bağlantısına başvurabilirsiniz .

smart_open

Bir Python 2 ve Python 3 kitaplığı olan smart_open, çok büyük dosyaların verimli akışı için kullanılır. S3, HDFS, WebHDFS, HTTP, HTTPS, SFTP veya yerel dosya sistemleri gibi depolardan / depolara akışı destekler. Gensim bağlıdırsmart_open Uzak depolamadaki dosyaları ve sıkıştırılmış dosyaları şeffaf bir şekilde açmak için Python kitaplığı.

Şimdiki versiyonu

Gensim'in güncel sürümü 3.8.0 Temmuz 2019'da piyasaya sürüldü.

Terminal Kullanarak Yükleme

Gensim'i kurmanın en basit yollarından biri, terminalinizde aşağıdaki komutu çalıştırmaktır -

pip install --upgrade gensim

Conda Ortamını Kullanarak Yükleme

Gensim'i indirmenin alternatif bir yolu, condaçevre. Aşağıdaki komutu cihazınızda çalıştırın.conda terminal -

conda install –c conda-forge gensim

Kaynak Paketi Kullanarak Yükleme

Varsayalım, kaynak paketi indirip açarsanız, aşağıdaki komutları çalıştırmanız gerekir -

python setup.py test
python setup.py install

Burada, esas olarak belgeler ve külliyat üzerinde odaklanarak Gensim'in temel kavramlarını öğreneceğiz.

Gensim'in Temel Kavramları

Gensim'i anlamak ve kullanmak için gerekli olan temel kavramlar ve terimler aşağıdadır -

• Document - Z Bazı metinleri ifade eder.

• Corpus - Bir belge koleksiyonunu ifade eder.

• Vector - Bir belgenin matematiksel temsiline vektör denir.

• Model - Vektörleri bir gösterimden diğerine dönüştürmek için kullanılan bir algoritmayı ifade eder.

Belge nedir?

Tartışıldığı gibi, bir metne atıfta bulunuyor. Biraz ayrıntıya girersek, bu, olarak bilinen metin dizisi türünün bir nesnesidir.‘str’ Python 3'te. Örneğin, Gensim'de bir belge şu gibi herhangi bir şey olabilir -

• 140 karakterlik kısa tweet
• Tek paragraf, yani makale veya araştırma makalesi özeti
• Haber makalesi
• Book
• Novel
• Theses

Metin Sırası

Metin dizisi türü genellikle şu adla bilinir: ‘str’ Python 3'te bildiğimiz gibi, Python'da metinsel veriler dizelerle veya daha spesifik olarak ‘str’nesneler. Dizeler temelde değişmez Unicode kod noktalarının dizileridir ve aşağıdaki şekillerde yazılabilir -

• Single quotes - Örneğin, ‘Hi! How are you?’. Ayrıca çift tırnak eklememize izin verir. Örneğin,‘Hi! “How” are you?’

• Double quotes - Örneğin, "Hi! How are you?". Ayrıca tek tırnak işaretlerini yerleştirmemize de olanak tanır. Örneğin,"Hi! 'How' are you?"

• Triple quotes - Üç tek tırnak olabilir, örneğin, '''Hi! How are you?'''. veya üç çift tırnak,"""Hi! 'How' are you?"""

Tüm boşluklar dize değişmezine dahil edilecektir.

Misal

Aşağıda Gensim'deki bir Belge örneği verilmiştir -

Document = “Tutorialspoint.com is the biggest online tutorials library and it’s all free also”

Corpus nedir?

Bir külliyat, doğal bir iletişim ortamında üretilen büyük ve yapılandırılmış makine tarafından okunabilir metinler dizisi olarak tanımlanabilir. Gensim'de bir belge nesnesi koleksiyonuna korpus denir. Korpus'un çoğulucorpora.

Gensim'de Derlemin Rolü

Gensim'deki bir külliyat aşağıdaki iki rolü yerine getirir:

Bir Modeli Eğitmek için Girdi Olarak Hizmet Eder

Bir külliyatın Gensim'de oynadığı ilk ve önemli rol, bir modelin eğitilmesi için bir girdi olmasıdır. Modelin dahili parametrelerini başlatmak için, eğitim sırasında model, eğitim külliyatından bazı ortak temaları ve konuları arar. Yukarıda tartışıldığı gibi, Gensim denetimsiz modellere odaklanır, bu nedenle herhangi bir insan müdahalesi gerektirmez.

Konu Çıkarıcı olarak hizmet verir

Model eğitildikten sonra, yeni belgelerden konuları çıkarmak için kullanılabilir. Burada yeni belgeler eğitim aşamasında kullanılmayan belgelerdir.

Misal

Külliyat, belirli bir kişinin tüm tweet'lerini, bir gazetenin tüm makalelerinin listesini veya belirli bir konudaki tüm araştırma makalelerini vb. İçerebilir.

Derlem Toplama

Aşağıda, 5 belge içeren küçük bir külliyat örneği verilmiştir. Burada her belge tek bir cümleden oluşan bir dizedir.

t_corpus = [
   "A survey of user opinion of computer system response time",
   "Relation of user perceived response time to error measurement",
   "The generation of random binary unordered trees",
   "The intersection graph of paths in trees",
   "Graph minors IV Widths of trees and well quasi ordering",
]

Derlemi Ön İşleme Toplama

Derlemeyi topladıktan sonra, derlemeyi basit tutmak için birkaç ön işleme adımı atılmalıdır. 'The' gibi yaygın olarak kullanılan bazı İngilizce kelimeleri kaldırabiliriz. Ayrıca külliyatta yalnızca bir kez geçen kelimeleri de kaldırabiliriz.

Örneğin, aşağıdaki Python betiği, her belgeyi küçük harfle yazmak, beyaz boşluğa bölmek ve durdurma sözcüklerini filtrelemek için kullanılır -

Misal

import pprint
t_corpus = [
   "A survey of user opinion of computer system response time", 
   "Relation of user perceived response time to error measurement", 
   "The generation of random binary unordered trees", 
   "The intersection graph of paths in trees", 
   "Graph minors IV Widths of trees and well quasi ordering",
]
stoplist = set('for a of the and to in'.split(' '))
processed_corpus = [[word for word in document.lower().split() if word not in stoplist]
   for document in t_corpus]
	
pprint.pprint(processed_corpus)
]

Çıktı

[['survey', 'user', 'opinion', 'computer', 'system', 'response', 'time'],
['relation', 'user', 'perceived', 'response', 'time', 'error', 'measurement'],
['generation', 'random', 'binary', 'unordered', 'trees'],
['intersection', 'graph', 'paths', 'trees'],
['graph', 'minors', 'iv', 'widths', 'trees', 'well', 'quasi', 'ordering']]

Etkili Ön İşleme

Gensim ayrıca, külliyatın daha etkili ön işlemesi için işlev sağlar. Bu tür bir ön işlemede, bir belgeyi küçük harfli simge listesine dönüştürebiliriz. Çok kısa veya çok uzun olan jetonları da göz ardı edebiliriz. Böyle bir işlevgensim.utils.simple_preprocess(doc, deacc=False, min_len=2, max_len=15).

gensim.utils.simple_preprocess() fucntion

Gensim, bir belgeyi küçük harfli simge listesine dönüştürmek ve ayrıca çok kısa veya çok uzun olan simgeleri yok saymak için bu işlevi sağlar. Aşağıdaki parametrelere sahiptir -

doc (str)

Ön işlemenin uygulanması gereken girdi belgesini ifade eder.

deacc (bool, isteğe bağlı)

Bu parametre, aksan işaretlerini belirteçlerden kaldırmak için kullanılır. Kullanırdeaccent() Bunu yapmak için.

min_len (int, isteğe bağlı)

Bu parametrenin yardımıyla, bir token'ın minimum uzunluğunu belirleyebiliriz. Tanımlanan uzunluktan daha kısa olan jetonlar atılacaktır.

max_len (int, isteğe bağlı)

Bu parametrenin yardımıyla bir token'ın maksimum uzunluğunu belirleyebiliriz. Tanımlanan uzunluktan daha uzun olan jetonlar atılacaktır.

Bu işlevin çıktısı, girdi belgesinden çıkarılan belirteçler olacaktır.

Burada, vektör ve modele odaklanarak Gensim'in temel kavramlarını öğreneceğiz.

Vector nedir?

Ya külliyatımızdaki gizli yapıyı çıkarmak istersek? Bunun için, belgeleri matematiksel olarak işleyebileceğimiz bir şekilde temsil etmemiz gerekiyor. Popüler bir temsil türü, her külliyat belgesini bir özellik vektörü olarak temsil etmektir. Bu nedenle vektörün bir belgenin matematiksel olarak uygun bir temsili olduğunu söyleyebiliriz.

Size bir örnek vermek gerekirse, yukarıda kullandığımız külliyatın tek bir özelliğini QA çifti olarak gösterelim -

Q - Bu kelime kaç kez Hello belgede görünüyor mu?

A - Sıfır (0).

Q - Belgede kaç paragraf var?

A - İki (2)

Soru genellikle tamsayı kimliği ile temsil edilir, bu nedenle bu belgenin temsili (1, 0.0), (2, 2.0) gibi bir dizi çifttir. Bu tür vektör gösterimi, birdensevektör. Nedendenseçünkü yukarıda yazılan tüm sorulara açık bir cevap içermektedir.

Tüm soruları önceden biliyorsanız, temsil (0, 2) gibi basit olabilir. Cevapların bu sekansı (tabii ki sorular önceden biliniyorsa)vector belgemiz için.

Diğer bir popüler temsil türü ise bag-of-word (BoW)model. Bu yaklaşımda, her belge temelde sözlükteki her kelimenin sıklık sayısını içeren bir vektörle temsil edilir.

Size bir örnek vermek gerekirse, ['Merhaba', 'Nasıl', 'siz'] kelimelerini içeren bir sözlüğümüz olduğunu varsayalım. "Nasılsın" dizesini içeren bir belge bu durumda [0, 2, 1, 1] vektörüyle temsil edilir. Burada, vektörün girişleri "Merhaba", "Nasıl", "siz" ve "siz" kelimelerinin geçiş sırasına göre verilmiştir.

Vektör ve Belge

Yukarıdaki vektör açıklamasından, bir belge ile bir vektör arasındaki ayrım neredeyse anlaşılmıştır. Ancak, daha net hale getirmek için,document metin ve vectorbu metnin matematiksel olarak uygun bir temsilidir. Ne yazık ki, bazen birçok insan bu terimleri birbirinin yerine kullanır.

Örneğin, rasgele bir A belgemiz olduğunu varsayalım, "A belgesine karşılık gelen vektör" demek yerine, "A vektörü" veya "A belgesi" derlerdi. Bu büyük bir belirsizliğe yol açar. Burada dikkat edilmesi gereken bir diğer önemli husus, iki farklı belgenin aynı vektör temsiline sahip olabileceğidir.

Korpusu vektör listesine dönüştürme

Korpusu vektörler listesine dönüştürmenin bir uygulama örneğini almadan önce, külliyattaki her kelimeyi benzersiz bir tamsayı kimliği ile ilişkilendirmemiz gerekir. Bunun için yukarıdaki bölümde alınan örneği genişleteceğiz.

Misal

from gensim import corpora
dictionary = corpora.Dictionary(processed_corpus)
print(dictionary)

Çıktı

Dictionary(25 unique tokens: ['computer', 'opinion', 'response', 'survey', 'system']...)

Bizim külliyatımızda bunun içinde 25 farklı token olduğunu gösteriyor gensim.corpora.Dictionary.

Uygulama Örneği

Sözlüğü, belirteçli belgeleri bu 5 boyutlu vektörlere dönüştürmek için aşağıdaki gibi kullanabiliriz:

pprint.pprint(dictionary.token2id)

Çıktı

{
   'binary': 11,
   'computer': 0,
   'error': 7,
   'generation': 12,
   'graph': 16,
   'intersection': 17,
   'iv': 19,
   'measurement': 8,
   'minors': 20,
   'opinion': 1,
   'ordering': 21,
   'paths': 18,
   'perceived': 9,
   'quasi': 22,
   'random': 13,
   'relation': 10,
   'response': 2,
   'survey': 3,
   'system': 4,
   'time': 5,
   'trees': 14,
   'unordered': 15,
   'user': 6,
   'well': 23,
   'widths': 24
}

Ve benzer şekilde, bir belge için kelime torbası temsilini aşağıdaki gibi oluşturabiliriz -

BoW_corpus = [dictionary.doc2bow(text) for text in processed_corpus]
pprint.pprint(BoW_corpus)

Çıktı

[
   [(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1)],
   [(2, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 1)],
   [(11, 1), (12, 1), (13, 1), (14, 1), (15, 1)],
   [(14, 1), (16, 1), (17, 1), (18, 1)],
   [(14, 1), (16, 1), (19, 1), (20, 1), (21, 1), (22, 1), (23, 1), (24, 1)]
]

Model nedir?

Külliyatı vektörleştirdikten sonra, ne olacak? Şimdi, modelleri kullanarak dönüştürebiliriz. Model, bir belge gösterimini diğerine dönüştürmek için kullanılan bir algoritmaya atıfta bulunulabilir.

Tartıştığımız gibi, Gensim'de belgeler vektörler olarak temsil edilmektedir, bu nedenle, iki vektör uzayı arasındaki bir dönüşüm olarak model olsa da yapabiliriz. Modellerin bu tür dönüşümlerin ayrıntılarını öğrendiği bir eğitim aşaması her zaman vardır. Model, eğitim aşamasında eğitim külliyatını okur.

Bir Modeli Başlatma

Başlayalım tf-idfmodel. Bu model, vektörleri BoW (Kelime Torbası) temsilinden başka bir vektör uzayına dönüştürür; burada frekans sayıları, külliyattaki her kelimenin göreli nadirliğine göre ağırlıklandırılır.

Uygulama Örneği

Aşağıdaki örnekte, tf-idfmodel. Onu külliyatımızda eğiteceğiz ve ardından "ağaç grafiğini" dize dönüştüreceğiz.

Misal

from gensim import models
tfidf = models.TfidfModel(BoW_corpus)
words = "trees graph".lower().split()
print(tfidf[dictionary.doc2bow(words)])

Çıktı

[(3, 0.4869354917707381), (4, 0.8734379353188121)]

Şimdi, modeli oluşturduktan sonra, tüm külliyatı tfidf aracılığıyla dönüştürebilir ve indeksleyebilir ve sorgu belgemizin (sorgu belgesine 'ağaç sistemi' veriyoruz) derlemdeki her bir belgeye benzerliğini sorgulayabiliriz -

Misal

from gensim import similarities
index = similarities.SparseMatrixSimilarity(tfidf[BoW_corpus],num_features=5)
query_document = 'trees system'.split()
query_bow = dictionary.doc2bow(query_document)
simils = index[tfidf[query_bow]]
print(list(enumerate(simils)))

Çıktı

[(0, 0.0), (1, 0.0), (2, 1.0), (3, 0.4869355), (4, 0.4869355)]

Yukarıdaki çıktıdan, belge 4 ve belge 5'in benzerlik puanı yaklaşık% 49'dur.

Dahası, bu çıktıyı daha fazla okunabilirlik için aşağıdaki gibi sıralayabiliriz -

Misal

for doc_number, score in sorted(enumerate(sims), key=lambda x: x[1], reverse=True):
   print(doc_number, score)

Çıktı

2 1.0
3 0.4869355
4 0.4869355
0 0.0
1 0.0

Vektör ve model hakkında tartıştığımız son bölümde, sözlük hakkında bir fikir edindiniz. Burada tartışacağızDictionary biraz daha ayrıntılı olarak nesne.

Sözlük nedir?

Sözlük kavramına derinlemesine dalmadan önce, bazı basit NLP kavramlarını anlayalım -

• Token - Belirteç, 'kelime' anlamına gelir.

• Document - Bir belge bir cümle veya paragrafa atıfta bulunur.

• Corpus - Bir kelime torbası (BoW) olarak bir belge koleksiyonunu ifade eder.

Tüm belgeler için, bir külliyat her zaman belgedeki sıklık sayısıyla birlikte her sözcüğün belirtecinin kimliğini içerir.

Gensim'deki sözlük kavramına geçelim. Metin belgeleri üzerinde çalışmak için Gensim ayrıca kelimelerin, yani belirteçlerin benzersiz kimliklerine dönüştürülmesini gerektirir. Bunu başarmak için bize kolaylık sağlarDictionary object, her kelimeyi benzersiz tam sayı kimliği ile eşleyen. Bunu, giriş metnini kelime listesine dönüştürerek ve ardından bunucorpora.Dictionary() nesne.

Sözlük İhtiyacı

Şimdi şu soru ortaya çıkıyor: Sözlük nesnesine gerçekten ihtiyaç nedir ve nerede kullanılabilir? Gensim'de sözlük nesnesi, daha sonra konu modellemesine ve diğer modellere girdi olarak kullanılan bir kelime çuvalı (BoW) korpusu oluşturmak için kullanılır.

Metin Giriş Formları

Gensim'e sağlayabileceğimiz üç farklı giriş metni biçimi vardır -

• Python'un yerel liste nesnesinde depolanan cümleler olarak ( str Python 3'te)

• Tek bir metin dosyası olarak (küçük veya büyük olabilir)

• Çoklu metin dosyaları

Gensim Kullanarak Sözlük Oluşturmak

Gensim'de tartışıldığı gibi, sözlük tüm kelimelerin, diğer adıyla jetonların benzersiz tamsayı kimliklerine eşlenmesini içerir. Cümle listesinden, bir veya daha fazla metin dosyasından (birden fazla metin satırı içeren metin dosyası) bir sözlük oluşturabiliriz. Öyleyse, önce cümle listesini kullanarak sözlük oluşturarak başlayalım.

Cümleler Listesinden

Aşağıdaki örnekte, bir cümle listesinden sözlük oluşturacağız. Cümle listemiz olduğunda veya birden fazla cümle söyleyebildiğimizde, her cümleyi bir kelime listesine dönüştürmeliyiz ve anlamalar bunu yapmanın en yaygın yollarından biridir.

Uygulama Örneği

Öncelikle gerekli ve gerekli paketleri aşağıdaki şekilde içe aktarın -

import gensim
from gensim import corpora
from pprint import pprint

Ardından, sözlüğü oluştururken kullanmak için cümle / belge listesinden anlama listesini yapın -

doc = [
   "CNTK formerly known as Computational Network Toolkit",
   "is a free easy-to-use open-source commercial-grade toolkit",
   "that enable us to train deep learning algorithms to learn like the human brain."
]

Sonra, cümleleri kelimelere bölmemiz gerekiyor. Buna belirteçleme denir.

text_tokens = [[text for text in doc.split()] for doc in doc]

Şimdi, aşağıdaki komut dosyasının yardımıyla sözlüğü oluşturabiliriz -

dict_LoS = corpora.Dictionary(text_tokens)

Şimdi sözlükteki simge sayısı gibi biraz daha bilgi alalım -

print(dict_LoS)

Çıktı

Dictionary(27 unique tokens: ['CNTK', 'Computational', 'Network', 'Toolkit', 'as']...)

Eşsiz tamsayı eşlemesine kelimesini aşağıdaki gibi de görebiliriz -

print(dict_LoS.token2id)

Çıktı

{
   'CNTK': 0, 'Computational': 1, 'Network': 2, 'Toolkit': 3, 'as': 4, 
   'formerly': 5, 'known': 6, 'a': 7, 'commercial-grade': 8, 'easy-to-use': 9,
   'free': 10, 'is': 11, 'open-source': 12, 'toolkit': 13, 'algorithms': 14,
   'brain.': 15, 'deep': 16, 'enable': 17, 'human': 18, 'learn': 19, 'learning': 20,
   'like': 21, 'that': 22, 'the': 23, 'to': 24, 'train': 25, 'us': 26
}

Eksiksiz Uygulama Örneği

import gensim
from gensim import corpora
from pprint import pprint
doc = [
   "CNTK formerly known as Computational Network Toolkit",
   "is a free easy-to-use open-source commercial-grade toolkit",
   "that enable us to train deep learning algorithms to learn like the human brain."
]
text_tokens = [[text for text in doc.split()] for doc in doc]
dict_LoS = corpora.Dictionary(text_tokens)
print(dict_LoS.token2id)

Tek Metin Dosyasından

Aşağıdaki örnekte tek bir metin dosyasından sözlük oluşturacağız. Benzer şekilde, birden fazla metin dosyasından da sözlük oluşturabiliriz (yani dosyaların dizini).

Bunun için önceki örnekte kullanılan belgeyi isimli metin dosyasına kaydettik. doc.txt. Gensim, dosyayı satır satır okuyacak ve bir seferde bir satır işleyecektir.simple_preprocess. Bu şekilde, dosyanın tamamını belleğe tek seferde yüklemesine gerek kalmaz.

Uygulama Örneği

Öncelikle gerekli ve gerekli paketleri aşağıdaki şekilde içe aktarın -

import gensim
from gensim import corpora
from pprint import pprint
from gensim.utils import simple_preprocess
from smart_open import smart_open
import os

Sonraki kod satırı, doc.txt adlı tek metin dosyasını kullanarak gensim sözlüğü yapacaktır -

dict_STF = corpora.Dictionary(
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
)

Şimdi sözlükteki simge sayısı gibi biraz daha bilgi alalım -

print(dict_STF)

Çıktı

Dictionary(27 unique tokens: ['CNTK', 'Computational', 'Network', 'Toolkit', 'as']...)

Eşsiz tamsayı eşlemesine kelimesini aşağıdaki gibi de görebiliriz -

print(dict_STF.token2id)

Çıktı

{
   'CNTK': 0, 'Computational': 1, 'Network': 2, 'Toolkit': 3, 'as': 4, 
   'formerly': 5, 'known': 6, 'a': 7, 'commercial-grade': 8, 'easy-to-use': 9, 
   'free': 10, 'is': 11, 'open-source': 12, 'toolkit': 13, 'algorithms': 14, 
   'brain.': 15, 'deep': 16, 'enable': 17, 'human': 18, 'learn': 19, 
   'learning': 20, 'like': 21, 'that': 22, 'the': 23, 'to': 24, 'train': 25, 'us': 26
}

Eksiksiz Uygulama Örneği

import gensim
from gensim import corpora
from pprint import pprint
from gensim.utils import simple_preprocess
from smart_open import smart_open
import os
dict_STF = corpora.Dictionary(
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
)
dict_STF = corpora.Dictionary(text_tokens)
print(dict_STF.token2id)

Birden Çok Metin Dosyasından

Şimdi birden fazla dosyadan, yani aynı dizine kaydedilmiş birden fazla metin dosyasından sözlük oluşturalım. Bu örnek için, üç farklı metin dosyası oluşturduk:first.txt, second.txt ve third.txtmetin dosyasından (doc.txt) üç satırı içeren, önceki örnek için kullandık. Tüm bu üç metin dosyası, adlı bir dizine kaydedilir.ABC.

Uygulama Örneği

Bunu uygulamak için, dizindeki (ABC) üç metin dosyasını (Birinci, İkinci ve Üçüncü.txt) yineleyebilen ve işlenmiş sözcük dizgeleri listesini veren bir yöntemle bir sınıf tanımlamamız gerekir.

Adlı sınıfı tanımlayalım Read_files __ adlı bir yönteme sahip olmakiteration__ () aşağıdaki gibi -

class Read_files(object):
   def __init__(self, directoryname):
      elf.directoryname = directoryname
   def __iter__(self):
      for fname in os.listdir(self.directoryname):
         for line in open(os.path.join(self.directoryname, fname), encoding='latin'):
   yield simple_preprocess(line)

Ardından, dizinin yolunu aşağıdaki gibi sağlamamız gerekiyor -

path = "ABC"

#provide the path as per your computer system where you saved the directory.

Sonraki adımlar, önceki örneklerde yaptığımız gibi benzerdir. Sonraki kod satırı, üç metin dosyası içeren dizini kullanarak Gensim dizini oluşturacaktır -

dict_MUL = corpora.Dictionary(Read_files(path))

Çıktı

Dictionary(27 unique tokens: ['CNTK', 'Computational', 'Network', 'Toolkit', 'as']...)

Şimdi, benzersiz tamsayı eşlemesine kelimesini aşağıdaki gibi görebiliriz -

print(dict_MUL.token2id)

Çıktı

{
   'CNTK': 0, 'Computational': 1, 'Network': 2, 'Toolkit': 3, 'as': 4, 
   'formerly': 5, 'known': 6, 'a': 7, 'commercial-grade': 8, 'easy-to-use': 9, 
   'free': 10, 'is': 11, 'open-source': 12, 'toolkit': 13, 'algorithms': 14, 
   'brain.': 15, 'deep': 16, 'enable': 17, 'human': 18, 'learn': 19, 
   'learning': 20, 'like': 21, 'that': 22, 'the': 23, 'to': 24, 'train': 25, 'us': 26
}

Gensim Sözlüğünü Kaydetme ve Yükleme

Gensim kendi yerellerini destekliyor save() sözlüğü diske kaydetme yöntemi ve load() sözlüğü diskten geri yükleme yöntemi.

Örneğin, aşağıdaki komut dosyası yardımıyla sözlüğü kaydedebiliriz -

Gensim.corpora.dictionary.save(filename)

#provide the path where you want to save the dictionary.

Benzer şekilde, kaydedilmiş sözlüğü load () yöntemini kullanarak yükleyebiliriz. Aşağıdaki komut dosyası bunu yapabilir -

Gensim.corpora.dictionary.load(filename)

#provide the path where you have saved the dictionary.

Bir belge listesinden ve metin dosyalarından (hem birden hem de birden çok belgeden) nasıl sözlük oluşturulacağını anladık. Şimdi, bu bölümde, bir kelime torbası (BoW) korpusu oluşturacağız. Gensim ile çalışmak için aşina olmamız gereken en önemli nesnelerden biridir. Temel olarak, her belgedeki id kelimesini ve sıklığını içeren külliyattır.

Bir BoW Corpus Oluşturma

Gensim'de tartışıldığı gibi külliyat, her belgede id kelimesini ve sıklığını içerir. Basit bir belge listesinden ve metin dosyalarından bir BoW corpus oluşturabiliriz. Yapmamız gereken, belirteçli kelime listesini adlı nesneye iletmektir.Dictionary.doc2bow(). İlk olarak, basit bir belge listesi kullanarak BoW corpus oluşturarak başlayalım.

Basit Bir Cümle Listesinden

Aşağıdaki örnekte, üç cümle içeren basit bir listeden BoW corpus oluşturacağız.

Öncelikle, gerekli tüm paketleri aşağıdaki gibi içe aktarmamız gerekiyor -

import gensim
import pprint
from gensim import corpora
from gensim.utils import simple_preprocess

Şimdi cümleleri içeren listeyi sağlayın. Listemizde üç cümle var -

doc_list = [
   "Hello, how are you?", "How do you do?", 
   "Hey what are you doing? yes you What are you doing?"
]

Ardından, cümleleri aşağıdaki gibi belirtiniz:

doc_tokenized = [simple_preprocess(doc) for doc in doc_list]

Bir nesne oluştur corpora.Dictionary() aşağıdaki gibi -

dictionary = corpora.Dictionary()

Şimdi bu belirtilmiş cümleleri dictionary.doc2bow() objectaşağıdaki gibi -

BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]

Sonunda kelime külliyatının çantasını yazdırabiliriz -

print(BoW_corpus)

Çıktı

[
   [(0, 1), (1, 1), (2, 1), (3, 1)], 
   [(2, 1), (3, 1), (4, 2)], [(0, 2), (3, 3), (5, 2), (6, 1), (7, 2), (8, 1)]
]

Yukarıdaki çıktı, id = 0 olan sözcüğün ilk belgede bir kez göründüğünü gösterir (çünkü çıktıda (0,1) var) vb.

Yukarıdaki çıktı insanların okuması için bir şekilde mümkün değil. Bu kimlikleri kelimelere de dönüştürebiliriz, ancak bunun için sözlüğümüzün aşağıdaki gibi dönüşümü yapmasına ihtiyacımız var -

id_words = [[(dictionary[id], count) for id, count in line] for line in BoW_corpus]
print(id_words)

Çıktı

[
   [('are', 1), ('hello', 1), ('how', 1), ('you', 1)], 
   [('how', 1), ('you', 1), ('do', 2)], 
   [('are', 2), ('you', 3), ('doing', 2), ('hey', 1), ('what', 2), ('yes', 1)]
]

Şimdi yukarıdaki çıktı bir şekilde insan tarafından okunabilir.

Eksiksiz Uygulama Örneği

import gensim
import pprint
from gensim import corpora
from gensim.utils import simple_preprocess
doc_list = [
   "Hello, how are you?", "How do you do?", 
   "Hey what are you doing? yes you What are you doing?"
]
doc_tokenized = [simple_preprocess(doc) for doc in doc_list]
dictionary = corpora.Dictionary()
BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]
print(BoW_corpus)
id_words = [[(dictionary[id], count) for id, count in line] for line in BoW_corpus]
print(id_words)

Bir Metin Dosyasından

Aşağıdaki örnekte, bir metin dosyasından BoW corpus oluşturacağız. Bunun için önceki örnekte kullanılan belgeyi isimli metin dosyasına kaydettik.doc.txt..

Gensim, dosyayı satır satır okuyacak ve bir seferde bir satır işleyecektir. simple_preprocess. Bu şekilde, dosyanın tamamını belleğe tek seferde yüklemesine gerek kalmaz.

Uygulama Örneği

Öncelikle gerekli ve gerekli paketleri aşağıdaki şekilde içe aktarın -

import gensim
from gensim import corpora
from pprint import pprint
from gensim.utils import simple_preprocess
from smart_open import smart_open
import os

Daha sonra, aşağıdaki kod satırı, belgeleri doc.txt'den okutacak ve onu belirtecek -

doc_tokenized = [
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
]
dictionary = corpora.Dictionary()

Şimdi bu belirteçli kelimeleri dictionary.doc2bow() nesne (önceki örnekte olduğu gibi)

BoW_corpus = [
   dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized
]
print(BoW_corpus)

Çıktı

[
   [(9, 1), (10, 1), (11, 1), (12, 1), (13, 1), (14, 1), (15, 1)], 
   [
      (15, 1), (16, 1), (17, 1), (18, 1), (19, 1), (20, 1), (21, 1), 
      (22, 1), (23, 1), (24, 1)
   ], 
   [
      (23, 2), (25, 1), (26, 1), (27, 1), (28, 1), (29, 1), 
      (30, 1), (31, 1), (32, 1), (33, 1), (34, 1), (35, 1), (36, 1)
   ], 
   [(3, 1), (18, 1), (37, 1), (38, 1), (39, 1), (40, 1), (41, 1), (42, 1), (43, 1)], 
   [
      (18, 1), (27, 1), (31, 2), (32, 1), (38, 1), (41, 1), (43, 1), 
      (44, 1), (45, 1), (46, 1), (47, 1), (48, 1), (49, 1), (50, 1), (51, 1), (52, 1)
   ]
]

doc.txt dosya aşağıdaki içeriğe sahip -

Eskiden Hesaplamalı Ağ Araç Kiti olarak bilinen CNTK, insan beyni gibi öğrenmek için derin öğrenme algoritmalarını eğitmemizi sağlayan, kullanımı kolay, açık kaynaklı, ticari düzeyde ücretsiz bir araç setidir.

Ücretsiz öğreticiyi tutorialspoint.com adresinde bulabilirsiniz, ayrıca AI derin öğrenme makine öğrenimi gibi teknolojiler hakkında ücretsiz olarak en iyi teknik eğitimleri sağlar.

Eksiksiz Uygulama Örneği

import gensim
from gensim import corpora
from pprint import pprint
from gensim.utils import simple_preprocess
from smart_open import smart_open
import os
doc_tokenized = [
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
]
dictionary = corpora.Dictionary()
BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]
print(BoW_corpus)

Gensim Corpus'unun Kaydedilmesi ve Yüklenmesi

Aşağıdaki komut dosyası yardımıyla külliyatı kaydedebiliriz -

corpora.MmCorpus.serialize(‘/Users/Desktop/BoW_corpus.mm’, bow_corpus)

#provide the path and the name of the corpus. The name of corpus is BoW_corpus and we saved it in Matrix Market format.

Benzer şekilde, aşağıdaki komut dosyasını kullanarak kaydedilmiş külliyatları yükleyebiliriz -

corpus_load = corpora.MmCorpus(‘/Users/Desktop/BoW_corpus.mm’)
for line in corpus_load:
print(line)

Bu bölüm, Gensim'deki çeşitli dönüşümleri öğrenmenize yardımcı olacaktır. Dönüşen belgeleri anlayarak başlayalım.

Belgeleri Dönüştürme

Belgelerin dönüştürülmesi, belgenin matematiksel olarak değiştirilebileceği şekilde temsil edilmesi anlamına gelir. Belgeleri dönüştürmek, derlemenin gizli yapısını çıkarmanın yanı sıra aşağıdaki hedeflere de hizmet edecektir:

• Kelimeler arasındaki ilişkiyi keşfeder.

• Derlemedeki gizli yapıyı ortaya çıkarır.

• Belgeleri yeni ve daha anlamsal bir şekilde açıklar.

• Belgelerin temsilini daha kompakt hale getirir.

• Yeni temsil daha az kaynak tükettiği için verimliliği artırır.

• Yeni sunumda marjinal veri eğilimleri göz ardı edildiği için etkinliği artırır.

• Yeni belge sunumunda gürültü de azaltılır.

Belgeleri bir vektör alanı gösteriminden diğerine dönüştürmek için uygulama adımlarını görelim.

Uygulama Adımları

Belgeleri dönüştürmek için aşağıdaki adımları izlemeliyiz -

1. Adım: Kitaplığın Oluşturulması

İlk ve temel adım, belgelerden külliyat oluşturmaktır. Önceki örneklerde korpusu zaten oluşturduk. Bazı iyileştirmelerle başka bir tane oluşturalım (ortak kelimeleri ve yalnızca bir kez görünen kelimeleri kaldıralım) -

import gensim
import pprint
from collections import defaultdict
from gensim import corpora

Şimdi korpusu oluşturmak için gerekli belgeleri sağlayın -

t_corpus = ["Eskiden Hesaplamalı Ağ Araç Seti olarak bilinen CNTK", "insan beyni gibi öğrenmek için derin öğrenme algoritmalarını eğitmemizi sağlayan, kullanımı kolay, açık kaynaklı, ticari düzeyde ücretsiz bir araç setidir", " Ücretsiz öğreticiyi tutorialspoint.com adresinde bulabilirsiniz "," Tutorialspoint.com ayrıca AI derin öğrenme makine öğrenimi gibi teknolojiler hakkında ücretsiz olarak en iyi teknik eğitimleri sağlar "]

Ardından, belirteç yapmalıyız ve bununla birlikte ortak sözcükleri de kaldıracağız -

stoplist = set('for a of the and to in'.split(' '))
processed_corpus = [
   [
      word for word in document.lower().split() if word not in stoplist
   ]
	for document in t_corpus
]

Aşağıdaki komut dosyası yalnızca görünen kelimeleri kaldıracaktır -

frequency = defaultdict(int)
for text in processed_corpus:
   for token in text:
      frequency[token] += 1
   processed_corpus = [
      [token for token in text if frequency[token] > 1] 
      for text in processed_corpus
   ]
pprint.pprint(processed_corpus)

Çıktı

[
   ['toolkit'],
   ['free', 'toolkit'],
   ['deep', 'learning', 'like'],
   ['free', 'on', 'tutorialspoint.com'],
   ['tutorialspoint.com', 'on', 'like', 'deep', 'learning', 'learning', 'free']
]

Şimdi bunu corpora.dictionary() külliyatımızdaki benzersiz nesneleri elde etmek için nesne -

dictionary = corpora.Dictionary(processed_corpus)
print(dictionary)

Çıktı

Dictionary(7 unique tokens: ['toolkit', 'free', 'deep', 'learning', 'like']...)

Daha sonra, aşağıdaki kod satırı, külliyatımız için Kelime Çantası modelini oluşturacaktır -

BoW_corpus = [dictionary.doc2bow(text) for text in processed_corpus]
pprint.pprint(BoW_corpus)

Çıktı

[
   [(0, 1)],
   [(0, 1), (1, 1)],
   [(2, 1), (3, 1), (4, 1)],
   [(1, 1), (5, 1), (6, 1)],
   [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1)]
]

Adım 2: Bir Dönüşüm Yaratmak

Dönüşümler bazı standart Python nesneleridir. Bu dönüşümleri, yani Python nesnelerini eğitimli bir külliyat kullanarak başlatabiliriz. Burada kullanacağıztf-idf eğitilmiş külliyatımızın bir dönüşümünü yaratmak için model BoW_corpus.

Öncelikle model paketini gensim'den ithal etmemiz gerekiyor.

from gensim import models

Şimdi, modeli aşağıdaki gibi başlatmamız gerekiyor -

tfidf = models.TfidfModel(BoW_corpus)

Adım 3: Vektörleri Dönüştürme

Şimdi, bu son adımda, vektörler eski temsilden yeni gösterime dönüştürülecek. Yukarıdaki adımda tfidf modelini başlattığımız için, tfidf artık salt okunur bir nesne olarak ele alınacaktır. Burada, bu tfidf nesnesini kullanarak vektörümüzü kelime gösterimi torbasından (eski temsil) Tfidf gerçek değerli ağırlıklara (yeni temsil) dönüştüreceğiz.

doc_BoW = [(1,1),(3,1)]
print(tfidf[doc_BoW]

Çıktı

[(1, 0.4869354917707381), (3, 0.8734379353188121)]

Dönüşümü külliyatın iki değerine uyguladık, ancak bunu tüm külliyat için de şu şekilde uygulayabiliriz -

corpus_tfidf = tfidf[BoW_corpus]
for doc in corpus_tfidf:
   print(doc)

Çıktı

[(0, 1.0)]
[(0, 0.8734379353188121), (1, 0.4869354917707381)]
[(2, 0.5773502691896257), (3, 0.5773502691896257), (4, 0.5773502691896257)]
[(1, 0.3667400603126873), (5, 0.657838022678017), (6, 0.657838022678017)]
[
   (1, 0.19338287240886842), (2, 0.34687949360312714), (3, 0.6937589872062543), 
   (4, 0.34687949360312714), (5, 0.34687949360312714), (6, 0.34687949360312714)
]

Eksiksiz Uygulama Örneği

import gensim
import pprint
from collections import defaultdict
from gensim import corpora
t_corpus = [
   "CNTK formerly known as Computational Network Toolkit", 
   "is a free easy-to-use open-source commercial-grade toolkit", 
   "that enable us to train deep learning algorithms to learn like the human brain.", 
   "You can find its free tutorial on tutorialspoint.com", 
   "Tutorialspoint.com also provide best technical tutorials on 
   technologies like AI deep learning machine learning for free"
]
stoplist = set('for a of the and to in'.split(' '))
processed_corpus = [
   [word for word in document.lower().split() if word not in stoplist]
   for document in t_corpus
]
frequency = defaultdict(int)
for text in processed_corpus:
   for token in text:
      frequency[token] += 1
   processed_corpus = [
      [token for token in text if frequency[token] > 1] 
      for text in processed_corpus
   ]
pprint.pprint(processed_corpus)
dictionary = corpora.Dictionary(processed_corpus)
print(dictionary)
BoW_corpus = [dictionary.doc2bow(text) for text in processed_corpus]
pprint.pprint(BoW_corpus)
   from gensim import models
   tfidf = models.TfidfModel(BoW_corpus)
   doc_BoW = [(1,1),(3,1)]
   print(tfidf[doc_BoW])
   corpus_tfidf = tfidf[BoW_corpus]
   for doc in corpus_tfidf:
print(doc)

Gensim'de Çeşitli Dönüşümler

Gensim'i kullanarak, çeşitli popüler dönüşümleri, yani Vektör Uzay Modeli algoritmalarını uygulayabiliriz. Bunlardan bazıları aşağıdaki gibidir -

Tf-Idf (Terim Frekansı-Ters Belge Frekansı)

Başlatma sırasında, bu tf-idf model algoritması, tamsayı değerlerine sahip bir eğitim külliyatını bekler (Kelime Çantası modeli gibi). Bundan sonra, dönüşüm sırasında bir vektör gösterimi alır ve başka bir vektör gösterimi döndürür.

Çıktı vektörü aynı boyutluluğa sahip olacak ancak nadir özelliklerin değeri (eğitim sırasında) artacaktır. Temel olarak tamsayı değerli vektörleri gerçek değerli vektörlere dönüştürür. Tf-idf dönüşümünün sözdizimi aşağıdadır -

Model=models.TfidfModel(corpus, normalize=True)

LSI (Gizli Anlamsal İndeksleme)

LSI model algoritması, belgeyi tamsayı değerli vektör modelinden (Kelime Torbası modeli gibi) veya Tf-Idf ağırlıklı uzaydan gizli uzaya dönüştürebilir. Çıktı vektörü daha düşük boyutta olacaktır. LSI dönüşümünün sözdizimi aşağıdadır -

Model=models.LsiModel(tfidf_corpus, id2word=dictionary, num_topics=300)

LDA (Gizli Dirichlet Tahsisi)

LDA model algoritması, belgeyi Kelime Çantası model alanından bir konu alanına dönüştüren başka bir algoritmadır. Çıktı vektörü daha düşük boyutta olacaktır. LSI dönüşümünün sözdizimi aşağıdadır -

Model=models.LdaModel(corpus, id2word=dictionary, num_topics=100)

Rastgele Tahminler (RP)

Çok verimli bir yaklaşım olan RP, vektör uzayının boyutsallığını azaltmayı amaçlamaktadır. Bu yaklaşım, temelde belgeler arasındaki Tf-Idf mesafelerini yaklaşık olarak gösterir. Bunu biraz rasgele atarak yapar.

Model=models.RpModel(tfidf_corpus, num_topics=500)

Hiyerarşik Dirichlet Süreci (HDP)

HDP, Gensim'e yeni eklenen parametrik olmayan bir Bayes yöntemidir. Kullanırken dikkatli olmalıyız.

Model=models.HdpModel(corpus, id2word=dictionary

Burada Gensim yardımıyla Terim Frekans-Ters Belge Frekans (TF-IDF) Matrisi oluşturmayı öğreneceğiz.

TF-IDF nedir?

Aynı zamanda bir kelime torbası modeli olan Terim Frekansı-Ters Doküman Frekansı modelidir. Düzenli külliyattan farklıdır çünkü belirteçlerin ağırlığını azaltır, yani belgeler arasında sıkça görünen sözcükler. Başlatma sırasında, bu tf-idf model algoritması, tamsayı değerlerine sahip bir eğitim külliyatını bekler (Kelime Çantası modeli gibi).

Bundan sonra, dönüşüm anında bir vektör gösterimi alır ve başka bir vektör gösterimi döndürür. Çıktı vektörü aynı boyutluluğa sahip olacak ancak nadir özelliklerin değeri (eğitim sırasında) artacaktır. Temel olarak tamsayı değerli vektörleri gerçek değerli vektörlere dönüştürür.

Nasıl Hesaplanır?

TF-IDF modeli, iki basit adımı takip ederek tfidf'yi hesaplar -

Adım 1: Yerel ve genel bileşeni çarpma

Bu ilk adımda, model TF (Terim Frekansı) gibi yerel bir bileşeni IDF (Ters Belge Frekansı) gibi global bir bileşenle çarpacaktır.

Adım 2: Sonucu Normalleştirin

Çarpma ile yapıldığında, bir sonraki adımda TFIDF modeli sonucu birim uzunluğa göre normalleştirecektir.

Yukarıdaki iki adımın bir sonucu olarak, belgeler arasında sıkça meydana gelen sözcüklerin ağırlığı düşecektir.

TF-IDF Ağırlıkları nasıl alınır?

Burada, TF-IDF ağırlıklarını nasıl elde edebileceğimizi görmek için bir örnek uygulayacağız. Temel olarak, TF-IDF ağırlıklarını elde etmek için önce külliyatın eğitimini vermemiz ve sonra bu külliyatı tfidf modelinde uygulamamız gerekir.

Corpus'u eğitin

Yukarıda belirtildiği gibi, TF-IDF'yi almak için önce külliyatımızı eğitmemiz gerekir. Öncelikle, gerekli tüm paketleri aşağıdaki gibi içe aktarmamız gerekiyor -

import gensim
import pprint
from gensim import corpora
from gensim.utils import simple_preprocess

Şimdi cümleleri içeren listeyi sağlayın. Listemizde üç cümle var -

doc_list = [
   "Hello, how are you?", "How do you do?", 
   "Hey what are you doing? yes you What are you doing?"
]

Ardından, cümleleri aşağıdaki gibi belirtiniz:

doc_tokenized = [simple_preprocess(doc) for doc in doc_list]

Bir nesne oluştur corpora.Dictionary() aşağıdaki gibi -

dictionary = corpora.Dictionary()

Şimdi bu belirtilmiş cümleleri dictionary.doc2bow() aşağıdaki gibi nesne -

BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]

Daha sonra, belgelerimizde kimlikleri ve frekanslarını alacağız.

for doc in BoW_corpus:
   print([[dictionary[id], freq] for id, freq in doc])

Çıktı

[['are', 1], ['hello', 1], ['how', 1], ['you', 1]]
[['how', 1], ['you', 1], ['do', 2]]
[['are', 2], ['you', 3], ['doing', 2], ['hey', 1], ['what', 2], ['yes', 1]]

Bu şekilde, külliyatımızı (Kelime Çantası külliyatını) eğitmiş olduk.

Daha sonra, bu eğitimli derlemi tfidf modeli içinde uygulamalıyız. models.TfidfModel().

Önce numpay paketini içe aktarın -

import numpy as np

Şimdi eğitilmiş külliyatımızı (BoW_corpus) köşeli parantezler içinde uygulayarak models.TfidfModel()

tfidf = models.TfidfModel(BoW_corpus, smartirs='ntc')

Sonra, tfidf modellenmiş külliyatımızda kimlikler kelimesini ve frekanslarını alacağız -

for doc in tfidf[BoW_corpus]:
   print([[dictionary[id], np.around(freq,decomal=2)] for id, freq in doc])

Çıktı

[['are', 0.33], ['hello', 0.89], ['how', 0.33]]
[['how', 0.18], ['do', 0.98]]
[['are', 0.23], ['doing', 0.62], ['hey', 0.31], ['what', 0.62], ['yes', 0.31]]

[['are', 1], ['hello', 1], ['how', 1], ['you', 1]]
[['how', 1], ['you', 1], ['do', 2]]
[['are', 2], ['you', 3], ['doing', 2], ['hey', 1], ['what', 2], ['yes', 1]]

[['are', 0.33], ['hello', 0.89], ['how', 0.33]]
[['how', 0.18], ['do', 0.98]]
[['are', 0.23], ['doing', 0.62], ['hey', 0.31], ['what', 0.62], ['yes', 0.31]]

Yukarıdaki çıktılardan belgelerimizdeki kelimelerin frekanslarındaki farklılığı görüyoruz.

Eksiksiz Uygulama Örneği

import gensim
import pprint
from gensim import corpora
from gensim.utils import simple_preprocess
doc_list = [
   "Hello, how are you?", "How do you do?", 
   "Hey what are you doing? yes you What are you doing?"
]
doc_tokenized = [simple_preprocess(doc) for doc in doc_list]
dictionary = corpora.Dictionary()
BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]
for doc in BoW_corpus:
   print([[dictionary[id], freq] for id, freq in doc])
import numpy as np
tfidf = models.TfidfModel(BoW_corpus, smartirs='ntc')
for doc in tfidf[BoW_corpus]:
   print([[dictionary[id], np.around(freq,decomal=2)] for id, freq in doc])

Sözcük Ağırlığı Farkı

Yukarıda tartışıldığı gibi, belgede daha sık yer alacak sözcükler daha küçük ağırlıkları alacaktır. Yukarıdaki iki çıktıdan kelimelerin ağırlıklarındaki farkı anlayalım. Kelime‘are’iki belgede oluşur ve ağırlıklandırılmıştır. Benzer şekilde, kelime‘you’ tüm belgelerde görünür ve tamamen kaldırılır.

Bu bölüm, Gensim ile ilgili konu modellemesini ele almaktadır.

Verilerimize açıklama eklemek ve cümle yapısını anlamak için en iyi yöntemlerden biri hesaplamalı dil algoritmaları kullanmaktır. Hiç şüphe yok ki, bu hesaplamalı dilbilimsel algoritmaların yardımıyla verilerimiz hakkında daha ince ayrıntıları anlayabiliriz, ancak

• Külliyatımızda hangi tür kelimelerin diğerlerinden daha sık göründüğünü bilebilir miyiz?

• Verilerimizi gruplayabilir miyiz?

• Verilerimizin altında yatan temalar olabilir miyiz?

Bütün bunları konu modelleme yardımıyla başarabilirdik. Şimdi konu modelleri kavramına derinlemesine bakalım.

Konu Modelleri nedir?

Konu modeli, metnimizdeki konular hakkında bilgi içeren olasılıksal model olarak tanımlanabilir. Ancak burada, aşağıdaki gibi iki önemli soru ortaya çıkıyor:

İlk, what exactly a topic is?

Adından da anlaşılacağı gibi konu, metnimizde temsil edilen temel fikirler veya temalardır. Size bir örnek vermek gerekirse, içeren külliyatnewspaper articles ile ilgili konular olurdu finance, weather, politics, sports, various states news ve bunun gibi.

İkinci, what is the importance of topic models in text processing?

Bildiğimiz gibi, metindeki benzerliği tespit etmek için kelimeler kullanarak bilgi alma ve arama teknikleri yapabiliriz. Ancak konu modellerinin yardımıyla artık metin dosyalarımızı kelimeler yerine konuları kullanarak arayabilir ve düzenleyebiliriz.

Bu anlamda konuların kelimelerin olasılıksal dağılımı olduğunu söyleyebiliriz. Bu nedenle, konu modellerini kullanarak, belgelerimizi konuların olasılık dağılımları olarak tanımlayabiliriz.

Konu Modellerinin Hedefleri

Yukarıda tartışıldığı gibi, konu modellemenin odak noktası, temelde yatan fikirler ve temalarla ilgilidir. Ana hedefleri aşağıdaki gibidir -

• Konu modelleri, metin özetlemesi için kullanılabilir.

• Belgeleri düzenlemek için kullanılabilirler. Örneğin, haber makalelerini, ilgili tüm haber makalelerini organize etmek gibi organize / birbirine bağlı bir bölümde gruplamak için konu modellemeyi kullanabiliriz.cricket.

• Arama sonuçlarını iyileştirebilirler. Nasıl? Bir arama sorgusu için, farklı anahtar kelimelerin karışımına sahip belgeyi ortaya çıkarmak için konu modellerini kullanabiliriz, ancak bunlar aynı fikirdir.

• Öneriler kavramı pazarlama için çok kullanışlıdır. Çeşitli çevrimiçi alışveriş siteleri, haber siteleri ve çok daha fazlası tarafından kullanılmaktadır. Konu modelleri, ne satın alınacağı, daha sonra ne okunacağı vb. Konularda tavsiyelerde bulunmaya yardımcı olur. Bunu, listede ortak bir konuya sahip materyaller bularak yaparlar.

Gensim'de Konu Modelleme Algoritmaları

Kuşkusuz, Gensim en popüler konu modelleme araç setidir. Ücretsiz olması ve Python'da olması onu daha popüler hale getiriyor. Bu bölümde, en popüler konu modelleme algoritmalarından bazılarını tartışacağız. Burada 'nasıl' yerine 'neye' odaklanacağız çünkü Gensim bunları bizim için çok iyi soyutlıyor.

Gizli Dirichlet Tahsisi (LDA)

Latent Dirichlet tahsisi (LDA), konu modellemesi için şu anda kullanılan en yaygın ve popüler tekniktir. Facebook araştırmacılarının 2013'te yayımlanan araştırma makalelerinde kullandıkları budur. İlk olarak 2003 yılında David Blei, Andrew Ng ve Michael Jordan tarafından önerilmiştir. Basitçe başlıklı makalelerinde LDA'yı önerdiler.Latent Dirichlet allocation.

LDA'nın özellikleri

Özellikleri aracılığıyla bu harika teknik hakkında daha fazla bilgi sahibi olalım -

Probabilistic topic modeling technique

LDA, olasılığa dayalı bir konu modelleme tekniğidir. Yukarıda tartıştığımız gibi, konu modellemesinde, birbiriyle ilişkili herhangi bir belge koleksiyonunda (akademik makaleler, gazete makaleleri, Facebook gönderileri, Tweetler, e-postalar vb. Olabilir), her belgede yer alan bazı konu kombinasyonları olduğunu varsayıyoruz. .

Olasılıklı konu modellemesinin temel amacı, birbiriyle ilişkili belgelerin toplanması için gizli konu yapısını keşfetmektir. Aşağıdaki üç şey genellikle bir konu yapısına dahil edilir -

• Topics

• Konuların belgeler arasında istatistiksel dağılımı

• Konuyu içeren bir belgedeki kelimeler

Work in an unsupervised way

LDA, denetimsiz bir şekilde çalışır. Bunun nedeni, LDA'nın gizli konu yapısını keşfetmek için koşullu olasılıkları kullanmasıdır. Konuların birbiriyle ilişkili belgelerin koleksiyonunda eşit olmayan bir şekilde dağıldığını varsayar.

Very easy to create it in Gensim

Gensim'de LDA modeli oluşturmak çok kolaydır. sadece külliyat, sözlük eşlemesi ve modelimizde kullanmak istediğimiz konuların sayısını belirtmemiz gerekiyor.

Model=models.LdaModel(corpus, id2word=dictionary, num_topics=100)

May face computationally intractable problem

Olası her konu yapısının olasılığını hesaplamak, LDA'nın karşılaştığı hesaplama zorluğudur. Bu zordur, çünkü olası her konu yapısı altında gözlemlenen her kelimenin olasılığını hesaplaması gerekir. Çok sayıda konu ve kelimemiz varsa, LDA hesaplama açısından çetin bir problemle karşılaşabilir.

Gizli Anlamsal İndeksleme (LSI)

İlk olarak Gensim'de uygulanan konu modelleme algoritmaları Latent Dirichlet Allocation (LDA) dır-dir Latent Semantic Indexing (LSI). Aynı zamandaLatent Semantic Analysis (LSA).

1988'de Scott Deerwester, Susan Dumais, George Furnas, Richard Harshman, Thomas Landaur, Karen Lochbaum ve Lynn Streeter tarafından patenti alındı. Bu bölümde LSI modelimizi kuracağız. LDA modelini kurmakla aynı şekilde yapılabilir. LSI modelini şuradan içe aktarmamız gerekiyor:gensim.models.

LSI'nin Rolü

Aslında, LSI, özellikle dağıtımsal anlambilimde bir teknik NLP'dir. Bir dizi belge ile bu belgelerin içerdiği terimler arasındaki ilişkiyi analiz eder. Çalışması hakkında konuşursak, o zaman büyük bir metin parçasından belge başına kelime sayısını içeren bir matris oluşturur.

LSI modeli, oluşturulduktan sonra satır sayısını azaltmak için tekil değer ayrıştırması (SVD) adı verilen matematiksel bir teknik kullanır. Sıra sayısını azaltmanın yanı sıra, sütunlar arasındaki benzerlik yapısını da korur. Matriste, satırlar benzersiz kelimeleri ve sütunlar her belgeyi temsil eder. Dağılım hipotezine dayalı olarak çalışır, yani anlamı yakın olan kelimelerin aynı tür metinde yer alacağını varsayar.

Model=models.LsiModel(corpus, id2word=dictionary, num_topics=100)

Hiyerarşik Dirichlet Süreci (HDP)

LDA ve LSI gibi konu modelleri, elle analiz edilmesi mümkün olmayan büyük metin arşivlerinin özetlenmesine ve düzenlenmesine yardımcı olur. LDA ve LSI dışında, Gensim'deki bir diğer güçlü konu modeli HDP'dir (Hiyerarşik Dirichlet Süreci). Temelde gruplanmış verilerin denetimsiz analizi için karma üyelik modelidir. LDA'nın (sonlu muadili) aksine, HDP verilerden konu sayısını çıkarıyor.

Model=models.HdpModel(corpus, id2word=dictionary

Bu bölüm, Gensim'de Latent Dirichlet tahsisi (LDA) konu modelini nasıl oluşturacağınızı öğrenmenize yardımcı olacaktır.

NLP'nin (doğal dil işleme) birincil uygulamalarından birinde büyük hacimli metinlerden konular hakkında otomatik olarak bilgi ayıklama. Otel incelemeleri, tweet'ler, Facebook gönderileri, diğer sosyal medya kanallarından beslemeler, film incelemeleri, haberler, kullanıcı geri bildirimleri, e-postalar vb. Gibi büyük hacimli metinler olabilir.

Bu dijital çağda, insanların / müşterilerin ne hakkında konuştuğunu bilmek, fikirlerini ve sorunlarını anlamak işletmeler, politik kampanyalar ve yöneticiler için çok değerli olabilir. Ancak, bu kadar büyük hacimli metinleri manuel olarak okumak ve ardından konulardaki bilgileri çıkarmak mümkün müdür?

Hayır değil. Bu büyük hacimli metin belgelerini okuyabilen ve ondan tartışılan gerekli bilgileri / konuları otomatik olarak çıkarabilen otomatik bir algoritma gerektirir.

LDA'nın Rolü

LDA'nın konu modellemeye yaklaşımı, bir belgedeki metni belirli bir konuya göre sınıflandırmaktır. Dirichlet dağıtımları olarak modellenen LDA, -

• Belge modeli başına bir konu ve
• Konu modeli başına kelime

LDA konu modeli algoritmasını sağladıktan sonra, konu-anahtar kelime dağılımının iyi bir bileşimini elde etmek için yeniden düzenler -

• Belge içindeki konu dağılımları ve
• Konular içinde anahtar kelime dağılımı

İşleme sırasında, LDA tarafından yapılan varsayımlardan bazıları -

• Her belge, konuların çoklu nominal dağılımları olarak modellenmiştir.
• Her konu, kelimelerin çoklu nominal dağılımları olarak modellenmiştir.
• Doğru veri külliyatını seçmeliyiz çünkü LDA, her metin parçasının ilgili kelimeleri içerdiğini varsayar.
• LDA ayrıca belgelerin farklı konulardan üretildiğini varsayar.

Gensim ile Uygulama

Burada, doğal olarak tartışılan konuları veri kümesinden çıkarmak için LDA (Latent Dirichlet Allocation) kullanacağız.

Veri Kümesi Yükleniyor

Kullanacağımız veri seti, veri setidir. ’20 Newsgroups’bir haberin çeşitli bölümlerinden binlerce haber makalesine sahip olmak. Altında mevcutturSklearnveri kümeleri. Aşağıdaki Python betiğinin yardımıyla kolayca indirebiliriz -

from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')

Aşağıdaki komut dosyası yardımıyla bazı örnek haberlere bakalım -

newsgroups_train.data[:4]

["From: [email protected] (where's my thing)\nSubject: 
WHAT car is this!?\nNntp-Posting-Host: rac3.wam.umd.edu\nOrganization: 
University of Maryland, College Park\nLines: 
15\n\n I was wondering if anyone out there could enlighten me on this car 
I saw\nthe other day. It was a 2-door sports car, looked to be from the 
late 60s/\nearly 70s. It was called a Bricklin. The doors were really small. 
In addition,\nthe front bumper was separate from the rest of the body. 
This is \nall I know. If anyone can tellme a model name, 
engine specs, years\nof production, where this car is made, history, or 
whatever info you\nhave on this funky looking car, please e-mail.\n\nThanks,
\n- IL\n ---- brought to you by your neighborhood Lerxst ----\n\n\n\n\n",

"From: [email protected] (Guy Kuo)\nSubject: SI Clock Poll - Final 
Call\nSummary: Final call for SI clock reports\nKeywords: 
SI,acceleration,clock,upgrade\nArticle-I.D.: shelley.1qvfo9INNc3s\nOrganization: 
University of Washington\nLines: 11\nNNTP-Posting-Host: carson.u.washington.edu\n\nA 
fair number of brave souls who upgraded their SI clock oscillator have\nshared their 
experiences for this poll. Please send a brief message detailing\nyour experiences with 
the procedure. Top speed attained, CPU rated speed,\nadd on cards and adapters, heat 
sinks, hour of usage per day, floppy disk\nfunctionality with 800 and 1.4 m floppies 
are especially requested.\n\nI will be summarizing in the next two days, so please add 
to the network\nknowledge base if you have done the clock upgrade and haven't answered 
this\npoll. Thanks.\n\nGuy Kuo <;[email protected]>\n",

'From: [email protected] (Thomas E Willis)\nSubject: 
PB questions...\nOrganization: Purdue University Engineering 
Computer Network\nDistribution: usa\nLines: 36\n\nwell folks, 
my mac plus finally gave up the ghost this weekend after\nstarting 
life as a 512k way back in 1985. sooo, i\'m in the market for 
a\nnew machine a bit sooner than i intended to be...\n\ni\'m looking 
into picking up a powerbook 160 or maybe 180 and have a bunch\nof 
questions that (hopefully) somebody can answer:\n\n* does anybody 
know any dirt on when the next round of powerbook\nintroductions 
are expected? i\'d heard the 185c was supposed to make an\nappearence 
"this summer" but haven\'t heard anymore on it - and since i\ndon\'t 
have access to macleak, i was wondering if anybody out there had\nmore 
info...\n\n* has anybody heard rumors about price drops to the powerbook 
line like the\nones the duo\'s just went through recently?\n\n* what\'s 
the impression of the display on the 180? i could probably swing\na 180 
if i got the 80Mb disk rather than the 120, but i don\'t really have\na 
feel for how much "better" the display is (yea, it looks great in the\nstore, 
but is that all "wow" or is it really that good?). could i solicit\nsome 
opinions of people who use the 160 and 180 day-to-day on if its
worth\ntaking the disk size and money hit to get the active display? 
(i realize\nthis is a real subjective question, but i\'ve only played around 
with the\nmachines in a computer store breifly and figured the opinions 
of somebody\nwho actually uses the machine daily might prove helpful).\n\n* 
how well does hellcats perform? ;)\n\nthanks a bunch in advance for any info - 
if you could email, i\'ll post a\nsummary (news reading time is at a premium 
with finals just around the\ncorner... :
( )\n--\nTom Willis \\ [email protected] \\ Purdue Electrical 
Engineering\n---------------------------------------------------------------------------\
n"Convictions are more dangerous enemies of truth than lies." - F. W.\nNietzsche\n',

'From: jgreen@amber (Joe Green)\nSubject: Re: Weitek P9000 ?\nOrganization: 
Harris Computer Systems Division\nLines: 14\nDistribution: world\nNNTP-Posting-Host: 
amber.ssd.csd.harris.com\nX-Newsreader: TIN [version 1.1 PL9]\n\nRobert 
J.C. Kyanko ([email protected]) wrote:\n >[email protected] writes in article 
<[email protected] >:\n> > Anyone know about the 
Weitek P9000 graphics chip?\n > As far as the low-level stuff goes, it looks 
pretty nice. It\'s got this\n> quadrilateral fill command that requires just 
the four points.\n\nDo you have Weitek\'s address/phone number? I\'d like to get 
some information\nabout this chip.\n\n--\nJoe Green\t\t\t\tHarris 
Corporation\[email protected]\t\t\tComputer Systems Division\n"The only 
thing that really scares me is a person with no sense of humor.
"\n\t\t\t\t\t\t-- Jonathan Winters\n']

Önkoşul

NLTK'dan Stopwords'e ve Scapy'den English modeline ihtiyacımız var. Her ikisi de aşağıdaki şekilde indirilebilir -

import nltk;
nltk.download('stopwords')
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])

Gerekli Paketleri İçe Aktarmak

LDA modelini oluşturmak için aşağıdaki gerekli paketi içe aktarmamız gerekiyor -

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import pyLDAvis
import pyLDAvis.gensim
import matplotlib.pyplot as plt

Engellenecek Kelimeler Hazırlanıyor

Şimdi, Engellenecek Kelimeleri içe aktarmalı ve kullanmalıyız -

from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])

Metni Temizle

Şimdi Gensim'in yardımıyla simple_preprocess()her cümleyi bir kelime listesi şeklinde belirtmeliyiz. Ayrıca noktalama işaretlerini ve gereksiz karakterleri de kaldırmalıyız. Bunu yapmak için adında bir fonksiyon oluşturacağızsent_to_words() -

def sent_to_words(sentences):
   for sentence in sentences:
      yield(gensim.utils.simple_preprocess(str(sentence), deacc=True))
data_words = list(sent_to_words(data))

Bigram ve Trigram Modelleri Oluşturma

Bildiğimiz gibi, bigramlar belgede sıklıkla birlikte geçen iki sözcük ve trigram, belgede sıklıkla birlikte geçen üç sözcüktür. Gensim'in yardımıylaPhrases model, bunu yapabiliriz -

bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)

Engellenecek Kelimeleri filtreleyin

Sonra, Engellenecek Kelimeleri filtrelememiz gerekiyor. Bununla birlikte, bigrams, trigrams ve lemmatizasyon yapmak için işlevler de yaratacağız -

def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc))
if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   return [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
     doc = nlp(" ".join(sent))
     texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
   return texts_out

Konu Modeli İçin Sözlük ve Topluluk Oluşturma

Şimdi sözlük ve külliyat oluşturmamız gerekiyor. Bunu önceki örneklerde de yaptık -

id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]

LDA Konu Modeli Oluşturma

LDA modelini eğitmek için gereken her şeyi zaten uyguladık. Şimdi, LDA konu modelini oluşturmanın zamanı geldi. Uygulama örneğimiz için, aşağıdaki kod satırı yardımı ile yapılabilir -

lda_model = gensim.models.ldamodel.LdaModel(
   corpus=corpus, id2word=id2word, num_topics=20, random_state=100, 
   update_every=1, chunksize=100, passes=10, alpha='auto', per_word_topics=True
)

Uygulama Örneği

LDA konu modelini oluşturmak için eksiksiz uygulama örneğini görelim -

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import pyLDAvis
import pyLDAvis.gensim
import matplotlib.pyplot as plt
from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])
from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')
data = newsgroups_train.data
data = [re.sub('\S*@\S*\s?', '', sent) for sent in data]
data = [re.sub('\s+', ' ', sent) for sent in data]
data = [re.sub("\'", "", sent) for sent in data]
print(data_words[:4]) #it will print the data after prepared for stopwords
bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)
def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc)) 
   if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
      doc = nlp(" ".join(sent))
      texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
   return texts_out
data_words_nostops = remove_stopwords(data_words)
data_words_bigrams = make_bigrams(data_words_nostops)
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])
data_lemmatized = lemmatization(data_words_bigrams, allowed_postags=[
   'NOUN', 'ADJ', 'VERB', 'ADV'
])
print(data_lemmatized[:4]) #it will print the lemmatized data.
id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]
print(corpus[:4]) #it will print the corpus we created above.
[[(id2word[id], freq) for id, freq in cp] for cp in corpus[:4]] 
#it will print the words with their frequencies.
lda_model = gensim.models.ldamodel.LdaModel(
   corpus=corpus, id2word=id2word, num_topics=20, random_state=100, 
   update_every=1, chunksize=100, passes=10, alpha='auto', per_word_topics=True
)

Şimdi, Model Şaşkınlığını hesaplamak için konuları elde etmek için yukarıda oluşturulan LDA modelini kullanabiliriz.

Bu bölümde, Latent Dirichlet Allocation (LDA) konu modelinin nasıl kullanılacağını anlayacağız.

LDA Modelinde Konuları Görüntüleme

Yukarıda oluşturduğumuz LDA modeli (lda_model) dokümanlardan konuları görüntülemek için kullanılabilir. Aşağıdaki komut dosyası yardımı ile yapılabilir -

pprint(lda_model.print_topics())
doc_lda = lda_model[corpus]

Çıktı

[
   (0, 
   '0.036*"go" + 0.027*"get" + 0.021*"time" + 0.017*"back" + 0.015*"good" + '
   '0.014*"much" + 0.014*"be" + 0.013*"car" + 0.013*"well" + 0.013*"year"'),
   (1,
   '0.078*"screen" + 0.067*"video" + 0.052*"character" + 0.046*"normal" + '
   '0.045*"mouse" + 0.034*"manager" + 0.034*"disease" + 0.031*"processor" + '
   '0.028*"excuse" + 0.028*"choice"'),
   (2,
   '0.776*"ax" + 0.079*"_" + 0.011*"boy" + 0.008*"ticket" + 0.006*"red" + '
   '0.004*"conservative" + 0.004*"cult" + 0.004*"amazing" + 0.003*"runner" + '
   '0.003*"roughly"'),
   (3,
   '0.086*"season" + 0.078*"fan" + 0.072*"reality" + 0.065*"trade" + '
   '0.045*"concept" + 0.040*"pen" + 0.028*"blow" + 0.025*"improve" + '
   '0.025*"cap" + 0.021*"penguin"'),
   (4,
   '0.027*"group" + 0.023*"issue" + 0.016*"case" + 0.016*"cause" + '
   '0.014*"state" + 0.012*"whole" + 0.012*"support" + 0.011*"government" + '
   '0.010*"year" + 0.010*"rate"'),
   (5,
   '0.133*"evidence" + 0.047*"believe" + 0.044*"religion" + 0.042*"belief" + '
   '0.041*"sense" + 0.041*"discussion" + 0.034*"atheist" + 0.030*"conclusion" +
   '
   '0.029*"explain" + 0.029*"claim"'),
   (6,
   '0.083*"space" + 0.059*"science" + 0.031*"launch" + 0.030*"earth" + '
   '0.026*"route" + 0.024*"orbit" + 0.024*"scientific" + 0.021*"mission" + '
   '0.018*"plane" + 0.017*"satellite"'),
   (7,
   '0.065*"file" + 0.064*"program" + 0.048*"card" + 0.041*"window" + '
   '0.038*"driver" + 0.037*"software" + 0.034*"run" + 0.029*"machine" + '
   '0.029*"entry" + 0.028*"version"'),
   (8,
   '0.078*"publish" + 0.059*"mount" + 0.050*"turkish" + 0.043*"armenian" + '
   '0.027*"western" + 0.026*"russian" + 0.025*"locate" + 0.024*"proceed" + '
   '0.024*"electrical" + 0.022*"terrorism"'),
   (9,
   '0.023*"people" + 0.023*"child" + 0.021*"kill" + 0.020*"man" + 0.019*"death" '
   '+ 0.015*"die" + 0.015*"live" + 0.014*"attack" + 0.013*"age" + '
   '0.011*"church"'),
   (10,
   '0.092*"cpu" + 0.085*"black" + 0.071*"controller" + 0.039*"white" + '
   '0.028*"water" + 0.027*"cold" + 0.025*"solid" + 0.024*"cool" + 0.024*"heat" '
   '+ 0.023*"nuclear"'),
   (11,
   '0.071*"monitor" + 0.044*"box" + 0.042*"option" + 0.041*"generate" + '
   '0.038*"vote" + 0.032*"battery" + 0.029*"wave" + 0.026*"tradition" + '
   '0.026*"fairly" + 0.025*"task"'),
   (12,
   '0.048*"send" + 0.045*"mail" + 0.036*"list" + 0.033*"include" + '
   '0.032*"price" + 0.031*"address" + 0.027*"email" + 0.026*"receive" + '
   '0.024*"book" + 0.024*"sell"'),
   (13,
   '0.515*"drive" + 0.052*"laboratory" + 0.042*"blind" + 0.020*"investment" + '
   '0.011*"creature" + 0.010*"loop" + 0.005*"dialog" + 0.000*"slave" + '
   '0.000*"jumper" + 0.000*"sector"'),
   (14,
   '0.153*"patient" + 0.066*"treatment" + 0.062*"printer" + 0.059*"doctor" + '

   '0.036*"medical" + 0.031*"energy" + 0.029*"study" + 0.029*"probe" + '
   '0.024*"mph" + 0.020*"physician"'),
   (15,
   '0.068*"law" + 0.055*"gun" + 0.039*"government" + 0.036*"right" + '
   '0.029*"state" + 0.026*"drug" + 0.022*"crime" + 0.019*"person" + '
   '0.019*"citizen" + 0.019*"weapon"'),
   (16,
   '0.107*"team" + 0.102*"game" + 0.078*"play" + 0.055*"win" + 0.052*"player" + '
   '0.051*"year" + 0.030*"score" + 0.025*"goal" + 0.023*"wing" + 0.023*"run"'),
   (17,
   '0.031*"say" + 0.026*"think" + 0.022*"people" + 0.020*"make" + 0.017*"see" + '
   '0.016*"know" + 0.013*"come" + 0.013*"even" + 0.013*"thing" + 0.013*"give"'),
   (18,
   '0.039*"system" + 0.034*"use" + 0.023*"key" + 0.016*"bit" + 0.016*"also" + '
   '0.015*"information" + 0.014*"source" + 0.013*"chip" + 0.013*"available" + '
   '0.010*"provide"'),
   (19,
   '0.085*"line" + 0.073*"write" + 0.053*"article" + 0.046*"organization" + '
   '0.034*"host" + 0.023*"be" + 0.023*"know" + 0.017*"thank" + 0.016*"want" + '
   '0.014*"help"')
]

Hesaplama Modeli Şaşkınlığı

Yukarıda oluşturduğumuz LDA modeli (lda_model) modelin şaşkınlığını yani modelin ne kadar iyi olduğunu hesaplamak için kullanılabilir. Puan ne kadar düşükse model o kadar iyi olacaktır. Aşağıdaki komut dosyası yardımı ile yapılabilir -

print('\nPerplexity: ', lda_model.log_perplexity(corpus))

Çıktı

Perplexity: -12.338664984332151

Tutarlılık Puanını Hesaplama

LDA modeli (lda_model)Yukarıda oluşturduğumuz modelin tutarlılık puanını yani konudaki kelimelerin ikili kelime benzerlik puanlarının ortalama / medyanını hesaplamak için kullanılabilir. Aşağıdaki komut dosyası yardımı ile yapılabilir -

coherence_model_lda = CoherenceModel(
   model=lda_model, texts=data_lemmatized, dictionary=id2word, coherence='c_v'
)
coherence_lda = coherence_model_lda.get_coherence()
print('\nCoherence Score: ', coherence_lda)

Çıktı

Coherence Score: 0.510264381411751

Konu-Anahtar Kelimeleri Görselleştirme

LDA modeli (lda_model)Yukarıda oluşturduğumuz, üretilen konuları ve ilgili anahtar kelimeleri incelemek için kullanılabilir. Kullanılarak görselleştirilebilirpyLDAvisaşağıdaki gibi paket -

pyLDAvis.enable_notebook()
vis = pyLDAvis.gensim.prepare(lda_model, corpus, id2word)
vis

Çıktı

Yukarıdaki çıktıdan, sol taraftaki baloncuklar bir konuyu temsil ediyor ve balon ne kadar büyükse, o konu o kadar yaygın. Konu modeli, grafik boyunca dağılmış büyük, üst üste binmeyen baloncuklara sahipse, konu modeli iyi olacaktır.

Bu bölüm Latent Dirichlet Tahsis (LDA) Mallet Modelinin ne olduğunu ve Gensim'de nasıl oluşturulacağını açıklayacaktır.

Önceki bölümde LDA modelini uyguladık ve konuları 20Newsgroup veri setinin belgelerinden aldık. Bu, Gensim'in LDA algoritmasının yerleşik versiyonuydu. Gensim'in daha kaliteli konu sağlayan bir Mallet versiyonu da vardır. Burada, Mallet'in LDA'sını daha önce uyguladığımız önceki örneğe uygulayacağız.

LDA Mallet Modeli nedir?

Açık kaynak kodlu bir araç olan Mallet, Andrew McCullum tarafından yazılmıştır. Temelde NLP, belge sınıflandırma, kümeleme, konu modelleme ve diğer birçok makine öğrenimi uygulamalarının metne dönüştürülmesi için kullanılan Java tabanlı bir pakettir. Bize, Hiyerarşik LDA'nın yanı sıra LDA'nın verimli, örnekleme tabanlı uygulamalarını içeren Mallet Konu Modelleme araç setini sağlar.

Mallet2.0, java konu modelleme araç seti olan MALLET'in güncel sürümüdür. LDA için Gensim ile kullanmaya başlamadan önce mallet-2.0.8.zip paketini sistemimize indirip açmalıyız. Kurulduktan ve fermuarını açtıktan sonra,% MALLET_HOME% ortam değişkenini manuel olarak veya LDA'yı Mallet ile uygularken sağlayacağımız kodla MALLET dizinini işaret edecek şekilde ayarlayın.

Gensim Sarıcı

Python, Latent Dirichlet Tahsisatı (LDA) için Gensim sarıcı sağlar. Bu sarmalayıcının sözdizimigensim.models.wrappers.LdaMallet. MALLET'ten daraltılmış gibbs örneklemesi olan bu modül, bir eğitim külliyatından LDA model tahminine ve yeni, görünmeyen belgelerde konu dağılımının çıkarılmasına olanak tanır.

Uygulama Örneği

Önceden oluşturulmuş LDA modelinde LDA Mallet kullanacağız ve Coherence skorunu hesaplayarak performans farkını kontrol edeceğiz.

Mallet Dosyasına Giden Yol Sağlama

Mallet LDA modelini önceki örnekte oluşturulan derlememize uygulamadan önce, ortam değişkenlerini güncellememiz ve Mallet dosyasının yolunu da sağlamamız gerekir. Aşağıdaki kod yardımı ile yapılabilir -

import os
from gensim.models.wrappers import LdaMallet
os.environ.update({'MALLET_HOME':r'C:/mallet-2.0.8/'}) 
#You should update this path as per the path of Mallet directory on your system.
mallet_path = r'C:/mallet-2.0.8/bin/mallet' 
#You should update this path as per the path of Mallet directory on your system.

Mallet dosyasının yolunu sağladıktan sonra, artık onu külliyatta kullanabiliriz. Yardımı ile yapılabilirldamallet.show_topics() aşağıdaki gibi işlev -

ldamallet = gensim.models.wrappers.LdaMallet(
   mallet_path, corpus=corpus, num_topics=20, id2word=id2word
)
pprint(ldamallet.show_topics(formatted=False))

Çıktı

[
   (4,
   [('gun', 0.024546225966016102),
   ('law', 0.02181426826996709),
   ('state', 0.017633545129043606),
   ('people', 0.017612848479831116),
   ('case', 0.011341763768445888),
   ('crime', 0.010596684396796159),
   ('weapon', 0.00985160502514643),
   ('person', 0.008671896020034356),
   ('firearm', 0.00838214293105946),
   ('police', 0.008257963035784506)]),
   (9,
   [('make', 0.02147966482730431),
   ('people', 0.021377478029838543),
   ('work', 0.018557122419783363),
   ('money', 0.016676885346413244),
   ('year', 0.015982015123646026),
   ('job', 0.012221540976905783),
   ('pay', 0.010239117106069897),
   ('time', 0.008910688739014919),
   ('school', 0.0079092581238504),
   ('support', 0.007357449417535254)]),
   (14,
   [('power', 0.018428398507941996),
   ('line', 0.013784244460364121),
   ('high', 0.01183271164249895),
   ('work', 0.011560979224821522),
   ('ground', 0.010770484918850819),
   ('current', 0.010745781971789235),
   ('wire', 0.008399002000938712),
   ('low', 0.008053160742076529),
   ('water', 0.006966231071366814),
   ('run', 0.006892122230182061)]),
   (0,
   [('people', 0.025218349201353372),
   ('kill', 0.01500904870564167),
   ('child', 0.013612400660948935),
   ('armenian', 0.010307655991816822),
   ('woman', 0.010287984892595798),
   ('start', 0.01003226060272248),
   ('day', 0.00967818081674404),
   ('happen', 0.009383114328428673),
   ('leave', 0.009383114328428673),
   ('fire', 0.009009363443229208)]),
   (1,
   [('file', 0.030686386604212003),
   ('program', 0.02227713642901929),
   ('window', 0.01945561169918489),
   ('set', 0.015914874783314277),
   ('line', 0.013831003577619592),
   ('display', 0.013794120901412606),
   ('application', 0.012576992586582082),
   ('entry', 0.009275993066056873),
   ('change', 0.00872275292295209),
   ('color', 0.008612104894331132)]),
   (12,
   [('line', 0.07153810971508515),
   ('buy', 0.02975597944523662),
   ('organization', 0.026877236406682988),
   ('host', 0.025451316957679788),
   ('price', 0.025182275552207485),
   ('sell', 0.02461728860071565),
   ('mail', 0.02192687454599263),
   ('good', 0.018967419085797303),
   ('sale', 0.017998870026097017),
   ('send', 0.013694207538540181)]),
   (11,
   [('thing', 0.04901329901329901),
   ('good', 0.0376018876018876),
   ('make', 0.03393393393393394),
   ('time', 0.03326898326898327),
   ('bad', 0.02664092664092664),
   ('happen', 0.017696267696267698),
   ('hear', 0.015615615615615615),
   ('problem', 0.015465465465465466),
   ('back', 0.015143715143715144),
   ('lot', 0.01495066495066495)]),
   (18,
   [('space', 0.020626317374284855),
   ('launch', 0.00965716006366413),
   ('system', 0.008560244332602057),
   ('project', 0.008173097603991913),
   ('time', 0.008108573149223556),
   ('cost', 0.007764442723792318),
   ('year', 0.0076784101174345075),
   ('earth', 0.007484836753129436),
   ('base', 0.0067535595990880545),
   ('large', 0.006689035144319697)]),
   (5,
   [('government', 0.01918437232469453),
   ('people', 0.01461203206475212),
   ('state', 0.011207097828624796),
   ('country', 0.010214802708381975),
   ('israeli', 0.010039691804809714),
   ('war', 0.009436532025838587),
   ('force', 0.00858043427504086),
   ('attack', 0.008424780138532182),
   ('land', 0.0076659662230523775),
   ('world', 0.0075103120865437)]),
   (2,
   [('car', 0.041091194044470564),
   ('bike', 0.015598981291017729),
   ('ride', 0.011019688510138114),
   ('drive', 0.010627877363110981),
   ('engine', 0.009403467528651191),
   ('speed', 0.008081104907434616),
   ('turn', 0.007738270153785875),
   ('back', 0.007738270153785875),
   ('front', 0.007468899990204721),
   ('big', 0.007370947203447938)])
]

Performansı Değerlendirme

Şimdi tutarlılık puanını aşağıdaki gibi hesaplayarak performansını da değerlendirebiliriz -

ldamallet = gensim.models.wrappers.LdaMallet(
   mallet_path, corpus=corpus, num_topics=20, id2word=id2word
)
pprint(ldamallet.show_topics(formatted=False))

Çıktı

Coherence Score: 0.5842762900901401

Bu bölümde, Gensim'deki belgeler ve LDA modeli tartışılmaktadır.

LDA için Optimum Konu Sayısı Bulma

Çeşitli konu değerlerine sahip birçok LDA modeli oluşturarak LDA için en uygun konu sayısını bulabiliriz. Bu LDA'lar arasından en yüksek tutarlılık değerine sahip olanı seçebiliriz.

Aşağıdaki işlev adı coherence_values_computation()birden çok LDA modelini eğitecek. Ayrıca modelleri ve bunlara karşılık gelen tutarlılık puanlarını da sağlayacaktır -

def coherence_values_computation(dictionary, corpus, texts, limit, start=2, step=3):
   coherence_values = []
   model_list = []
   for num_topics in range(start, limit, step):
      model = gensim.models.wrappers.LdaMallet(
         mallet_path, corpus=corpus, num_topics=num_topics, id2word=id2word
      )
      model_list.append(model)
   coherencemodel = CoherenceModel(
      model=model, texts=texts, dictionary=dictionary, coherence='c_v'
   )
   coherence_values.append(coherencemodel.get_coherence())
return model_list, coherence_values

Şimdi aşağıdaki kodun yardımıyla, bir grafik yardımıyla da gösterebileceğimiz optimum sayıda konu elde edebiliriz -

model_list, coherence_values = coherence_values_computation (
   dictionary=id2word, corpus=corpus, texts=data_lemmatized, 
   start=1, limit=50, step=8
)
limit=50; start=1; step=8;
x = range(start, limit, step)
plt.plot(x, coherence_values)
plt.xlabel("Num Topics")
plt.ylabel("Coherence score")
plt.legend(("coherence_values"), loc='best')
plt.show()

Çıktı

Ardından, çeşitli konular için tutarlılık değerlerini aşağıdaki gibi yazdırabiliriz -

for m, cv in zip(x, coherence_values):
   print("Num Topics =", m, " is having Coherence Value of", round(cv, 4))

Çıktı

Num Topics = 1 is having Coherence Value of 0.4866
Num Topics = 9 is having Coherence Value of 0.5083
Num Topics = 17 is having Coherence Value of 0.5584
Num Topics = 25 is having Coherence Value of 0.5793
Num Topics = 33 is having Coherence Value of 0.587
Num Topics = 41 is having Coherence Value of 0.5842
Num Topics = 49 is having Coherence Value of 0.5735

Şimdi, şimdi hangi modeli seçmemiz gerektiği sorusu ortaya çıkıyor. İyi uygulamalardan biri, övünmeden önce en yüksek tutarlılık değerini veren modeli seçmektir. Bu yüzden yukarıdaki listede 4. sırada yer alan 25 konulu modeli seçiyor olacağız.

optimal_model = model_list[3]
model_topics = optimal_model.show_topics(formatted=False)
pprint(optimal_model.print_topics(num_words=10))

[
   (0,
   '0.018*"power" + 0.011*"high" + 0.010*"ground" + 0.009*"current" + '
   '0.008*"low" + 0.008*"wire" + 0.007*"water" + 0.007*"work" + 0.007*"design" '
   '+ 0.007*"light"'),
   (1,
   '0.036*"game" + 0.029*"team" + 0.029*"year" + 0.028*"play" + 0.020*"player" '
   '+ 0.019*"win" + 0.018*"good" + 0.013*"season" + 0.012*"run" + 0.011*"hit"'),
   (2,
   '0.020*"image" + 0.019*"information" + 0.017*"include" + 0.017*"mail" + '
   '0.016*"send" + 0.015*"list" + 0.013*"post" + 0.012*"address" + '
   '0.012*"internet" + 0.012*"system"'),
   (3,
   '0.986*"ax" + 0.002*"_" + 0.001*"tm" + 0.000*"part" + 0.000*"biz" + '
   '0.000*"mb" + 0.000*"mbs" + 0.000*"pne" + 0.000*"end" + 0.000*"di"'),
   (4,
   '0.020*"make" + 0.014*"work" + 0.013*"money" + 0.013*"year" + 0.012*"people" '
   '+ 0.011*"job" + 0.010*"group" + 0.009*"government" + 0.008*"support" + '
   '0.008*"question"'),
   (5,
   '0.011*"study" + 0.011*"drug" + 0.009*"science" + 0.008*"food" + '
   '0.008*"problem" + 0.008*"result" + 0.008*"effect" + 0.007*"doctor" + '
   '0.007*"research" + 0.007*"patient"'),
   (6,
   '0.024*"gun" + 0.024*"law" + 0.019*"state" + 0.015*"case" + 0.013*"people" + '
   '0.010*"crime" + 0.010*"weapon" + 0.010*"person" + 0.008*"firearm" + '
   '0.008*"police"'),
   (7,
   '0.012*"word" + 0.011*"question" + 0.011*"exist" + 0.011*"true" + '
   '0.010*"religion" + 0.010*"claim" + 0.008*"argument" + 0.008*"truth" + '
   '0.008*"life" + 0.008*"faith"'),
   (8,
   '0.077*"time" + 0.029*"day" + 0.029*"call" + 0.025*"back" + 0.021*"work" + '
   '0.019*"long" + 0.015*"end" + 0.015*"give" + 0.014*"year" + 0.014*"week"'),
   (9,
   '0.048*"thing" + 0.041*"make" + 0.038*"good" + 0.037*"people" + '
   '0.028*"write" + 0.019*"bad" + 0.019*"point" + 0.018*"read" + 0.018*"post" + '
   '0.016*"idea"'),
   (10,
   '0.022*"book" + 0.020*"_" + 0.013*"man" + 0.012*"people" + 0.011*"write" + '
   '0.011*"find" + 0.010*"history" + 0.010*"armenian" + 0.009*"turkish" + '
   '0.009*"number"'),
   (11,
   '0.064*"line" + 0.030*"buy" + 0.028*"organization" + 0.025*"price" + '
   '0.025*"sell" + 0.023*"good" + 0.021*"host" + 0.018*"sale" + 0.017*"mail" + '
   '0.016*"cost"'),
   (12,
   '0.041*"car" + 0.015*"bike" + 0.011*"ride" + 0.010*"engine" + 0.009*"drive" '
   '+ 0.008*"side" + 0.008*"article" + 0.007*"turn" + 0.007*"front" + '
   '0.007*"speed"'),
   (13,
   '0.018*"people" + 0.011*"attack" + 0.011*"state" + 0.011*"israeli" + '
   '0.010*"war" + 0.010*"country" + 0.010*"government" + 0.009*"live" + '
   '0.009*"give" + 0.009*"land"'),
   (14,
   '0.037*"file" + 0.026*"line" + 0.021*"read" + 0.019*"follow" + '
   '0.018*"number" + 0.015*"program" + 0.014*"write" + 0.012*"entry" + '
   '0.012*"give" + 0.011*"check"'),
   (15,
   '0.196*"write" + 0.172*"line" + 0.165*"article" + 0.117*"organization" + '
   '0.086*"host" + 0.030*"reply" + 0.010*"university" + 0.008*"hear" + '
   '0.007*"post" + 0.007*"news"'),
   (16,
   '0.021*"people" + 0.014*"happen" + 0.014*"child" + 0.012*"kill" + '
   '0.011*"start" + 0.011*"live" + 0.010*"fire" + 0.010*"leave" + 0.009*"hear" '
   '+ 0.009*"home"'),
   (17,
   '0.038*"key" + 0.018*"system" + 0.015*"space" + 0.015*"technology" + '
   '0.014*"encryption" + 0.010*"chip" + 0.010*"bit" + 0.009*"launch" + '
   '0.009*"public" + 0.009*"government"'),
   (18,
   '0.035*"drive" + 0.031*"system" + 0.027*"problem" + 0.027*"card" + '
   '0.020*"driver" + 0.017*"bit" + 0.017*"work" + 0.016*"disk" + '
   '0.014*"monitor" + 0.014*"machine"'),
   (19,
   '0.031*"window" + 0.020*"run" + 0.018*"color" + 0.018*"program" + '
   '0.017*"application" + 0.016*"display" + 0.015*"set" + 0.015*"version" + '
   '0.012*"screen" + 0.012*"problem"')
]

Cümlelerde baskın konuları bulmak

Cümlelerde baskın konuları bulmak, konu modellemenin en kullanışlı pratik uygulamalarından biridir. Belli bir belgenin hangi konuyla ilgili olduğunu belirler. Burada, söz konusu belgede en yüksek katkı yüzdesine sahip olan konu numarasını bulacağız. Bir tablodaki bilgileri toplamak için, adında bir fonksiyon oluşturacağız.dominant_topics() -

def dominant_topics(ldamodel=lda_model, corpus=corpus, texts=data):
   sent_topics_df = pd.DataFrame()

Ardından, her belgede ana konuları ele alacağız -

for i, row in enumerate(ldamodel[corpus]):
   row = sorted(row, key=lambda x: (x[1]), reverse=True)

Daha sonra, her belge için Baskın konu, Yüzde Katkı ve Anahtar Kelimeler alacağız -

for j, (topic_num, prop_topic) in enumerate(row):
   if j == 0: # => dominant topic
      wp = ldamodel.show_topic(topic_num)
      topic_keywords = ", ".join([word for word, prop in wp])
sent_topics_df = sent_topics_df.append(
   pd.Series([int(topic_num), round(prop_topic,4), topic_keywords]), ignore_index=True
)
   else:
      break
sent_topics_df.columns = ['Dominant_Topic', 'Perc_Contribution', 'Topic_Keywords']

Aşağıdaki kodun yardımıyla, orijinal metni çıktının sonuna ekleyeceğiz -

contents = pd.Series(texts)
   sent_topics_df = pd.concat([sent_topics_df, contents], axis=1)
   return(sent_topics_df)
df_topic_sents_keywords = dominant_topics(
   ldamodel=optimal_model, corpus=corpus, texts=data
)

Şimdi, cümlelerdeki konuların biçimlendirmesini aşağıdaki gibi yapın -

df_dominant_topic = df_topic_sents_keywords.reset_index()
df_dominant_topic.columns = [
   'Document_No', 'Dominant_Topic', 'Topic_Perc_Contrib', 'Keywords', 'Text'
]

Son olarak baskın konuları şu şekilde gösterebiliriz:

df_dominant_topic.head(15)

En Temsilci Belgeyi Bulma

Konu hakkında daha fazla bilgi sahibi olmak için, belirli bir konunun en çok katkıda bulunduğu belgeleri de bulabiliriz. Bu belirli belgeleri okuyarak bu konuyu çıkarabiliriz.

sent_topics_sorteddf_mallet = pd.DataFrame()
sent_topics_outdf_grpd = df_topic_sents_keywords.groupby('Dominant_Topic')
for i, grp in sent_topics_outdf_grpd:
   sent_topics_sorteddf_mallet = pd.concat([sent_topics_sorteddf_mallet,
grp.sort_values(['Perc_Contribution'], ascending=[0]).head(1)], axis=0)
sent_topics_sorteddf_mallet.reset_index(drop=True, inplace=True)
sent_topics_sorteddf_mallet.columns = [
   'Topic_Number', "Contribution_Perc", "Keywords", "Text"
]
sent_topics_sorteddf_mallet.head()

Çıktı

Konuların Hacmi ve Dağılımı

Bazen konunun belgelerde ne kadar geniş bir şekilde tartışıldığını da değerlendirmek isteriz. Bunun için konuların belgelerdeki hacmini ve dağılımını anlamamız gerekir.

Önce her Konu için doküman sayısını aşağıdaki gibi hesaplayın -

topic_counts = df_topic_sents_keywords['Dominant_Topic'].value_counts()

Ardından, her Konu için Dokümanların yüzdesini şu şekilde hesaplayın -;

topic_contribution = round(topic_counts/topic_counts.sum(), 4)

Şimdi, Numara ve Anahtar Kelimeler konusunu aşağıdaki gibi bulun -

topic_num_keywords = df_topic_sents_keywords[['Dominant_Topic', 'Topic_Keywords']]

Şimdi, aşağıdaki gibi Sütun bilgisini birleştirin -

df_dominant_topics = pd.concat(
   [topic_num_keywords, topic_counts, topic_contribution], axis=1
)

Ardından, Sütun adlarını aşağıdaki gibi değiştireceğiz -

df_dominant_topics.columns = [
   'Dominant-Topic', 'Topic-Keywords', 'Num_Documents', 'Perc_Documents'
]
df_dominant_topics

Çıktı

Bu bölüm, Gensim ile ilgili olarak Gizli Anlamsal İndeksleme (LSI) ve Hiyerarşik Dirichlet Süreci (HDP) konu modeli oluşturma ile ilgilidir.

İlk olarak Gensim'de Latent Dirichlet Tahsisi (LDA) ile uygulanan konu modelleme algoritmaları Latent Semantic Indexing (LSI). Aynı zamandaLatent Semantic Analysis (LSA). 1988'de Scott Deerwester, Susan Dumais, George Furnas, Richard Harshman, Thomas Landaur, Karen Lochbaum ve Lynn Streeter tarafından patenti alındı.

Bu bölümde LSI modelimizi kuracağız. LDA modelini kurmakla aynı şekilde yapılabilir. LSI modelini buradan içe aktarmamız gerekiyorgensim.models.

LSI'nin Rolü

Aslında, LSI, özellikle dağıtımsal anlambilimde bir teknik NLP'dir. Bir dizi belge ile bu belgelerin içerdiği terimler arasındaki ilişkiyi analiz eder. Çalışması hakkında konuşursak, o zaman büyük bir metin parçasından belge başına kelime sayısını içeren bir matris oluşturur.

LSI modeli, oluşturulduktan sonra satır sayısını azaltmak için tekil değer ayrıştırması (SVD) adı verilen matematiksel bir teknik kullanır. Sıra sayısını azaltmanın yanı sıra, sütunlar arasındaki benzerlik yapısını da korur.

Matriste, satırlar benzersiz kelimeleri ve sütunlar her belgeyi temsil eder. Dağılım hipotezine dayalı olarak çalışır, yani anlamı birbirine yakın olan kelimelerin aynı tür metinde yer alacağını varsayar.

Gensim ile Uygulama

Burada, doğal olarak tartışılan konuları veri kümesinden çıkarmak için LSI (Latent Semantic Indexing) kullanacağız.

Veri Kümesi Yükleniyor

Kullanacağımız veri seti, veri setidir. ’20 Newsgroups’bir haberin çeşitli bölümlerinden binlerce haber makalesine sahip olmak. Altında mevcutturSklearnveri kümeleri. Aşağıdaki Python betiğinin yardımıyla kolayca indirebiliriz -

from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')

Aşağıdaki komut dosyası yardımıyla bazı örnek haberlere bakalım -

newsgroups_train.data[:4]
["From: [email protected] (where's my thing)\nSubject: 
WHAT car is this!?\nNntp-Posting-Host: rac3.wam.umd.edu\nOrganization: 
University of Maryland, College Park\nLines: 15\n\n 
I was wondering if anyone out there could enlighten me on this car 
I saw\nthe other day. It was a 2-door sports car,
looked to be from the late 60s/\nearly 70s. It was called a Bricklin. 
The doors were really small. In addition,\nthe front bumper was separate from 
the rest of the body. This is \nall I know. If anyone can tellme a model name, 
engine specs, years\nof production, where this car is made, history, or 
whatever info you\nhave on this funky looking car, 
please e-mail.\n\nThanks,\n- IL\n ---- brought to you by your neighborhood 
Lerxst ----\n\n\n\n\n",

"From: [email protected] (Guy Kuo)\nSubject: 
SI Clock Poll - Final Call\nSummary: Final call for SI clock reports\nKeywords: 
SI,acceleration,clock,upgrade\nArticle-I.D.: shelley.1qvfo9INNc3s\nOrganization: 
University of Washington\nLines: 11\nNNTP-Posting-Host: carson.u.washington.edu\n\nA 
fair number of brave souls who upgraded their SI clock oscillator have\nshared their 
experiences for this poll. Please send a brief message detailing\nyour experiences with 
the procedure. Top speed attained, CPU rated speed,\nadd on cards and adapters, heat 
sinks, hour of usage per day, floppy disk\nfunctionality with 800 and 1.4 m floppies 
are especially requested.\n\nI will be summarizing in the next two days, so please add 
to the network\nknowledge base if you have done the clock upgrade and haven't answered 
this\npoll. Thanks.\n\nGuy Kuo <[email protected]>\n",

'From: [email protected] (Thomas E Willis)\nSubject: 
PB questions...\nOrganization: Purdue University Engineering Computer 
Network\nDistribution: usa\nLines: 36\n\nwell folks, my mac plus finally gave up the 
ghost this weekend after\nstarting life as a 512k way back in 1985. sooo, i\'m in the 
market for a\nnew machine a bit sooner than i intended to be...\n\ni\'m looking into 
picking up a powerbook 160 or maybe 180 and have a bunch\nof questions that (hopefully) 
somebody can answer:\n\n* does anybody know any dirt on when the next round of 
powerbook\nintroductions are expected? i\'d heard the 185c was supposed to make 
an\nappearence "this summer" but haven\'t heard anymore on it - and since i\ndon\'t 
have access to macleak, i was wondering if anybody out there had\nmore info...\n\n* has 
anybody heard rumors about price drops to the powerbook line like the\nones the duo\'s 
just went through recently?\n\n* what\'s the impression of the display on the 180? i 
could probably swing\na 180 if i got the 80Mb disk rather than the 120, but i don\'t 
really have\na feel for how much "better" the display is (yea, it looks great in 
the\nstore, but is that all "wow" or is it really that good?). could i solicit\nsome 
opinions of people who use the 160 and 180 day-to-day on if its worth\ntaking the disk 
size and money hit to get the active display? (i realize\nthis is a real subjective 
question, but i\'ve only played around with the\nmachines in a computer store breifly 
and figured the opinions of somebody\nwho actually uses the machine daily might prove 
helpful).\n\n* how well does hellcats perform? ;)\n\nthanks a bunch in advance for any 
info - if you could email, i\'ll post a\nsummary (news reading time is at a premium 
with finals just around the\ncorner... :( )\n--\nTom Willis \\ [email protected] 
\\ Purdue Electrical 
Engineering\n---------------------------------------------------------------------------\
n"Convictions are more dangerous enemies of truth than lies." - F. W.\nNietzsche\n',

'From: jgreen@amber (Joe Green)\nSubject: Re: Weitek P9000 ?\nOrganization: Harris 
Computer Systems Division\nLines: 14\nDistribution: world\nNNTP-Posting-Host: 
amber.ssd.csd.harris.com\nX-Newsreader: TIN [version 1.1 PL9]\n\nRobert J.C. Kyanko 
([email protected]) wrote:\n > [email protected] writes in article <
[email protected]>:\n> > Anyone know about the Weitek P9000 
graphics chip?\n > As far as the low-level stuff goes, it looks pretty nice. It\'s 
got this\n > quadrilateral fill command that requires just the four
points.\n\nDo you have Weitek\'s address/phone number? I\'d like to get some 
information\nabout this chip.\n\n--\nJoe Green\t\t\t\tHarris 
Corporation\[email protected]\t\t\tComputer Systems Division\n"The only thing that 
really scares me is a person with no sense of humor."\n\t\t\t\t\t\t-- Jonathan 
Winters\n']

Önkoşul

NLTK'dan Stopwords'e ve Scapy'den English modeline ihtiyacımız var. Her ikisi de aşağıdaki şekilde indirilebilir -

import nltk;
nltk.download('stopwords')
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])

Gerekli Paketleri İçe Aktarmak

LSI modeli oluşturmak için aşağıdaki gerekli paketi içe aktarmamız gerekir -

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import matplotlib.pyplot as plt

Engellenecek Kelimeler Hazırlanıyor

Şimdi Engellenecek Kelimeleri içe aktarmalı ve kullanmalıyız -

from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])

Metni Temizle

Şimdi Gensim'in yardımıyla simple_preprocess()her cümleyi bir kelime listesi şeklinde belirtmeliyiz. Ayrıca noktalama işaretlerini ve gereksiz karakterleri de kaldırmalıyız. Bunu yapmak için adında bir fonksiyon oluşturacağızsent_to_words() -

def sent_to_words(sentences):
   for sentence in sentences:
      yield(gensim.utils.simple_preprocess(str(sentence), deacc=True))
data_words = list(sent_to_words(data))

Bigram ve Trigram Modelleri Oluşturma

Bildiğimiz gibi, bigramlar belgede sıklıkla birlikte geçen iki kelime ve trigram, belgede sıklıkla birlikte geçen üç kelimedir. Gensim'in Cümleler modelinin yardımıyla bunu yapabiliriz -

bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)

Engellenecek Kelimeleri filtreleyin

Sonra, Engellenecek Kelimeleri filtrelememiz gerekiyor. Bununla birlikte, bigrams, trigrams ve lemmatizasyon yapmak için işlevler de yaratacağız -

def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc)) 
   if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   return [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
      doc = nlp(" ".join(sent))
      texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
   return texts_out

Konu Modeli İçin Sözlük ve Topluluk Oluşturma

Şimdi sözlük ve külliyat oluşturmamız gerekiyor. Bunu önceki örneklerde de yaptık -

id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]

LSI Konu Modeli Oluşturma

LSI modelini eğitmek için gereken her şeyi zaten uyguladık. Şimdi, LSI konu modelini oluşturmanın zamanı geldi. Uygulama örneğimiz için, aşağıdaki kod satırı yardımı ile yapılabilir -

lsi_model = gensim.models.lsimodel.LsiModel(
   corpus=corpus, id2word=id2word, num_topics=20,chunksize=100
)

Uygulama Örneği

LDA konu modelini oluşturmak için eksiksiz uygulama örneğini görelim -

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import matplotlib.pyplot as plt
from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])
from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')
data = newsgroups_train.data
data = [re.sub('\S*@\S*\s?', '', sent) for sent in data]
data = [re.sub('\s+', ' ', sent) for sent in data]
data = [re.sub("\'", "", sent) for sent in data]
print(data_words[:4]) #it will print the data after prepared for stopwords
bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)
def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc)) 
   if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   return [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
      doc = nlp(" ".join(sent))
      texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
return texts_out
data_words_nostops = remove_stopwords(data_words)
data_words_bigrams = make_bigrams(data_words_nostops)
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])
data_lemmatized = lemmatization(
   data_words_bigrams, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']
)
print(data_lemmatized[:4]) #it will print the lemmatized data.
id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]
print(corpus[:4]) #it will print the corpus we created above.
[[(id2word[id], freq) for id, freq in cp] for cp in corpus[:4]] 
#it will print the words with their frequencies.
lsi_model = gensim.models.lsimodel.LsiModel(
   corpus=corpus, id2word=id2word, num_topics=20,chunksize=100
)

Şimdi konuları elde etmek için yukarıda oluşturulan LSI modelini kullanabiliriz.

LSI Modelinde Konuları Görüntüleme

LSI modeli (lsi_model)Yukarıda oluşturduğumuz dokümanlardan konuları görüntülemek için kullanılabilir. Aşağıdaki komut dosyası yardımı ile yapılabilir -

pprint(lsi_model.print_topics())
doc_lsi = lsi_model[corpus]

Çıktı

[
   (0,
   '1.000*"ax" + 0.001*"_" + 0.000*"tm" + 0.000*"part" +    0.000*"pne" + '
   '0.000*"biz" + 0.000*"mbs" + 0.000*"end" + 0.000*"fax" + 0.000*"mb"'),
   (1,
   '0.239*"say" + 0.222*"file" + 0.189*"go" + 0.171*"know" + 0.169*"people" + '
   '0.147*"make" + 0.140*"use" + 0.135*"also" + 0.133*"see" + 0.123*"think"')
]

Hiyerarşik Dirichlet Süreci (HPD)

LDA ve LSI gibi konu modelleri, elle analiz edilmesi mümkün olmayan büyük metin arşivlerinin özetlenmesine ve düzenlenmesine yardımcı olur. LDA ve LSI dışında, Gensim'deki bir diğer güçlü konu modeli HDP'dir (Hiyerarşik Dirichlet Süreci). Temelde gruplanmış verilerin denetimsiz analizi için karma üyelik modelidir. LDA'nın (sonlu muadili) aksine, HDP verilerden konu sayısını çıkarıyor.

Gensim ile Uygulama

HDP'yi Gensim'de uygulamak için, gensim.models.HdpModel'den içe aktarabileceğimiz HDP konu modelini (yukarıdaki örneklerde LDA ve LSI konu modellerini uygularken olduğu gibi) eğitmemiz gerekiyor. Burada da 20Newsgroup verilerine HDP konu modelini uygulayacağız ve adımlar da aynı.

Derlememiz ve sözlüğümüz için (yukarıdaki LSI ve LDA modeli örneklerinde oluşturulmuştur), HdpModel'i aşağıdaki gibi içe aktarabiliriz -

Hdp_model = gensim.models.hdpmodel.HdpModel(corpus=corpus, id2word=id2word)

LSI Modelinde Konuları Görüntüleme

HDP modeli (Hdp_model)Belgelerden konuları görüntülemek için kullanılabilir. Aşağıdaki komut dosyası yardımı ile yapılabilir -

pprint(Hdp_model.print_topics())

Çıktı

[
   (0,
   '0.009*line + 0.009*write + 0.006*say + 0.006*article + 0.006*know + '
   '0.006*people + 0.005*make + 0.005*go + 0.005*think + 0.005*be'),
   (1,
   '0.016*line + 0.011*write + 0.008*article + 0.008*organization + 0.006*know '
   '+ 0.006*host + 0.006*be + 0.005*get + 0.005*use + 0.005*say'),
   (2,
   '0.810*ax + 0.001*_ + 0.000*tm + 0.000*part + 0.000*mb + 0.000*pne + '
   '0.000*biz + 0.000*end + 0.000*wwiz + 0.000*fax'),
   (3,
   '0.015*line + 0.008*write + 0.007*organization + 0.006*host + 0.006*know + '
   '0.006*article + 0.005*use + 0.005*thank + 0.004*get + 0.004*problem'),
   (4,
   '0.004*line + 0.003*write + 0.002*believe + 0.002*think + 0.002*article + '
   '0.002*belief + 0.002*say + 0.002*see + 0.002*look + 0.002*organization'),
   (5,
   '0.005*line + 0.003*write + 0.003*organization + 0.002*article + 0.002*time '
   '+ 0.002*host + 0.002*get + 0.002*look + 0.002*say + 0.001*number'),
   (6,
   '0.003*line + 0.002*say + 0.002*write + 0.002*go + 0.002*gun + 0.002*get + '
   '0.002*organization + 0.002*bill + 0.002*article + 0.002*state'),
   (7,
   '0.003*line + 0.002*write + 0.002*article + 0.002*organization + 0.001*none '
   '+ 0.001*know + 0.001*say + 0.001*people + 0.001*host + 0.001*new'),
   (8,
   '0.004*line + 0.002*write + 0.002*get + 0.002*team + 0.002*organization + '
   '0.002*go + 0.002*think + 0.002*know + 0.002*article + 0.001*well'),
   (9,
   '0.004*line + 0.002*organization + 0.002*write + 0.001*be + 0.001*host + '
   '0.001*article + 0.001*thank + 0.001*use + 0.001*work + 0.001*run'),
   (10,
   '0.002*line + 0.001*game + 0.001*write + 0.001*get + 0.001*know + '
   '0.001*thing + 0.001*think + 0.001*article + 0.001*help + 0.001*turn'),
   (11,
   '0.002*line + 0.001*write + 0.001*game + 0.001*organization + 0.001*say + '
   '0.001*host + 0.001*give + 0.001*run + 0.001*article + 0.001*get'),
   (12,
   '0.002*line + 0.001*write + 0.001*know + 0.001*time + 0.001*article + '
   '0.001*get + 0.001*think + 0.001*organization + 0.001*scope + 0.001*make'),
   (13,
   '0.002*line + 0.002*write + 0.001*article + 0.001*organization + 0.001*make '
   '+ 0.001*know + 0.001*see + 0.001*get + 0.001*host + 0.001*really'),
   (14,
   '0.002*write + 0.002*line + 0.002*know + 0.001*think + 0.001*say + '
   '0.001*article + 0.001*argument + 0.001*even + 0.001*card + 0.001*be'),
   (15,
   '0.001*article + 0.001*line + 0.001*make + 0.001*write + 0.001*know + '
   '0.001*say + 0.001*exist + 0.001*get + 0.001*purpose + 0.001*organization'),
   (16,
   '0.002*line + 0.001*write + 0.001*article + 0.001*insurance + 0.001*go + '
   '0.001*be + 0.001*host + 0.001*say + 0.001*organization + 0.001*part'),
   (17,
   '0.001*line + 0.001*get + 0.001*hit + 0.001*go + 0.001*write + 0.001*say + '
   '0.001*know + 0.001*drug + 0.001*see + 0.001*need'),
   (18,
   '0.002*option + 0.001*line + 0.001*flight + 0.001*power + 0.001*software + '
   '0.001*write + 0.001*add + 0.001*people + 0.001*organization + 0.001*module'),
   (19,
   '0.001*shuttle + 0.001*line + 0.001*roll + 0.001*attitude + 0.001*maneuver + '
   '0.001*mission + 0.001*also + 0.001*orbit + 0.001*produce + 0.001*frequency')
]

Bu bölüm, Gensim'de gelişmekte olan kelime gömülmesini anlamamıza yardımcı olacaktır.

Kelime gömme, kelime ve belgeyi temsil etme yaklaşımı, aynı anlama sahip kelimelerin benzer bir temsiline sahip olduğu metin için yoğun bir vektör temsilidir. Aşağıda kelime yerleştirmenin bazı özellikleri verilmiştir -

• Tek tek sözcükleri önceden tanımlanmış bir vektör uzayında gerçek değerli vektörler olarak temsil eden bir teknik sınıfıdır.

• Bu teknik genellikle DL (derin öğrenme) alanında toplanır çünkü her kelime bir vektöre eşlenir ve vektör değerleri bir NN'nin (Sinir Ağları) yaptığı gibi öğrenilir.

• Kelime gömme tekniğinin temel yaklaşımı, her kelime için yoğun dağıtılmış bir temsildir.

Farklı Kelime Gömme Yöntemleri / Algoritmaları

Yukarıda tartışıldığı gibi, kelime gömme yöntemleri / algoritmaları, bir metin külliyatından gerçek değerli bir vektör gösterimini öğrenir. Bu öğrenme süreci, belge sınıflandırması gibi görevlerde NN modeliyle birlikte kullanılabilir veya belge istatistikleri gibi denetimsiz bir süreçtir. Burada, metinden gömülen bir kelimeyi öğrenmek için kullanılabilecek iki yöntemi / algoritmayı tartışacağız -

Google'dan Word2Vec

Word2Vec, Tomas Mikolov, et. Tarafından geliştirilmiştir. al. 2013'te Google'da, metin derlemesinden bir kelimeyi gömmeyi verimli bir şekilde öğrenmek için istatistiksel bir yöntemdir. Aslında NN tabanlı kelime gömme eğitimini daha verimli hale getirmek için bir yanıt olarak geliştirilmiştir. Kelime yerleştirmenin fiili standardı haline geldi.

Word2Vec tarafından kelime gömme, öğrenilen vektörlerin analizinin yanı sıra kelimelerin temsili üzerinde vektör matematiğinin araştırılmasını içerir. Aşağıda, Word2Vec yönteminin bir parçası olarak kullanılabilecek iki farklı öğrenme yöntemi verilmiştir -

• CBoW (Continuous Bag of Words) Modeli
• Sürekli Skip-Gram Modeli

GloVe by Standford

GloVe (Kelime Gösterimi için Global Vektörler), Word2Vec yönteminin bir uzantısıdır. Pennington ve ark. Tarafından geliştirilmiştir. Stanford'da. GloVe algoritması her ikisinin bir karışımıdır -

• LSA (Gizli Anlamsal Analiz) gibi matris çarpanlarına ayırma tekniklerinin küresel istatistikleri
• Word2Vec'de yerel bağlama dayalı öğrenme.

Çalışması hakkında konuşursak, yerel bağlamı tanımlamak için bir pencere kullanmak yerine, GloVe tüm metin külliyatındaki istatistikleri kullanarak açık bir kelime birlikte oluşum matrisi oluşturur.

Word2Vec Gömme Geliştirme

Burada, Gensim kullanarak Word2Vec katıştırmayı geliştireceğiz. Bir Word2Vec modeliyle çalışmak için Gensim bizeWord2Vec ithal edilebilecek sınıf models.word2vec. Word2vec uygulaması için çok sayıda metin, örneğin tüm Amazon inceleme külliyatını gerektirir. Ancak burada, bu prensibi hafızası küçük metinlere uygulayacağız.

Uygulama Örneği

Öncelikle Word2Vec sınıfını gensim.models'den aşağıdaki gibi içe aktarmamız gerekiyor -

from gensim.models import Word2Vec

Daha sonra eğitim verilerini tanımlamamız gerekiyor. Bu prensibi uygulamak için büyük metin dosyası almak yerine bazı cümleler kullanıyoruz.

sentences = [
   ['this', 'is', 'gensim', 'tutorial', 'for', 'free'],
   ['this', 'is', 'the', 'tutorials' 'point', 'website'],
   ['you', 'can', 'read', 'technical','tutorials', 'for','free'],
   ['we', 'are', 'implementing','word2vec'],
   ['learn', 'full', 'gensim', 'tutorial']
]

Eğitim verileri sağlandıktan sonra modeli eğitmemiz gerekir. şu şekilde yapılabilir -

model = Word2Vec(sentences, min_count=1)

Modeli şu şekilde özetleyebiliriz -;

print(model)

Kelime dağarcığını şu şekilde özetleyebiliriz -

words = list(model.wv.vocab)
print(words)

Sonra, bir kelime için vektöre erişelim. Bunu 'öğretici' kelimesi için yapıyoruz.

print(model['tutorial'])

Ardından, modeli kaydetmemiz gerekiyor -

model.save('model.bin')

Ardından, modeli yüklememiz gerekiyor -

new_model = Word2Vec.load('model.bin')

Son olarak, kaydedilen modeli aşağıdaki gibi yazdırın -

print(new_model)

Eksiksiz Uygulama Örneği

from gensim.models import Word2Vec
sentences = [
   ['this', 'is', 'gensim', 'tutorial', 'for', 'free'],
   ['this', 'is', 'the', 'tutorials' 'point', 'website'],
   ['you', 'can', 'read', 'technical','tutorials', 'for','free'],
   ['we', 'are', 'implementing','word2vec'],
   ['learn', 'full', 'gensim', 'tutorial']
]
model = Word2Vec(sentences, min_count=1)
print(model)
words = list(model.wv.vocab)
print(words)
print(model['tutorial'])
model.save('model.bin')
new_model = Word2Vec.load('model.bin')
print(new_model)

Çıktı

Word2Vec(vocab=20, size=100, alpha=0.025)
[
   'this', 'is', 'gensim', 'tutorial', 'for', 'free', 'the', 'tutorialspoint', 
   'website', 'you', 'can', 'read', 'technical', 'tutorials', 'we', 'are', 
   'implementing', 'word2vec', 'learn', 'full'
]
[
   -2.5256255e-03 -4.5352755e-03 3.9024993e-03 -4.9509313e-03
   -1.4255195e-03 -4.0217536e-03 4.9407515e-03 -3.5925603e-03
   -1.1933431e-03 -4.6682903e-03 1.5440651e-03 -1.4101702e-03
   3.5070938e-03 1.0914479e-03 2.3334436e-03 2.4452661e-03
   -2.5336299e-04 -3.9676363e-03 -8.5054158e-04 1.6443320e-03
   -4.9968651e-03 1.0974540e-03 -1.1123562e-03 1.5393364e-03
   9.8941079e-04 -1.2656028e-03 -4.4471184e-03 1.8309267e-03
   4.9302122e-03 -1.0032534e-03 4.6892050e-03 2.9563988e-03
   1.8730218e-03 1.5343715e-03 -1.2685956e-03 8.3664013e-04
   4.1721235e-03 1.9445885e-03 2.4097660e-03 3.7517555e-03
   4.9687522e-03 -1.3598346e-03 7.1032363e-04 -3.6595813e-03
   6.0000515e-04 3.0872561e-03 -3.2115565e-03 3.2270295e-03
   -2.6354722e-03 -3.4988276e-04 1.8574356e-04 -3.5757164e-03
   7.5391348e-04 -3.5205986e-03 -1.9795434e-03 -2.8321696e-03
   4.7155009e-03 -4.3349937e-04 -1.5320212e-03 2.7013756e-03
   -3.7055744e-03 -4.1658725e-03 4.8034848e-03 4.8594419e-03
   3.7129463e-03 4.2385766e-03 2.4612297e-03 5.4920948e-04
   -3.8912550e-03 -4.8226118e-03 -2.2763973e-04 4.5571579e-03
   -3.4609400e-03 2.7903817e-03 -3.2709218e-03 -1.1036445e-03
   2.1492650e-03 -3.0384419e-04 1.7709908e-03 1.8429896e-03
   -3.4038599e-03 -2.4872608e-03 2.7693063e-03 -1.6352943e-03
   1.9182395e-03 3.7772327e-03 2.2769428e-03 -4.4629495e-03
   3.3151123e-03 4.6509290e-03 -4.8521687e-03 6.7615538e-04
   3.1034781e-03 2.6369948e-05 4.1454583e-03 -3.6932561e-03
   -1.8769916e-03 -2.1958587e-04 6.3395966e-04 -2.4969708e-03
]
Word2Vec(vocab=20, size=100, alpha=0.025)

Kelime Gömmeyi Görselleştirme

Görselleştirme ile kelime yerleştirmeyi de keşfedebiliriz. Yüksek boyutlu kelime vektörlerini 2 boyutlu grafiklere indirmek için klasik bir projeksiyon yöntemi (PCA gibi) kullanılarak yapılabilir. Azaltıldıktan sonra, onları grafiğe çizebiliriz.

PCA Kullanarak Kelime Vektörlerini Çizme

İlk olarak, tüm vektörleri eğitimli bir modelden aşağıdaki gibi almamız gerekir -

Z = model[model.wv.vocab]

Ardından, aşağıdaki gibi PCA sınıfını kullanarak 2 boyutlu bir PCA kelime vektörleri modeli oluşturmamız gerekiyor -

pca = PCA(n_components=2)
result = pca.fit_transform(Z)

Şimdi matplotlib kullanarak ortaya çıkan projeksiyonu aşağıdaki gibi grafiklendirebiliriz -

Pyplot.scatter(result[:,0],result[:,1])

Grafikteki noktalara kelimelerin kendisiyle de açıklama ekleyebiliriz. Matplotlib kullanarak ortaya çıkan projeksiyonu aşağıdaki gibi çizin -

words = list(model.wv.vocab)
for i, word in enumerate(words):
   pyplot.annotate(word, xy=(result[i, 0], result[i, 1]))

Eksiksiz Uygulama Örneği

from gensim.models import Word2Vec
from sklearn.decomposition import PCA
from matplotlib import pyplot
sentences = [
   ['this', 'is', 'gensim', 'tutorial', 'for', 'free'],
	['this', 'is', 'the', 'tutorials' 'point', 'website'],
	['you', 'can', 'read', 'technical','tutorials', 'for','free'],
	['we', 'are', 'implementing','word2vec'],
	['learn', 'full', 'gensim', 'tutorial']
]
model = Word2Vec(sentences, min_count=1)
X = model[model.wv.vocab]
pca = PCA(n_components=2)
result = pca.fit_transform(X)
pyplot.scatter(result[:, 0], result[:, 1])
words = list(model.wv.vocab)
for i, word in enumerate(words):
   pyplot.annotate(word, xy=(result[i, 0], result[i, 1]))
pyplot.show()

Çıktı

Doc2Vec modeli, Word2Vec modelinin tersi olarak, toplu olarak tek bir birim olarak alınan bir kelime grubunun vektörleştirilmiş bir temsilini oluşturmak için kullanılır. Sadece cümledeki kelimelerin basit ortalamasını vermez.

Doc2Vec Kullanarak Belge Vektörleri Oluşturma

Burada Doc2Vec kullanarak belge vektörleri oluşturmak için, buradan indirilebilen text8 veri setini kullanacağız. gensim.downloader.

Veri Kümesini İndirme

Aşağıdaki komutları kullanarak text8 veri setini indirebiliriz -

import gensim
import gensim.downloader as api
dataset = api.load("text8")
data = [d for d in dataset]

Text8 veri setini indirmek biraz zaman alacak.

Doc2Vec'i eğitin

Modeli eğitmek için, kullanılarak oluşturulabilen etiketli belgeye ihtiyacımız var. models.doc2vec.TaggedDcument() aşağıdaki gibi -

def tagged_document(list_of_list_of_words):
   for i, list_of_words in enumerate(list_of_list_of_words):
      yield gensim.models.doc2vec.TaggedDocument(list_of_words, [i])
data_for_training = list(tagged_document(data))

Eğitimli veri setini aşağıdaki gibi yazdırabiliriz -

print(data_for_training [:1])

Çıktı

[TaggedDocument(words=['anarchism', 'originated', 'as', 'a', 'term', 'of',
'abuse', 'first', 'used', 'against', 'early', 'working', 'class', 'radicals',
'including', 'the', 'diggers', 'of', 'the', 'english', 'revolution', 
'and', 'the', 'sans', 'culottes', 'of', 'the', 'french', 'revolution',
'whilst', 'the', 'term', 'is', 'still', 'used', 'in', 'a', 'pejorative',
'way', 'to', 'describe', 'any', 'act', 'that', 'used', 'violent', 
'means', 'to', 'destroy',
'the', 'organization', 'of', 'society', 'it', 'has', 'also', 'been'
, 'taken', 'up', 'as', 'a', 'positive', 'label', 'by', 'self', 'defined',
'anarchists', 'the', 'word', 'anarchism', 'is', 'derived', 'from', 'the',
'greek', 'without', 'archons', 'ruler', 'chief', 'king', 'anarchism', 
'as', 'a', 'political', 'philosophy', 'is', 'the', 'belief', 'that', 
'rulers', 'are', 'unnecessary', 'and', 'should', 'be', 'abolished',
'although', 'there', 'are', 'differing', 'interpretations', 'of', 
'what', 'this', 'means', 'anarchism', 'also', 'refers', 'to', 
'related', 'social', 'movements', 'that', 'advocate', 'the', 
'elimination', 'of', 'authoritarian', 'institutions', 'particularly',
'the', 'state', 'the', 'word', 'anarchy', 'as', 'most', 'anarchists', 
'use', 'it', 'does', 'not', 'imply', 'chaos', 'nihilism', 'or', 'anomie',
'but', 'rather', 'a', 'harmonious', 'anti', 'authoritarian', 'society', 
'in', 'place', 'of', 'what', 'are', 'regarded', 'as', 'authoritarian',
'political', 'structures', 'and', 'coercive', 'economic', 'institutions', 
'anarchists', 'advocate', 'social', 'relations', 'based', 'upon', 'voluntary',
'association', 'of', 'autonomous', 'individuals', 'mutual', 'aid', 'and', 
'self', 'governance', 'while', 'anarchism', 'is', 'most', 'easily', 'defined',
'by', 'what', 'it', 'is', 'against', 'anarchists', 'also', 'offer', 
'positive', 'visions', 'of', 'what', 'they', 'believe', 'to', 'be', 'a',
'truly', 'free', 'society', 'however', 'ideas', 'about', 'how', 'an', 'anarchist',
'society', 'might', 'work', 'vary', 'considerably', 'especially', 'with',
'respect', 'to', 'economics', 'there', 'is', 'also', 'disagreement', 'about', 
'how', 'a', 'free', 'society', 'might', 'be', 'brought', 'about', 'origins', 
'and', 'predecessors', 'kropotkin', 'and', 'others', 'argue', 'that', 'before',
'recorded', 'history', 'human', 'society', 'was', 'organized', 'on', 'anarchist', 
'principles', 'most', 'anthropologists', 'follow', 'kropotkin', 'and', 'engels', 
'in', 'believing', 'that', 'hunter', 'gatherer', 'bands', 'were', 'egalitarian',
'and', 'lacked', 'division', 'of', 'labour', 'accumulated', 'wealth', 'or', 'decreed',
'law', 'and', 'had', 'equal', 'access', 'to', 'resources', 'william', 'godwin', 
'anarchists', 'including', 'the', 'the', 'anarchy', 'organisation', 'and', 'rothbard',
'find', 'anarchist', 'attitudes', 'in', 'taoism', 'from', 'ancient', 'china', 
'kropotkin', 'found', 'similar', 'ideas', 'in', 'stoic', 'zeno', 'of', 'citium', 
'according', 'to', 'kropotkin', 'zeno', 'repudiated', 'the', 'omnipotence', 'of',
'the', 'state', 'its', 'intervention', 'and', 'regimentation', 'and', 'proclaimed',
'the', 'sovereignty', 'of', 'the', 'moral', 'law', 'of', 'the', 'individual', 'the',
'anabaptists', 'of', 'one', 'six', 'th', 'century', 'europe', 'are', 'sometimes',
'considered', 'to', 'be', 'religious', 'forerunners', 'of', 'modern', 'anarchism',
'bertrand', 'russell', 'in', 'his', 'history', 'of', 'western', 'philosophy', 
'writes', 'that', 'the', 'anabaptists', 'repudiated', 'all', 'law', 'since', 
'they', 'held', 'that', 'the', 'good', 'man', 'will', 'be', 'guided', 'at', 
'every', 'moment', 'by', 'the', 'holy', 'spirit', 'from', 'this', 'premise',
'they', 'arrive', 'at', 'communism', 'the', 'diggers', 'or', 'true', 'levellers', 
'were', 'an', 'early', 'communistic', 'movement',
(truncated…)

Modeli Başlatma

Eğitildikten sonra, şimdi modeli başlatmamız gerekiyor. şu şekilde yapılabilir -

model = gensim.models.doc2vec.Doc2Vec(vector_size=40, min_count=2, epochs=30)

Şimdi, kelimeleri aşağıdaki gibi oluşturun -

model.build_vocab(data_for_training)

Şimdi Doc2Vec modelini şu şekilde eğitelim -

model.train(data_for_training, total_examples=model.corpus_count, epochs=model.epochs)

Çıktının Analiz Edilmesi

Son olarak, model.infer_vector () kullanarak çıktıyı aşağıdaki gibi analiz edebiliriz -

print(model.infer_vector(['violent', 'means', 'to', 'destroy', 'the','organization']))

Eksiksiz Uygulama Örneği

import gensim
import gensim.downloader as api
dataset = api.load("text8")
data = [d for d in dataset]
def tagged_document(list_of_list_of_words):
   for i, list_of_words in enumerate(list_of_list_of_words):
      yield gensim.models.doc2vec.TaggedDocument(list_of_words, [i])
data_for_training = list(tagged_document(data))
print(data_for_training[:1])
model = gensim.models.doc2vec.Doc2Vec(vector_size=40, min_count=2, epochs=30)
model.build_vocab(data_training)
model.train(data_training, total_examples=model.corpus_count, epochs=model.epochs)
print(model.infer_vector(['violent', 'means', 'to', 'destroy', 'the','organization']))

Çıktı

[
   -0.2556166 0.4829361 0.17081228 0.10879577 0.12525807 0.10077011
   -0.21383236 0.19294572 0.11864349 -0.03227958 -0.02207291 -0.7108424
   0.07165232 0.24221905 -0.2924459 -0.03543589 0.21840079 -0.1274817
   0.05455418 -0.28968817 -0.29146606 0.32885507 0.14689675 -0.06913587
   -0.35173815 0.09340707 -0.3803535 -0.04030455 -0.10004586 0.22192696
   0.2384828 -0.29779273 0.19236489 -0.25727913 0.09140676 0.01265439
   0.08077634 -0.06902497 -0.07175519 -0.22583418 -0.21653089 0.00347822
   -0.34096122 -0.06176808 0.22885063 -0.37295452 -0.08222228 -0.03148199
   -0.06487323 0.11387568
]