Latent Semantic Analysis con Python

Scoprire gli argomenti è utile per vari scopi, come raggruppare i documenti, organizzare i contenuti online per il recupero di informazioni e i sistemi di raccomandazione. Molti provider di contenuti e agenzie di stampa usano i topic model per consigliare articoli ai lettori. Allo stesso modo, le società di recruiting li usano per estrarre le descrizioni delle posizioni e metterle in relazione con le competenze dei candidati. Se pensi al lavoro del data scientist, consiste nell’estrarre la “conoscenza” da grandi quantità di dati raccolti. Di solito i dati raccolti sono non strutturati. Hai bisogno di strumenti e tecniche potenti per analizzare e comprendere grandi quantità di dati non strutturati.

Il topic modeling è una tecnica di text mining che fornisce metodi per identificare parole chiave che co-occorrono, così da riassumere grandi collezioni di informazioni testuali. Aiuta a scoprire i temi nascosti nei documenti, ad annotare i documenti con questi temi e a organizzare grandi quantità di dati non strutturati.

Topic Modeling

Il Topic Modeling scopre automaticamente i temi nascosti a partire dai documenti forniti. È un algoritmo di text analytics non supervisionato che serve a trovare gruppi di parole dal documento dato. Questi gruppi di parole rappresentano un argomento. È possibile che un singolo documento sia associato a più temi. Per esempio, un gruppo di parole come "patient", "doctor", "disease", "cancer" e "health" rappresenterà il topic "healthcare". Il Topic Modeling è un approccio diverso rispetto alla ricerca testuale basata su regole che utilizza espressioni regolari.

Confronto tra Text Classification e Topic Modeling

La text classification è un problema di machine learning supervisionato, in cui un documento o articolo viene classificato in un insieme di classi predefinite. Il topic modeling è il processo di scoperta di gruppi di parole che co-occorrono nei documenti di testo. Questi gruppi di parole correlate formano i "topic". È una forma di apprendimento non supervisionato, quindi l’insieme dei possibili topic è sconosciuto. Il topic modeling può essere usato per risolvere problemi di classificazione del testo. Il topic modeling identifica i topic presenti in un documento, mentre la text classification classifica il testo in una singola classe.

Latent Semantic Analysis

LSA (Latent Semantic Analysis), noto anche come LSI (Latent Semantic Index), usa il modello bag of words (BoW), che produce una matrice termine-documento (occorrenze dei termini in un documento). Le righe rappresentano i termini e le colonne rappresentano i documenti. LSA apprende i topic latenti eseguendo una decomposizione della matrice termine-documento tramite la Singular Value Decomposition. LSA è tipicamente usato come tecnica di riduzione della dimensionalità o di riduzione del rumore.

Singular Value Decomposition (SVD)

SVD è un metodo di fattorizzazione che rappresenta una matrice come prodotto di due matrici. Offre varie applicazioni utili nell’elaborazione del segnale, psicologia, sociologia, scienze del clima e dell’atmosfera, statistica e astronomia.

• M è una matrice m×m
• U è una matrice singolare sinistra m×n
• Σ è una matrice diagonale n×n con numeri reali non negativi.
• V è una matrice singolare destra m×n
• V* è una matrice n×m, che è la trasposizione di V.

Matrice identità: è una matrice quadrata in cui tutti gli elementi della diagonale principale sono uno e tutti gli altri elementi sono zero.

Matrice diagonale: è una matrice in cui tutte le voci al di fuori della diagonale principale sono zero.

Matrice singolare: una matrice è singolare se il suo determinante è 0, ovvero una matrice quadrata che non ha inversa.

Determinare il numero ottimale di topic

Qual è il modo migliore per determinare k (numero di topic) nel topic modeling? Identificare il numero ottimale di topic nel corpus dato è un compito impegnativo. Possiamo usare le seguenti opzioni per determinarlo:

• Un modo è considerare ciascun topic come un cluster e valutare l’efficacia del cluster usando il coefficiente di Silhouette.
• La misura di coerenza del topic (topic coherence) è una misura realistica per identificare il numero di topic.

