<jupyter_start><jupyter_text>**Resolução Lista 4**---<NAME> <NAME><jupyter_code>#from google.colab import files
#uploaded = files.upload()
# upando train_data e test_data_solution
!pip install yellowbrick
!pip install umap-learn
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import umap
import random
import time
import nltk
import re
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import LatentDirichletAllocation, TruncatedSVD, NMF, PCA
from sklearn.cluster import KMeans
from bokeh.palettes import Category20
from bokeh.plotting import figure
from bokeh.io import output_notebook, show
from sklearn.manifold import TSNE
from yellowbrick.cluster import KElbowVisualizer
from IPython.display import HTML, display
import warnings
warnings.filterwarnings('ignore')
output_notebook()
nltk.download('stopwords')
nltk.download('punkt')
nltk.download('rslp')
df = pd.read_csv('train_data.txt', sep =':::', header = None, engine = 'python', nrows = 2000)
df.columns = ['id', 'title', 'genre', 'description']
df2 = pd.read_csv('test_data_solution.txt', sep =':::', header = None, engine = 'python', nrows = 2000)
df2.columns = ['id', 'title', 'genre', 'description']
dataset = pd.concat([df, df2], ignore_index=True)
dataset.drop(['id','genre'], axis=1, inplace=True)
def preprocess(description):
  description = re.sub(r'\w*\d\w*', '', description) #remove todas as palavras que contêm números
  description = re.sub(r'[^a-zA-Z ]', '', description.lower())
  return re.sub(r'\s+', ' ', description) #retira espaços repetidos
dataset['processed_description'] = dataset.description.apply(preprocess)
stop_words = set(nltk.corpus.stopwords.words('english'))
def remove_stopwords(description):
    tokenized_text = nltk.word_tokenize(description, language='english')
    return " ".join([token for token in tokenized_text if token not in stop_words])
dataset['processed_description'] = dataset.processed_description.apply(remove_stopwords)
dataset<jupyter_output><empty_output><jupyter_text>Questão 1Realize um comparativo entre os métodos LDA, SVD e NMF para realizarmodelagem de tópicos. Para cada método:a) empiricamente, tente identificar uma quantidade de tópicos adequada paraseu problema. Exiba resultados que justifiquem a quantidade de tópicosescolhida;b) identifique as 5 palavras mais relevantes de cada tópico;c) identifique os 3 tópicos mais relevantes de 5 documentos quaisquer (vocêpode representar os tópicos por suas 5 palavras mais relevantes).d) qual método apresentou melhores resultados, na sua opinião? Justifique com resultados/dados.<jupyter_code>n_topics = 5
samples = dataset.sample(n=5)
samples.reset_index(inplace=True)
samples<jupyter_output><empty_output><jupyter_text>Utilizando TF-IDF como embbeding dos textos<jupyter_code>tfidf = TfidfVectorizer()
X = tfidf.fit_transform(dataset.processed_description)
for decomposition_algorithm in (LatentDirichletAllocation, TruncatedSVD, NMF):
    algorithm = decomposition_algorithm(n_components=n_topics)
    X_topics = algorithm.fit_transform(X)

    def get_top_words(topic, n, words, algorithm):
      sorted_idxs = np.argsort(algorithm.components_[topic])
      top_words = [words[i] for i in sorted_idxs]
      return [w for w in reversed(top_words[-n:])]

    print(f'Algoritmo: {decomposition_algorithm.__name__}')
    for i in range(n_topics):
        print(f'Tópico {i + i} -> {get_top_words(i, 5, tfidf.get_feature_names(), algorithm)}')
    print('\n')

    sample_topics = algorithm.transform(tfidf.transform(samples.processed_description))

    for i, sample in samples.iterrows():
        print(f'{sample.title}')
        print(sample.description[:70] + '...')
        print(sample_topics[i])
        print('\n')<jupyter_output>Algoritmo: LatentDirichletAllocation
Tópico 0 -> ['one', 'life', 'film', 'story', 'time']
Tópico 2 -> ['life', 'film', 'one', 'story', 'new']
Tópico 4 -> ['life', 'young', 'film', 'one', 'world']
Tópico 6 -> ['life', 'one', 'new', 'film', 'world']
Tópico 8 -> ['life', 'film', 'new', 'one', 'world']


 The Obsidian Curse (2016) 
 <NAME>, a young mother, get's released out of prison after bein...
[0.02949073 0.02925364 0.88301041 0.02924527 0.02899995]


 Missing, Believed Married (1937) 
 A heiress discovers during her engagement that the man she is about t...
[0.8635487  0.03421241 0.03404556 0.03404888 0.03414445]


 The Seduction of Jo<NAME> (1979) 
 Respected liberal Senator <NAME> is asked to lead the opposition t...
