Ekstraksi kata kunci otomatis: menggunakan persamaan cosinus sebagai fitur

Saya punya matriks istilah-dokumen , dan sekarang saya ingin mengekstraksi kata kunci untuk setiap dokumen dengan metode pembelajaran yang dilindungi (SVM, Naif Bayes, ...). Dalam model ini, saya sudah menggunakan Tf-idf, tag Pos, ...$M$

Tapi sekarang aku bertanya-tanya tentang selanjutnya. Saya punya matriks dengan persamaan cosinus antara istilah-istilah.$C$

Apakah ada kemungkinan untuk menggunakan kesamaan ini sebagai fitur untuk model saya? Ide saya adalah istilah dalam dokumen d , untuk menggunakan rata-rata persamaan cosinus dari semua istilah dalam dokumen d dengan istilah i . Apakah ini berguna?$i$$d$$d$$i$

Saya tidak tahu bagaimana mungkin melakukan ekstraksi kata kunci dengan pembelajaran terawasi, tetapi saya tahu bagaimana melakukannya dengan pembelajaran tanpa pengawasan.

Ada beberapa metode untuk melakukan ini, jadi inilah mereka:

Hierarkis

Anda dapat menerapkan metode pengelompokan hierarkis apa pun pada istilah kesamaan matriks (dengan fungsi kesamaan apa pun, bukan hanya cosinus)

Di scikit-belajar Anda akan melakukan sesuatu seperti ini:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.cluster import AgglomerativeClustering

vectorizer = TfidfVectorizer(stop_words='english')
X = vectorizer.fit_transform(data)
C = 1 - cosine_similarity(X.T)
ward = AgglomerativeClustering(n_clusters=k, linkage='ward').fit(C)
label = ward.labels_

Sumber: [1]

Tetapi karena ini adalah pengelompokan aglomeratif, ini mahal secara komputasional dan perlu waktu untuk dihitung.

K-Means

Kemungkinan lain adalah melakukan k-means pada baris-baris matriks dokumen-istilah, dan kemudian menemukan istilah yang paling umum untuk setiap centroid

Sebagai contoh, dalam scikit belajar ini adalah cara melakukannya:

from sklearn.cluster import KMeans

km = KMeans(n_clusters=k, init='k-means++', max_iter=100, n_init=1)
km.fit(X)
order_centroids = km.cluster_centers_.argsort()[:, ::-1]
terms = vectorizer.get_feature_names()
for i in range(k):
    print("Cluster %d:" % i, end='')
    for ind in order_centroids[i, :10]:
        print(' %s' % terms[ind], end='')

Sumber: [2]

Tetapi k-means bergantung pada jarak Euclidean, yang buruk untuk data dimensi tinggi yang jarang. Ada teknik lain yang bekerja lebih baik untuk teks dan menggunakan kesamaan cosinus

Cosine K-Means and Scatter / Gather

Dimungkinkan untuk menggunakan Cosine dengan K-means (lihat misalnya [3] ): hitung centroid sebagai rata-rata semua dokumen dalam setiap klaster, dan kemudian gunakan cosinus untuk menghitung jarak ke centroid terdekat.

Pada akhirnya, Anda dapat mengekstraksi kata kunci dengan cara yang sama seperti untuk k-means yang biasa.

Menghitung rata-rata centroid sebagai rata-rata dari semua dokumen dalam cluster tidak selalu baik. Pendekatan lain disarankan dalam algoritma Scatter / Gather [4] : centroid dari sebuah cluster adalah gabungan dari semua dokumen dalam cluster ini.

Untuk pendekatan ini Anda hanya perlu mengambil istilah yang paling sering untuk setiap cluster centroid.

Tidak ada implementasi algoritma ini di scikit belajar, tetapi Anda dapat dengan mudah menerapkannya sendiri dengan memperluas KMeans.

Perhatikan bahwa dalam kedua kasus, centroid menjadi cukup padat: lebih padat daripada dokumen lainnya di setiap cluster, jadi Anda mungkin ingin memotong istilah dalam centroid, yaitu menghapus yang "tidak penting". (lihat [8]).

Clustering Spektral

Cara lain adalah dengan menerapkan pengelompokan spektral. Anda harus menyediakan matriks kesamaan, yang sudah Anda miliki, dan ia akan menemukan cluster di atasnya.

Itu diterapkan di SpectralClusteringkelas, lihat contoh di [5] . Perhatikan bahwa karena Anda sudah memiliki matriks pra-komputasi, Anda perlu menggunakan affinity='precumputed'atribut saat menginisialisasi.

Spectral clustering terkait dengan Kernel KMeans: ada kertas (lihat [7]) yang menunjukkan bahwa mereka adalah hal yang sama. Baru-baru ini saya menemukan implementasi KMeans Kernel yang mungkin berguna: https://gist.github.com/mblondel/6230787

Factorisasi Matriks Non-Negatif

Akhirnya, Anda dapat mengelompokkan term-document matrix Anda dengan beberapa teknik dekomposisi dari Linear Algebra, seperti SVD (ini akan disebut "Latent Semantic Analysis") atau Factorization Matriks Non-Negatif. Yang terakhir dapat dilihat sebagai pengelompokan, dan dapat mengelompokkan kedua baris dan kolom matriks pada saat yang sama.

Misalnya, Anda dapat mengekstrak kata kunci dengan melakukan

from sklearn.decomposition import NMF
nmf = NMF(n_components=k, random_state=1).fit(X)

feature_names = vectorizer.get_feature_names()

for topic_idx, topic in enumerate(nmf.components_):
    print("Topic #%d:" % topic_idx)
    print(" ".join([feature_names[i]
                    for i in topic.argsort()[:-10-1:-1]]))
    print()

Sumber kode: [6]

Meskipun di sini contohnya adalah dalam python scikit-belajar, saya pikir itu seharusnya tidak menjadi masalah besar untuk menemukan beberapa contoh untuk R

Sumber

• [1]: http://scikit-learn.org/stable/auto_examples/cluster/plot_ward_structured_vs_unstructured.html
• [2]: http://scikit-learn.org/stable/auto_examples/text/document_clustering.html#example-text-document-clustering-py
• [3]: Larsen, Bjornar, dan Chinatsu Aone. "Penambangan teks cepat dan efektif menggunakan pengelompokan dokumen linear-time." (pdf)
• [4]: Pemotongan, Douglass R., et al. "Sebar / kumpulkan: Pendekatan berbasis cluster untuk menjelajahi koleksi dokumen besar." (pdf)
• [5]: http://scikit-learn.org/stable/modules/generated/sklearn.cluster.SpectralClustering.html
• [6]: http://scikit-learn.org/stable/auto_examples/applications/topics_extraction_with_nmf.html
• [7]: Dhillon, Inderjit S., Yuqiang Guan, dan Brian Kulis. "K-means Kernel: pengelompokan spektral dan pemotongan yang dinormalisasi." (pdf)
• [8]: Schütze, Hinrich, dan Craig Silverstein. "Proyeksi untuk pengelompokan dokumen yang efisien." (situs web acm)