Topic Coherence è una metrica ampiamente utilizzata per valutare i topic model. Usa modelli a variabili latenti. Ogni topic generato ha una lista di parole. Nella misura di coerenza, si calcola la media/mediana dei punteggi di similarità a coppie tra le parole di un topic. Un valore elevato del punteggio di coerenza indica un buon topic model.

Implementare LSA con Gensim

Importa le librerie necessarie

#import modules
import os.path
from gensim import corpora
from gensim.models import LsiModel
from nltk.tokenize import RegexpTokenizer
from nltk.corpus import stopwords
from nltk.stem.porter import PorterStemmer
from gensim.models.coherencemodel import CoherenceModel
import matplotlib.pyplot as plt

Caricare i dati

Per prima cosa creiamo una funzione di caricamento per articles.csv. Puoi scaricare i dati qui.

def load_data(path,file_name):
    """
    Input  : path and file_name
    Purpose: loading text file
    Output : list of paragraphs/documents and
             title(initial 100 words considred as title of document)
    """
    documents_list = []
    titles=[]
    with open( os.path.join(path, file_name) ,"r") as fin:
        for line in fin.readlines():
            text = line.strip()
            documents_list.append(text)
    print("Total Number of Documents:",len(documents_list))
    titles.append( text[0:min(len(text),100)] )
    return documents_list,titles

Preprocessare i dati

Dopo la funzione di caricamento, devi preprocessare il testo. I passaggi seguenti vengono eseguiti per il preprocessing:

• Tokenizzare gli articoli di testo
• Rimuovere le stop word
• Eseguire lo stemming del testo

def preprocess_data(doc_set):
    """
    Input  : docuemnt list
    Purpose: preprocess text (tokenize, removing stopwords, and stemming)
    Output : preprocessed text
    """
    # initialize regex tokenizer
    tokenizer = RegexpTokenizer(r'\w+')
    # create English stop words list
    en_stop = set(stopwords.words('english'))
    # Create p_stemmer of class PorterStemmer
    p_stemmer = PorterStemmer()
    # list for tokenized documents in loop
    texts = []
    # loop through document list
    for i in doc_set:
        # clean and tokenize document string
        raw = i.lower()
        tokens = tokenizer.tokenize(raw)
        # remove stop words from tokens
        stopped_tokens = [i for i in tokens if not i in en_stop]
        # stem tokens
        stemmed_tokens = [p_stemmer.stem(i) for i in stopped_tokens]
        # add tokens to list
        texts.append(stemmed_tokens)
    return texts

Preparare il corpus

Il passo successivo è preparare il corpus. Qui devi creare una matrice documento-termine e un dizionario dei termini.

def prepare_corpus(doc_clean):
    """
    Input  : clean document
    Purpose: create term dictionary of our courpus and Converting list of documents (corpus) into Document Term Matrix
    Output : term dictionary and Document Term Matrix
    """
    # Creating the term dictionary of our courpus, where every unique term is assigned an index. dictionary = corpora.Dictionary(doc_clean)
    dictionary = corpora.Dictionary(doc_clean)
    # Converting list of documents (corpus) into Document Term Matrix using dictionary prepared above.
    doc_term_matrix = [dictionary.doc2bow(doc) for doc in doc_clean]
    # generate LDA model
    return dictionary,doc_term_matrix

Creare un modello LSA con Gensim

Dopo aver creato il corpus, puoi generare un modello usando LSA.

def create_gensim_lsa_model(doc_clean,number_of_topics,words):
    """
    Input  : clean document, number of topics and number of words associated with each topic
    Purpose: create LSA model using gensim
    Output : return LSA model
    """
    dictionary,doc_term_matrix=prepare_corpus(doc_clean)
    # generate LSA model
    lsamodel = LsiModel(doc_term_matrix, num_topics=number_of_topics, id2word = dictionary)  # train model
    print(lsamodel.print_topics(num_topics=number_of_topics, num_words=words))
    return lsamodel

Determinare il numero di topic