[0.02837264 0.0280808  0.88754593 0.0279945  0.02800614]


 The Kois: Fish Out of Water (2009) 
 The ups and downs of teen life are magnified by an all-girl high scho...
[0.02047709 0.02046967 0.0203794  0.91832165 0.02035218]


 Fast Zombies with Guns (2009)[...]<jupyter_text>Melhor algoritmo: NMF  Questão 2Realize um agrupamento dos dados seguindo os seguintes passos:a) Aplique o algoritmo PCA, preservando 95% da variância nos dados. Qual adimensão resultante dos dados projetados?b) Aplique um algoritmo k-means nos dados projetados, usando o método elbowpara encontrar o valor de k ótimo.c) Finalmente, aplique um algoritmo k-means nos dados originais (sem projeçãopor PCA), usando o método elbow para encontrar o valor de k ótimo.<jupyter_code>stemmer = nltk.stem.RSLPStemmer()
dataset['stemmed_text'] = dataset.processed_description.apply(lambda tokens: ' '.join([stemmer.stem(token) for token in tokens.split(' ')]))
X = tfidf.fit_transform(dataset.stemmed_text)
Xproj = PCA(n_components=.95).fit_transform(X.toarray())
Xproj.shape[1]
visualizer = KElbowVisualizer(KMeans(), k=(10, 25), metric='distortion')
visualizer.fit(Xproj)
visualizer.show()
k = 13
kmeans_proj = KMeans(n_clusters=k).fit(Xproj)
visualizer = KElbowVisualizer(KMeans(), k=(10, 25), metric='distortion')
visualizer.fit(X)
visualizer.show()
k = 11
kmeans = KMeans(n_clusters=k).fit(X)<jupyter_output><empty_output><jupyter_text>Questão 3Nesta questão você deve aplicar métodos de projeção multidimensional para visualizar os dados da segunda questão no espaço visual.a) aplique os métodos de projeção multidimensional t-SNE e UMAP nos dados resultantes da questão 2b, e plote os gráficos das projeções resultantes, codificando as cores dos pontos de acordo com os grupos obtidos pelo k-means.b) compare o tempo de execução e a qualidade visual da projeção dos 2 métodosde projeção multidimensional, no resultado da questão 2b.c) usando o método de projeção multidimensional que gerou melhores resultados no item anterior, calcule a projeção nos resultados da questão 2c e compare visualmente os resultados da questão 2b e 2c. Qual abordagemfuncionou melhor?<jupyter_code>start = time.time()
X_tsne = TSNE(n_components = 2).fit_transform(Xproj)
duration = time.time() - start
print('%s segundos' %duration)
palette = Category20[k]
def scatter_plot(X, labels):
  scatter_plot = figure(plot_width = 1000, plot_height = 500)
  scatter_plot.circle(X[:, 0], X[:, 1], size = 10, line_color=[palette[l] for l in labels], 
                      fill_color=[palette[l] for l in labels], fill_alpha=.8)
  show(scatter_plot)
scatter_plot(X_tsne, kmeans.labels_)
start = time.time()
X_umap = umap.UMAP().fit_transform(Xproj)
duration = time.time() - start
print('%s segundos' %duration)
scatter_plot(X_umap, kmeans.labels_)<jupyter_output><empty_output><jupyter_text>O melhor método de projeção multidimensional foi o TSNE. Usando o TSNE nos dados não projetados:<jupyter_code>start = time.time()
X_tsne = TSNE(n_components = 2).fit_transform(X)
duration = time.time() - start
print('%s segundos' %duration)
scatter_plot(X_tsne, kmeans.labels_)
dataset['label'] = kmeans.labels_
def cluster_topic(dataset, cluster_label, n_words):
  X = tfidf.fit_transform(dataset[dataset['label'] == cluster_label].processed_description)
  nmf = NMF(n_components=1)
  X_topics = nmf.fit_transform(X)
  return get_top_words(0, n_words, tfidf.get_feature_names(), nmf)
n_words = 10
display(HTML('<h2>Top {} palavras de cada grupo</h2>'.format(n_words)))
for label, color in enumerate(palette):
  display(HTML('<h3><span style="color:{}"><strong>Grupo {}: {}</strong></span></h3>'.format(color, label, ', '.join(cluster_topic(dataset, label, n_words)))))<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11856606515683663, 'fraction_numerical': 0.03330507448225748, 'mean_word_length': 5.824793388429752, 'pattern_counts': {'":': 0, '<': 37, '<?xml version=': 0, '>': 43, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '119800', 'license': 'MIT', 'n_tokens_mistral': 3115, 'n_tokens_neox': 2834, 'n_words': 772, 'path': 'pln_lista4.ipynb', 'repo_name': 'audreyemmely/pln', 'size': '8316'}