<jupyter_start><jupyter_text>Hasta acá tenemos 9 estados financieros de una misma empresa ya limpios de caracteres y palabras basura. Ahora tenemos que Lemmatizar las palabras, es decir, volverlas a su raíz para mejor procesamiento. Luego, intentaremos clasificar los documentos según el modelo No Supervisado: Latent Dirichlet Allocation.Recuerda en que la diferencia entre Lemmatizer y Stemmer yace en la metodología de la reducción de palabras. Mientras Lemmatizer se basa en un análisis morfológico de las palabras y requiere de un diccionario de especificación, Stemmer se basa en cortar prefijos y sufijos comunes a las palabras involucradas en el texto.<jupyter_code>from nltk.stem import PorterStemmer

def porter_stemmer(word):
    stemmer = PorterStemmer()
    return stemmer.stem(word)
dataframe['raw_clean_text'].str.split()
porter_stemmer('subsidiarias')
dict_data = {k:v.split() for k, v in zip(dataframe['nombre_doc'],dataframe['raw_clean_text'])}
doc_clean = [*dataframe['raw_clean_text'].str.split()]
import gensim
from gensim import corpora
from gensim.models import CoherenceModel

#Debemos crear un diccionario de nuestro corpus (lista de docs), donde cada término único sea asignado a un index. 

#Convirtiendo la lista de documentos corpus en una Matriz de términos de documentos, usando el diccionario dict_data

dictionary = corpora.Dictionary(doc_clean)
doc_term_matrix = [dictionary.doc2bow(doc) for doc in doc_clean]
dictionary = corpora.Dictionary(doc_clean)<jupyter_output><empty_output><jupyter_text>Latent Dirichlet Allocation model:<jupyter_code>LDA = gensim.models.ldamodel.LdaModel

ldamodel = LDA(doc_term_matrix, num_topics=5, id2word=dictionary, passes=40,random_state=300)
print(ldamodel.print_topics(num_topics=5, num_words=6))<jupyter_output>[(0, '0.015*"arrendamiento" + 0.014*"inversiones" + 0.012*"activo" + 0.012*"arrendamientos" + 0.011*"pasivo" + 0.010*"subsidiaria"'), (1, '0.012*"instrumentos" + 0.011*"coberturas" + 0.011*"cobertura" + 0.011*"ingresos" + 0.010*"contables" + 0.010*"inversiones"'), (2, '0.001*"cobrar" + 0.001*"emision" + 0.001*"serie" + 0.001*"inversiones" + 0.001*"marzo" + 0.001*"contables"'), (3, '0.019*"arrendamiento" + 0.014*"bonos" + 0.014*"emision" + 0.010*"subsidiarias" + 0.009*"vigentes" + 0.009*"bolivianos"'), (4, '0.023*"cobrar" + 0.014*"marzo" + 0.008*"vitapro" + 0.008*"distribucion" + 0.008*"deterioro" + 0.006*"mar"')]<jupyter_text>Hierarchical Dirichlet process:En este caso, el modelo debería poner el número de tópicos que necesitas.<jupyter_code>from gensim.models.hdpmodel import HdpModel

hdpmodel = HdpModel(corpus= doc_term_matrix, id2word=dictionary, random_state=300)

hdpmodel.show_topics()<jupyter_output><empty_output><jupyter_text>Métricas del modelo: Perplexity: Qué tan bueno es el modelo con respecto a palabras buenas.Coherence Score: Qué tanto se sustenta el modelo con respecto a las palabras aledañas.<jupyter_code>print('Perplexity: {}'.format(ldamodel.log_perplexity(doc_term_matrix))) #Mientras más bajo mejor.

#Cohere Score:
coherence_model_lda = CoherenceModel(model=ldamodel, texts= doc_clean, dictionary=dictionary, coherence='c_v')
coherence_lda = coherence_model_lda.get_coherence()

print('Coherence Score: {}'.format(coherence_lda))
ldamodel2 = LDA(doc_term_matrix, num_topics=3, id2word=dictionary, passes=60,random_state=300)
coherence_model_lda = CoherenceModel(model=ldamodel2, texts= doc_clean, dictionary=dictionary, coherence='c_v')
coherence_lda = coherence_model_lda.get_coherence()

print('Coherence Score: {}'.format(coherence_lda))
#Ahora le pondremos 600 passes
ldamodel2 = LDA(doc_term_matrix, num_topics=7, id2word=dictionary, passes=600,random_state=300)
coherence_model_lda = CoherenceModel(model=ldamodel2, texts= doc_clean, dictionary=dictionary, coherence='c_v')
coherence_lda = coherence_model_lda.get_coherence()

print('Coherence Score: {}'.format(coherence_lda))
print(ldamodel2.print_topics(num_topics=5, num_words=6))
ldamodel3 = LDA(corpus = doc_term_matrix, num_topics=7, id2word=dictionary, passes=600,random_state=300,alpha=0.05)
coherence_model_lda = CoherenceModel(model=ldamodel2, texts= doc_clean, dictionary=dictionary, coherence='c_v')
coherence_lda = coherence_model_lda.get_coherence()