Serve un ulteriore passaggio per ottimizzare i risultati, identificando un numero ottimale di topic. Qui genererai i punteggi di coerenza per determinare il numero ottimale di topic.

def compute_coherence_values(dictionary, doc_term_matrix, doc_clean, stop, start=2, step=3):
    """
    Input   : dictionary : Gensim dictionary
              corpus : Gensim corpus
              texts : List of input texts
              stop : Max num of topics
    purpose : Compute c_v coherence for various number of topics
    Output  : model_list : List of LSA topic models
              coherence_values : Coherence values corresponding to the LDA model with respective number of topics
    """
    coherence_values = []
    model_list = []
    for num_topics in range(start, stop, step):
        # generate LSA model
        model = LsiModel(doc_term_matrix, num_topics=number_of_topics, id2word = dictionary)  # train model
        model_list.append(model)
        coherencemodel = CoherenceModel(model=model, texts=doc_clean, dictionary=dictionary, coherence='c_v')
        coherence_values.append(coherencemodel.get_coherence())
    return model_list, coherence_values

Tracciamo i valori del punteggio di coerenza.

def plot_graph(doc_clean,start, stop, step):
    dictionary,doc_term_matrix=prepare_corpus(doc_clean)
    model_list, coherence_values = compute_coherence_values(dictionary, doc_term_matrix,doc_clean,
                                                            stop, start, step)
    # Show graph
    x = range(start, stop, step)
    plt.plot(x, coherence_values)
    plt.xlabel("Number of Topics")
    plt.ylabel("Coherence score")
    plt.legend(("coherence_values"), loc='best')
    plt.show()

start,stop,step=2,12,1
plot_graph(clean_text,start,stop,step)

Questo grafico è facile da valutare. Sull’asse X c’è il numero di topic e sull’asse Y il punteggio di coerenza. Tra i numeri di topic, 7 ha il punteggio di coerenza più alto, quindi il numero ottimale di topic è 7.

Esegui tutte le funzioni sopra

# LSA Model
number_of_topics=7
words=10
document_list,titles=load_data("","articles.txt")
clean_text=preprocess_data(document_list)
model=create_gensim_lsa_model(clean_text,number_of_topics,words)

Total Number of Documents: 4551
[(0, '0.361*"trump" + 0.272*"say" + 0.233*"said" + 0.166*"would" + 0.160*"clinton" + 0.140*"peopl" + 0.136*"one" + 0.126*"campaign" + 0.123*"year" + 0.110*"time"'), (1, '-0.389*"citi" + -0.370*"v" + -0.356*"h" + -0.355*"2016" + -0.354*"2017" + -0.164*"unit" + -0.159*"west" + -0.157*"manchest" + -0.116*"apr" + -0.112*"dec"'), (2, '0.612*"trump" + 0.264*"clinton" + -0.261*"eu" + -0.148*"say" + -0.137*"would" + 0.135*"donald" + -0.134*"leav" + -0.134*"uk" + 0.119*"republican" + -0.110*"cameron"'), (3, '-0.400*"min" + 0.261*"eu" + -0.183*"goal" + -0.152*"ball" + -0.132*"play" + 0.128*"said" + 0.128*"say" + -0.126*"leagu" + 0.122*"leav" + -0.122*"game"'), (4, '0.404*"bank" + -0.305*"eu" + -0.290*"min" + 0.189*"year" + -0.164*"leav" + -0.153*"cameron" + 0.143*"market" + 0.140*"rate" + -0.139*"vote" + -0.133*"say"'), (5, '0.310*"bank" + -0.307*"say" + -0.221*"peopl" + 0.203*"trump" + 0.166*"1" + 0.164*"min" + 0.163*"0" + 0.152*"eu" + 0.152*"market" + -0.138*"like"'), (6, '0.570*"say" + 0.237*"min" + -0.170*"vote" + 0.158*"govern" + -0.154*"poll" + 0.122*"tax" + 0.115*"statement" + 0.115*"bank" + 0.112*"budget" + -0.108*"one"')]

