import pandas as pd import tweepy import re import emoji import spacy import gensim import json import string from spacy.tokenizer import Tokenizer from gensim.parsing.preprocessing import STOPWORDS as SW from wordcloud import STOPWORDS from gensim.corpora import Dictionary from gensim.models.coherencemodel import CoherenceModel from pprint import pprint import numpy as np import tqdm from gensim.parsing.preprocessing import preprocess_string, strip_punctuation, strip_numeric import torch from transformers import T5ForConditionalGeneration,T5Tokenizer from googletrans import Translator from bertopic import BERTopic from umap import UMAP from sklearn.feature_extraction.text import CountVectorizer from operator import itemgetter import gradio as gr global df bearer_token = 'AAAAAAAAAAAAAAAAAAAAACEigwEAAAAACoP8KHJYLOKCL4OyB9LEPV00VB0%3DmyeDROUvw4uipHwvbPPfnTuY0M9ORrLuXrMvcByqZhwo3SUc4F' client = tweepy.Client(bearer_token=bearer_token) nlp = spacy.load('en_core_web_lg') print('hi') def scrape(keywords): query = keywords + ' (lang:en OR lang:tl) -is:retweet' max_results = 100 tweet_fields=['geo', 'id', 'lang', 'created_at'] expansions=['geo.place_id'] place_fields = ['contained_within', 'country', 'country_code', 'full_name', 'geo', 'id', 'name', 'place_type'] response = client.search_recent_tweets( query=query, max_results=max_results, tweet_fields=tweet_fields, expansions=expansions, place_fields=place_fields ) tweets = [] for x in response[0]: tweets.append(str(x)) place_data = response[1] df = pd.DataFrame(tweets, columns=['tweet']) return place_data def get_example(dataset): df = pd.read_csv(dataset + '.csv') return df def give_emoji_free_text(text): """ Removes emoji's from tweets Accepts: Text (tweets) Returns: Text (emoji free tweets) """ emoji_list = [c for c in text if c in emoji.EMOJI_DATA] clean_text = ' '.join([str for str in text.split() if not any(i in str for i in emoji_list)]) return clean_text def url_free_text(text): ''' Cleans text from urls ''' text = re.sub(r'http\S+', '', text) return text def get_lemmas(text): '''Used to lemmatize the processed tweets''' lemmas = [] doc = nlp(text) for token in doc: if ((token.is_stop == False) and (token.is_punct == False)) and (token.pos_ != 'PRON'): lemmas.append(token.lemma_) return lemmas # Tokenizer function def tokenize(text): """ Parses a string into a list of semantic units (words) Args: text (str): The string that the function will tokenize. Returns: list: tokens parsed out """ # Removing url's pattern = r"http\S+" tokens = re.sub(pattern, "", text) # https://www.youtube.com/watch?v=O2onA4r5UaY tokens = re.sub('[^a-zA-Z 0-9]', '', text) tokens = re.sub('[%s]' % re.escape(string.punctuation), '', text) # Remove punctuation tokens = re.sub('\w*\d\w*', '', text) # Remove words containing numbers # tokens = re.sub('@*!*$*', '', text) # Remove @ ! $ tokens = tokens.strip(',') # TESTING THIS LINE tokens = tokens.strip('?') # TESTING THIS LINE tokens = tokens.strip('!') # TESTING THIS LINE tokens = tokens.strip("'") # TESTING THIS LINE tokens = tokens.strip(".") # TESTING THIS LINE tokens = tokens.lower().split() # Make text lowercase and split it return tokens def cleaning(df): df.rename(columns = {'tweet':'original_tweets'}, inplace = True) # Apply the function above and get tweets free of emoji's call_emoji_free = lambda x: give_emoji_free_text(x) # Apply `call_emoji_free` which calls the function to remove all emoji's df['emoji_free_tweets'] = df['original_tweets'].apply(call_emoji_free) #Create a new column with url free tweets df['url_free_tweets'] = df['emoji_free_tweets'].apply(url_free_text) f = open('stopwords-tl.json') tlStopwords = json.loads(f.read()) stopwords = set(STOPWORDS) stopwords.update(tlStopwords) stopwords.update(['na', 'sa', 'ko', 'ako', 'ng', 'mga', 'ba', 'ka', 'yung', 'lang', 'di', 'mo', 'kasi']) # Tokenizer tokenizer = Tokenizer(nlp.vocab) # Custom stopwords custom_stopwords = ['hi','\n','\n\n', '&', ' ', '.', '-', 'got', "it's", 'it’s', "i'm", 'i’m', 'im', 'want', 'like', '$', '@'] # Customize stop words by adding to the default list STOP_WORDS = nlp.Defaults.stop_words.union(custom_stopwords) # ALL_STOP_WORDS = spacy + gensim + wordcloud ALL_STOP_WORDS = STOP_WORDS.union(SW).union(stopwords) tokens = [] STOP_WORDS.update(stopwords) for doc in tokenizer.pipe(df['url_free_tweets'], batch_size=500): doc_tokens = [] for token in doc: if token.text.lower() not in STOP_WORDS: doc_tokens.append(token.text.lower()) tokens.append(doc_tokens) # Makes tokens column df['tokens'] = tokens # Make tokens a string again df['tokens_back_to_text'] = [' '.join(map(str, l)) for l in df['tokens']] df['lemmas'] = df['tokens_back_to_text'].apply(get_lemmas) # Make lemmas a string again df['lemmas_back_to_text'] = [' '.join(map(str, l)) for l in df['lemmas']] # Apply tokenizer df['lemma_tokens'] = df['lemmas_back_to_text'].apply(tokenize) def split_corpus(corpus, n): for i in range(0, len(corpus), n): corpus_split = corpus yield corpus_split[i:i + n] def compute_coherence_values_base_lda(dictionary, corpus, texts, limit, coherence, start=2, step=1): coherence_values = [] model_list = [] for num_topics in range(start, limit, step): model = gensim.models.ldamodel.LdaModel(corpus=corpus, num_topics=num_topics, random_state=100, chunksize=200, passes=10, per_word_topics=True, id2word=id2word) model_list.append(model) coherencemodel = CoherenceModel(model=model, texts=texts, dictionary=dictionary, coherence=coherence) coherence_values.append(coherencemodel.get_coherence()) return model_list, coherence_values def base_lda(): # Create a id2word dictionary global id2word id2word = Dictionary(df['lemma_tokens']) # Filtering Extremes id2word.filter_extremes(no_below=2, no_above=.99) # Creating a corpus object global corpus corpus = [id2word.doc2bow(d) for d in df['lemma_tokens']] global corpus_og corpus_og = [id2word.doc2bow(d) for d in df['lemma_tokens']] corpus_split = corpus split_corpus(corpus_split, 5) global coherence coherence = 'c_v' coherence_averages = [0] * 8 for i in range(5): training_corpus = corpus_split training_corpus.remove(training_corpus[i]) print(training_corpus[i]) model_list, coherence_values = compute_coherence_values_base_lda(dictionary=id2word, corpus=training_corpus, texts=df['lemma_tokens'], start=2, limit=10, step=1, coherence=coherence) for j in range(len(coherence_values)): coherence_averages[j] += coherence_values[j] limit = 10; start = 2; step = 1; x = range(start, limit, step) coherence_averages = [x / 5 for x in coherence_averages] if coherence == 'c_v': k_max = max(coherence_averages) else: k_max = min(coherence_averages, key=abs) global num_topics num_topics = coherence_averages.index(k_max) + 2 def compute_coherence_values2(corpus, dictionary, k, a, b): lda_model = gensim.models.ldamodel.LdaModel(corpus=corpus, id2word=id2word, num_topics=num_topics, random_state=100, chunksize=200, passes=10, alpha=a, eta=b, per_word_topics=True) coherence_model_lda = CoherenceModel(model=lda_model, texts=df['lemma_tokens'], dictionary=id2word, coherence='c_v') return coherence_model_lda.get_coherence() def hyperparameter_optimization(): grid = {} grid['Validation_Set'] = {} min_topics = 1 max_topics = 10 step_size = 1 topics_range = range(min_topics, max_topics, step_size) alpha = [0.05, 0.1, 0.5, 1, 5, 10] # alpha.append('symmetric') # alpha.append('asymmetric') beta = [0.05, 0.1, 0.5, 1, 5, 10] # beta.append('symmetric') num_of_docs = len(corpus_og) corpus_sets = [gensim.utils.ClippedCorpus(corpus_og, int(num_of_docs*0.75)), corpus_og] corpus_title = ['75% Corpus', '100% Corpus'] model_results = {'Validation_Set': [], 'Alpha': [], 'Beta': [], 'Coherence': [] } if 1 == 1: pbar = tqdm.tqdm(total=540) for i in range(len(corpus_sets)): for a in alpha: for b in beta: cv = compute_coherence_values2(corpus=corpus_sets[i], dictionary=id2word, k=num_topics, a=a, b=b) model_results['Validation_Set'].append(corpus_title[i]) model_results['Alpha'].append(a) model_results['Beta'].append(b) model_results['Coherence'].append(cv) pbar.update(1) pd.DataFrame(model_results).to_csv('lda_tuning_results_new.csv', index=False) pbar.close() params_df = pd.read_csv('lda_tuning_results_new.csv') params_df = params_df[params_df.Validation_Set == '75% Corpus'] params_df.reset_index(inplace=True) params_df = params_df.replace(np.inf, -np.inf) max_params = params_df.loc[params_df['Coherence'].idxmax()] max_coherence = max_params['Coherence'] max_alpha = max_params['Alpha'] max_beta = max_params['Beta'] max_validation_set = max_params['Validation_Set'] global lda_model_final lda_model_final = gensim.models.ldamodel.LdaModel(corpus=corpus_og, id2word=id2word, num_topics=num_topics, random_state=100, chunksize=200, passes=10, alpha=max_alpha, eta=max_beta, per_word_topics=True) coherence_model_lda = CoherenceModel(model=lda_model_final, texts=df['lemma_tokens'], dictionary=id2word, coherence='c_v') coherence_lda = coherence_model_lda.get_coherence() return coherence_lda def assignMaxTopic(l): maxTopic = max(l,key=itemgetter(1))[0] return maxTopic def assignTopic(l): topics = [] for x in l: topics.append(x[0]) def topic_assignment(df): lda_topics = lda_model_final.show_topics(num_words=10) topics = [] filters = [lambda x: x.lower(), strip_punctuation, strip_numeric] for topic in lda_topics: topics.append(preprocess_string(topic[1], filters)) df['topic'] = [sorted(lda_model_final[corpus_og][text][0]) for text in range(len(df['original_tweets']))] df = df[df['topic'].map(lambda d: len(d)) > 0] df['max_topic'] = df['topic'].map(lambda row: assignMaxTopic(row)) global topic_clusters topic_clusters = [] for i in range(num_topics): topic_clusters.append(df[df['max_topic'].isin(([i]))]) topic_clusters[i] = topic_clusters[i]['original_tweets'].tolist() def get_topic_value(row, i): if len(row) == 1: return row[0][1] else: try: return row[i][1] except Exception as e: print(e) def reprsentative_tweets(): global top_tweets top_tweets = [] for i in range(len(topic_clusters)): tweets = df.loc[df['max_topic'] == i] tweets['topic'] = tweets['topic'].apply(lambda x: get_topic_value(x, i)) # tweets['topic'] = [row[i][1] for row in tweets['topic']] tweets_sorted = tweets.sort_values('topic', ascending=False) tweets_sorted.drop_duplicates(subset=['original_tweets']) rep_tweets = tweets_sorted['original_tweets'] rep_tweets = [*set(rep_tweets)] top_tweets.append(rep_tweets[:5]) # print('Topic ', i) # print(rep_tweets[:5]) return top_tweets def topic_summarization(topic_groups): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = T5ForConditionalGeneration.from_pretrained("Michau/t5-base-en-generate-headline") tokenizer = T5Tokenizer.from_pretrained("Michau/t5-base-en-generate-headline") model = model.to(device) translator = Translator() headlines = [] for i in range(len(topic_groups)): tweets = " ".join(topic_groups[i]) # print(tweets) out = translator.translate(tweets, dest='en') text = out.text # print(tweets) max_len = 256 encoding = tokenizer.encode_plus(text, return_tensors = "pt") input_ids = encoding["input_ids"].to(device) attention_masks = encoding["attention_mask"].to(device) beam_outputs = model.generate( input_ids = input_ids, attention_mask = attention_masks, max_length = 64, num_beams = 3, early_stopping = True, ) result = tokenizer.decode(beam_outputs[0]) headlines += "Topic " + str(i) + " " + result return headlines def compute_coherence_value_bertopic(topic_model): topic_words = [[words for words, _ in topic_model.get_topic(topic)] for topic in range(len(set(topics))-1)] coherence_model = CoherenceModel(topics=topic_words, texts=df['lemma_tokens'], corpus=corpus, dictionary=id2word, coherence=coherence) coherence_score = coherence_model.get_coherence() return coherence_score def base_bertopic(): df['lemma_tokens_string'] = df['lemma_tokens'].apply(lambda x: ' '.join(x)) global id2word id2word = Dictionary(df['lemma_tokens']) global corpus corpus = [id2word.doc2bow(d) for d in df['lemma_tokens']] global umap_model umap_model = UMAP(n_neighbors=15, n_components=5, min_dist=0.0, metric='cosine', random_state=100) base_topic_model = BERTopic(umap_model=umap_model, language="english", calculate_probabilities=True) topics, probabilities = base_topic_model.fit_transform(df['lemma_tokens_string']) try: print(compute_coherence_value_bertopic(base_topic_model)) except: print('Unable to generate meaningful topics (Base BERTopic model)') def optimized_bertopic(): vectorizer_model = CountVectorizer(max_features=1_000, stop_words="english") optimized_topic_model = BERTopic(umap_model=umap_model, language="multilingual", n_gram_range=(1, 3), vectorizer_model=vectorizer_model, calculate_probabilities=True) topics, probabilities = optimized_topic_model.fit_transform(df['lemma_tokens_string']) try: print(compute_coherence_value_bertopic(optimized_topic_model)) except: print('Unable to generate meaningful topics, base BERTopic model if possible') rep_docs = optimized_topic_model.representative_docs_ global top_tweets top_tweets = [] for topic in rep_docs: if topic == -1: print('test') continue topic_docs = rep_docs.get(topic) tweets = [] for doc in topic_docs: index = df.isin([doc]).any(axis=1).idxmax() # print(index) tweets.append(df.loc[index, 'original_tweets']) print(tweets) top_tweets.append(tweets) global examples def main(dataset, model): global df examples = [ "katip,katipunan", "bgc,bonifacio global city", "pobla,poblacion", "cubao", "taft" ] keyword_list = dataset.split(',') if len(keyword_list) > 1: keywords = '(' + ' OR '.join(keyword_list) + ')' else: keywords = keyword_list[0] if dataset in examples: df = get_example(keywords) place_data = 'test' else: print(dataset) place_data = str(scrape(keyword_list)) print(df) cleaning(df) print(df) if model == 'LDA': base_lda() coherence = hyperparameter_optimization() topic_assignment(df) top_tweets = reprsentative_tweets() else: base_bertopic() optimized_bertopic() headlines = topic_summarization(top_tweets) headlines = '\n'.join(str(h) for h in headlines) return place_data, headlines iface = gr.Interface(fn=main, inputs=[gr.Dropdown(["katip,katipunan", "bgc,bonifacio global city", "cubao", "taft", "pobla,poblacion"], label="Dataset"), gr.Dropdown(["LDA", "BERTopic"], label="Model") ], # examples=examples, outputs=["text", "text"] ) iface.launch()