print('Coherence Score: {}'.format(coherence_lda))
print(ldamodel3.print_topics(num_topics=5, num_words=6))<jupyter_output>[(5, '0.020*"arrendamiento" + 0.015*"bonos" + 0.015*"emision" + 0.011*"subsidiarias" + 0.009*"vigentes" + 0.009*"bolivianos"'), (4, '0.001*"extension" + 0.001*"estime" + 0.001*"fiscales" + 0.001*"fiscal" + 0.001*"factores" + 0.001*"incertidumbre"'), (0, '0.026*"cobrar" + 0.015*"marzo" + 0.009*"deterioro" + 0.009*"vitapro" + 0.009*"distribucion" + 0.009*"mar"'), (2, '0.001*"extension" + 0.001*"estime" + 0.001*"fiscales" + 0.001*"fiscal" + 0.001*"factores" + 0.001*"incertidumbre"'), (1, '0.013*"instrumentos" + 0.012*"cobertura" + 0.012*"coberturas" + 0.011*"ingresos" + 0.011*"contables" + 0.011*"inversiones"')]<jupyter_text>Podemos ver que algunos de las palabras dentro de los tópicos nos pueden ser útiles. Pero, quedan las preguntas:¿Cómo sé cuántos tópicos son óptimos dentro de mis datos? ¿Cómo veo el puntaje de un tópico por documento? Optimizando el Número de tópicos: Fuente: https://towardsdatascience.com/evaluate-topic-model-in-python-latent-dirichlet-allocation-lda-7d57484bb5d0<jupyter_code>import numpy as np
import tqdm

def compute_coherence_values_lda(corpus, texts, id2word, alpha, n_topics):
    "Hace el modelo y luego valida los resultados"
    lda_model = gensim.models.LdaMulticore(corpus=corpus,
                                           id2word=id2word,
                                           num_topics=n_topics, 
                                           random_state=133,
                                           passes=50,
                                           alpha=alpha)
    
    coherence_model_lda = CoherenceModel(model=lda_model, texts=texts, dictionary=dictionary, coherence='c_v')
    
    return coherence_model_lda.get_coherence()

def compute_coherence_values_hdp(corpus, texts, id2word, alpha, beta, tau):
    return 0

grid = {}
grid['Validation_Set'] = {}
# Rango de tópicos
min_topics = 3
max_topics = 10
topics_range = range(min_topics, max_topics, 1)
# Rango de optimización del alpha
alpha = list(np.arange(0.01, 1, 0.25))
alpha.append('symmetric')
# Rango de optimización del beta
beta = list(np.arange(0.01, 1, 0.25))
beta.append('symmetric')
# VTest de validación
num_of_docs = len(doc_clean)

model_results = {
                 'Topics': [],
                 'Alpha': [],
                 'Coherence': []
                }
n=0
for n_topic in topics_range:
    n += 1
    print("Va {} grupo de modelos ejecutado para {} de tópicos".format(n,n_topic))
    i=0
    for a in alpha:
        i+=1
        coherence_value = compute_coherence_values_lda(corpus = doc_term_matrix, texts=doc_clean, n_topics=n_topic, alpha=a,id2word=dictionary)
        print('Va {} modelo entrenado con un score de {}'.format(i, coherence_value))
        model_results['Topics'].append(n_topic)
        model_results['Alpha'].append(a)
        model_results['Coherence'].append(coherence_value)

resultados = pd.DataFrame(model_results)
resultados.sort_values('Coherence',ascending=False).head()
ldamodel3 = LDA(corpus = doc_term_matrix, num_topics=5, id2word=dictionary, passes=600,random_state=300,alpha=0.75)
coherence_model_lda = CoherenceModel(model=ldamodel2, texts= doc_clean, dictionary=dictionary, coherence='c_v')
coherence_lda = coherence_model_lda.get_coherence()

print('Coherence Score: {}'.format(coherence_lda))
print(ldamodel3.print_topics(num_topics=5, num_words=6))
print(ldamodel3.print_topics(num_topics=5, num_words=6))<jupyter_output>[(2, '0.014*"swap" + 0.014*"unwind" + 0.014*"equivalente" + 0.014*"registro" + 0.014*"acciones" + 0.009*"perdida"'), (4, '0.001*"iquitos" + 0.001*"distribuidor" + 0.001*"muebles" + 0.001*"consorcio" + 0.001*"maquinaria" + 0.001*"obras"'), (1, '0.012*"instrumentos" + 0.011*"inversiones" + 0.011*"ingresos" + 0.011*"contables" + 0.011*"coberturas" + 0.011*"cobertura"'), (3, '0.019*"arrendamiento" + 0.015*"bonos" + 0.015*"emision" + 0.011*"subsidiarias" + 0.009*"vigentes" + 0.009*"bolivianos"'), (5, '0.001*"iquitos" + 0.001*"distribuidor" + 0.001*"muebles" + 0.001*"consorcio" + 0.001*"maquinaria" + 0.001*"obras"')]<jupyter_text>PyLDAvis<jupyter_code>import pyLDAvis as ldavis
import pyLDAvis.gensim

ldavis.enable_notebook()
prepared_data = ldavis.gensim.prepare(ldamodel3, doc_term_matrix, dictionary)

prepared_data<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1356305835943845, 'fraction_numerical': 0.05708318830490776, 'mean_word_length': 5.525359576078729, 'pattern_counts': {'":': 0, '<': 22, '<?xml version=': 0, '>': 22, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 10, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '610997', 'license': 'MIT', 'n_tokens_mistral': 3622, 'n_tokens_neox': 3190, 'n_words': 612, 'path': 'Topic Modelling/Latent Dirichlet Allocation/LDA_Analysis_01.ipynb', 'repo_name': 'PBenavides/Kaggle_competitions', 'size': '8619'}