• Topic-1: "trump", "say", "said", "would", "clinton", "peopl", "one", "campaign","year","time" (Elezioni presidenziali USA)
• Topic-2: "citi", "v", "h", "2016", "2017","unit", "west", "manchest","apr" ,"dec" (Premier League inglese)
• Topic-3: "trump","clinton", "eu","say","would","donald","leav","uk" ,"republican" ,"cameron" (Elezioni presidenziali USA, Brexit)
• Topic-4: "min","eu","goal","ball","play","said","say","leagu","leav","game" (Premier League inglese)
• Topic-5: "bank","eu","min","year","leav","cameron","market","rate","vote","say" (Brexit e condizioni di mercato)
• Topic-6: "bank","say","peopl","trump","1" ,"min" ,"eu","market" ,"like" (Situazioni politiche e condizioni di mercato)
• Topic-7: "say","min","vote","govern","poll","tax","statement","bank","budget","one" (Elezioni presidenziali USA e pianificazione finanziaria)

Qui sono stati scoperti 7 topic usando la Latent Semantic Analysis. Alcuni di essi si sovrappongono. Per cogliere significati multipli con maggiore accuratezza dobbiamo provare LDA (Latent Dirichlet Allocation). Lo lascio come esercizio per te: provalo con Gensim e condividi le tue opinioni.

Pro e contro di LSA

L’algoritmo LSA è il metodo più semplice, facile da comprendere e implementare. Offre anche risultati migliori rispetto al modello a spazio vettoriale. È più veloce rispetto ad altri algoritmi disponibili perché comporta solo la decomposizione della matrice documento-termine.

La dimensione dei topic latenti dipende dal rango della matrice, quindi non possiamo superare quel limite. La matrice decomposta da LSA è altamente densa, quindi è difficile indicizzare singole dimensioni. LSA non riesce a catturare i molteplici significati delle parole. Non è più semplice da implementare rispetto a LDA (Latent Dirichlet Allocation). Offre un’accuratezza inferiore rispetto a LDA.

Casi d’uso del Topic Modeling

Le applicazioni semplici in cui si usa questa tecnica sono il clustering di documenti nell’analisi testuale, i sistemi di raccomandazione e il recupero di informazioni. Casi d’uso più dettagliati del topic modeling sono:

• Riassunto dei CV: può aiutare i recruiter a valutare i curriculum a colpo d’occhio. Possono ridurre lo sforzo nel filtrare pile di CV.
• Ottimizzazione per i motori di ricerca: articoli online, blog e documenti possono essere taggati facilmente identificando i topic e le parole chiave associate, migliorando così i risultati di ricerca.
• Ottimizzazione dei sistemi di raccomandazione: i sistemi di raccomandazione agiscono come filtri informativi e consulenti in base al profilo utente e alla cronologia. Possono aiutare a scoprire contenuti pertinenti non ancora visitati in base alle visite passate.
• Migliorare l’assistenza clienti: scoprire topic rilevanti e parole chiave associate nei reclami e nei feedback dei clienti, ad esempio specifiche di prodotti e servizi, reparto e dettagli della filiale. Queste informazioni aiutano l’azienda a inoltrare direttamente il reclamo al reparto competente.
• Nell’industria sanitaria, il topic modeling può aiutare a estrarre informazioni utili e preziose da referti medici non strutturati. Queste informazioni possono essere usate per il trattamento dei pazienti e per la ricerca in campo medico.

Conclusione

In questo tutorial hai visto molti dettagli sul Topic Modeling. Hai imparato cos’è il Topic Modeling, cos’è la Latent Semantic Analysis, come costruire i relativi modelli e come vengono generati i topic usando LSA. Hai anche coperto alcuni concetti di base come la Singular Value Decomposition e il punteggio di coerenza dei topic.

Si spera che ora tu possa utilizzare il topic modeling per analizzare i tuoi dataset. Grazie per aver letto questo tutorial!

Se vuoi imparare di più su Python, segui il corso di DataCamp Case Studies in Statistical Thinking.