Upload 10 files

app.py

@@ -0,0 +1,260 @@
+import numpy as np
+import pandas as pd
+import streamlit as st
+import streamlit.components.v1 as components
+from transformers import *
+from carga_articulos import cargar_articulos
+from preprocesamiento_articulos import limpieza_articulos, remove_URL, remove_html_markup, remove_emoji, remover_casos_especiales, frases_remover, obtener_kpes
+from entrenamiento_modelo import term_document_matrix, tf_idf_score
+from resultados_consulta import resultados_consulta, detalles_resultados
+import tensorflow as tf
+import tensorflow.python.ops.numpy_ops.np_config as np_config
+from math import ceil
+from datetime import datetime
+
+###
+
+def split_frame(input_df, rows):
+    df=[]
+    for i in range(0, len(input_df), rows):
+        df.append(input_df.iloc[i : i + rows, :])
+    return df
+
+def paginar_frame(df):
+     N_cards_per_row = 1
+     for n_row, row in df.reset_index().iterrows():
+        i = n_row%N_cards_per_row
+        if i==0:
+            st.write("---")
+            cols = st.columns(N_cards_per_row, gap="large")
+        # draw the card
+        with cols[n_row%N_cards_per_row]:
+            if 'answer' in row:
+                if (row['answer']):
+                    t= row['answer'] + ' (score: ' + str(row['score']) + ')'
+                    st.info(t)
+            row['resumen']=remove_html_markup(row['resumen'])
+            row['resumen']=remove_URL(row['resumen'])
+            if (len(row['resumen'])>600):
+                row['resumen']=row['resumen'][0:600]     
+            st.caption(f"{row['feed'].strip()} - {row['seccion'].strip()} - {row['fecha'].strip()} ")
+            st.markdown(f"**{row['titulo'].strip()}**")
+            st.markdown(f"{row['resumen'].strip()}")
+            st.markdown(f"{row['link']}")
+
+def load_qa_model():
+
+    tokenizer = AutoTokenizer.from_pretrained('dccuchile/bert-base-spanish-wwm-uncased', use_fast="false")
+    model = TFAutoModelForQuestionAnswering.from_pretrained("Lisibonny/modelo_qa_beto_squad_es_pdqa")
+    return tokenizer, model
+
+# 4. Use streamlit to create a web app
+def main():
+
+    
+    
+    st.set_page_config(page_title="Buscador de noticias periodicos dominicanos", page_icon="📰", layout="centered")
+    st.image('repartidor_periodicos.jpeg', width=150)
+    st.header('El Repartidor Dominicano :red[experimental]')
+
+    df, fecha_min, fecha_max=cargar_articulos()
+    fecha_min=fecha_min[:19]
+    fecha_max=fecha_max[:19]
+
+    fecha_min=datetime.strptime(fecha_min, '%Y-%m-%d %H:%M:%S')
+    fecha_max=datetime.strptime(fecha_max, '%Y-%m-%d %H:%M:%S')
+    
+    days=(fecha_max-fecha_min).days
+    fecha_min=fecha_min.strftime("%d-%m-%Y %I:%M %p")
+    fecha_max=fecha_max.strftime("%d-%m-%Y %I:%M %p")
+    
+    usar_barra_progreso=1 
+    
+    # Sidebar
+    st.sidebar.header("Acerca De")
+    st.sidebar.markdown(
+        "El Repartidor Dominicano es un sistema de recuperación de información desde periódicos dominicanos que usa técnicas de aprendizaje automático."
+    )
+    st.sidebar.markdown("Desarrollado por [Lisibonny Beato-Castro](https://scholar.google.com/citations?user=KSzjfeUAAAAJ&hl=es&oi=ao)")
+    
+    st.sidebar.header("Artículos Indexados")
+    st.sidebar.markdown(
+        """
+    Fuentes: 
+
+     - [Diario Libre](https://www.diariolibre.com/)
+     - [El Nacional](https://www.elnacional.com.do/)
+     - [Remolacha.net](https://www.remolacha.net/)
+     - [AlMomento.net](https://almomento.net/)
+     - [Gente Tuya](http://www.gentetuya.com)
+    
+    """
+    )
+    st.sidebar.markdown(f"Noticias de los últimos: **{days} días**")
+    st.sidebar.markdown(f"Fecha más antigua: **{fecha_min}**")
+    st.sidebar.markdown(f"Fecha más reciente: **{fecha_max}**")
+    st.sidebar.header("Aviso Legal Sobre Uso de Datos")
+    st.sidebar.markdown(
+        """
+        El uso de los artículos en este sitio tiene fines no comerciales, respetando los derechos de autor. Implementamos las mejores prácticas para el uso de RSS, tal y como son recomendadas por el Berkman Klein Center for Internet & Society de la Universidad de Harvard.
+        
+        Si quieres saber más acerca de los feeds RSS o de las mejores prácticas para el uso de RSS, haz clic en los siguientes enlaces:
+        
+        - [RSS](https://es.wikipedia.org/wiki/RSS)
+        - [Uso legal de feeds RSS](https://cyber.harvard.edu/publications/2010/news_aggregator_legal_implications_best_practices)
+        """
+    )
+
+    st.sidebar.header("¡Cómprame un Café!")
+    st.sidebar.markdown("Si te gusta este sitio y quieres darme las gracias o animarme a hacer más, puedes hacer una pequeña donación.")
+    with st.sidebar:
+        st.markdown("[![Haz clic aquí](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/donate/?hosted_button_id=VK5ZAB52ZYDNA)")
+
+
+    articulos_indexados = pd.read_csv('articulos_indexados.csv')
+    articulos_indexados = articulos_indexados.set_index('Unnamed: 0')
+    tokenizer, qa_model = load_qa_model()
+    kpes=obtener_kpes(df)
+
+    query = st.text_input(
+        "Escribe tus términos de búsqueda o haz una pregunta usando los caracteres ¿?:"
+    )
+
+    # Topicos populares
+    st.write("Tópicos populares en los artículos indexados:")
+    cadena  = ':blue['
+    for value in kpes:
+        cadena = cadena + ' - ' + str(value[0])
+    cadena=cadena + ']'    
+    st.write(cadena)
+    
+    if query:
+
+        # Si se especifico una pregunta
+        
+        if (('¿' == query[0]) and ('?' == query[len(query)-1])):
+           st.write("Contestando a: ", query)
+           # Verificando cada resumen de los articulos como contexto a la pregunta 
+           cantidad_respuestas = 0 
+           lista_noticias_respuestas = [] 
+           all_results = pd.DataFrame(columns=["id","answer","score","start","end"])
+           df_answer=df
+           df_answer['answer']=''
+           df_answer['score'] =0
+            
+            
+           progress_text = "Buscando respuestas. Por favor, espere."
+           my_bar = st.progress(0, text=progress_text)
+           total_respuestas = len(df_answer)
+           for i in range(total_respuestas):
+                     
+               text=remove_html_markup(df_answer.loc[i, "resumen"])
+               text=remove_URL(text)
+               text=remove_emoji(text)
+               text=frases_remover(text)
+               text=remover_casos_especiales(text)
+               
+               inputs =  tokenizer(query, text[0:512], return_tensors='tf')
+               input_ids = inputs["input_ids"].numpy()[0]
+
+               text_tokens = tokenizer.convert_ids_to_tokens(input_ids)
+               outputs = qa_model(inputs)
+               answer_start = tf.argmax(outputs.start_logits, axis=1).numpy()[0]
+               answer_end = (tf.argmax(outputs.end_logits, axis=1) + 1).numpy()[0] 
+                
+               answer = tokenizer.convert_tokens_to_string(tokenizer.convert_ids_to_tokens(input_ids[answer_start:answer_end]))
+
+               all_results.loc[i] = i,answer, max(outputs.start_logits.numpy()[0]), 0, 0
+                           
+               # Barra de progreso
+               if (usar_barra_progreso==1):
+                   porcentaje_progreso = round((i/total_respuestas)*100)
+                   if (porcentaje_progreso in range (1,101)):
+                       my_bar.progress(porcentaje_progreso, text=progress_text)
+           
+           my_bar.empty()
+           usar_barra_progreso = 0
+
+           # Obteniendo las respuestas con los 10 scores mas altos
+           all_results=all_results.sort_values(by=['score'], ascending=False).head(5)
+           # Si hay alguna de ellas que diga que no hay respuesta, no se traera ninguna 
+           if not (all_results['answer'].isnull().any()):
+               for index, row in all_results.iterrows():
+                   if (len(row['answer'])>0):    
+                       cantidad_respuestas = cantidad_respuestas + 1
+                       i=row['id']
+                       df_answer.loc[i, "answer"] = row.loc['answer']
+                       df_answer.loc[i, "score"]= row.loc['score']
+                       lista_noticias_respuestas.append(df_answer.loc[i].to_frame().T)
+            
+           df_noticias_respuestas=pd.concat(lista_noticias_respuestas)
+           batch_size = 5
+           pages = split_frame(df_noticias_respuestas, batch_size)
+           top_menu = st.columns(3)
+                
+           pagination = st.container()
+            
+           bottom_menu = st.columns((3))
+
+           with pagination: 
+            
+               with bottom_menu[2]:
+                   total_pages = (ceil(cantidad_respuestas / batch_size) if ceil(cantidad_respuestas / batch_size) > 0 else 1)
+                   current_page = st.number_input("Página", min_value=1, max_value=total_pages, step=1)  
+                    
+               with bottom_menu[1]:
+                   st.write("---")
+                   st.markdown(f"Página **{current_page}** de **{total_pages}** ") 
+                    
+               with top_menu[0]:
+                   pagina_res_fin= batch_size*current_page if batch_size*current_page <= cantidad_respuestas else cantidad_respuestas
+                   st.markdown(f"Respuestas **{(current_page*batch_size)-batch_size+1}-{pagina_res_fin}**  de  **{cantidad_respuestas}** ") 
+                        
+               paginar_frame(pages[current_page - 1]) 
+                  
+                   
+
+        # Si se especificaron keywords
+        else:    
+
+            st.write("Buscando: ", query)
+            result = resultados_consulta(df,articulos_indexados, query)
+
+            if result.empty:
+                st.info("No se encontraron artículos para la búsqueda solicitada")
+
+            else:
+            
+                df_results=detalles_resultados(df,result)
+                cantidad_resultados=len(df_results)
+                batch_size = 5
+                pages = split_frame(df_results, batch_size)
+                top_menu = st.columns(3)
+                    
+                pagination = st.container()
+                
+                
+                bottom_menu = st.columns((3))
+            
+                
+                    
+                with bottom_menu[2]:
+                    total_pages = (ceil(cantidad_resultados / batch_size) if ceil(cantidad_resultados / batch_size) > 0 else 1)
+                    current_page = st.number_input("Página", min_value=1, max_value=total_pages, step=1)  
+                    
+                with bottom_menu[1]:
+                    st.write("---")
+                    st.markdown(f"Página **{current_page}** de **{total_pages}** ") 
+                    
+                with top_menu[0]:
+                    pagina_res_fin= batch_size*current_page if batch_size*current_page <= cantidad_resultados else cantidad_resultados
+                    st.markdown(f"Artículos **{(current_page*batch_size)-batch_size+1}-{pagina_res_fin}**  de  **{cantidad_resultados}** ") 
+                
+                with pagination:        
+                
+                    paginar_frame(pages[current_page - 1])
+                
+                
+                        
+if __name__ == "__main__": 
+    main() 

carga_articulos.py

@@ -0,0 +1,20 @@
+import pandas as pd
+import streamlit as st
+from dateutil.parser import parse
+import locale
+
+def cargar_articulos():
+    articulos = pd.read_csv('articulos_ultima_semana.csv')
+    #articulos=articulos.iloc[0:250,:] # Cargando solo 250
+    # Eliminando la primera columna
+    articulos.drop("Unnamed: 0", axis=1, inplace=True)
+    # creando columna nueva ID
+    articulos['ID']=articulos.index 
+    articulos.ID = pd.Series(["D"+str(ind) for ind in articulos.ID])
+    fechas=articulos['fecha'].apply(lambda x: parse(x))
+    fechas=fechas.astype(str)
+    fecha_minima=fechas.min()
+    fecha_maxima=fechas.max()
+    # Retornando el dataframe con los articulos y algunos datos al respecto
+    return articulos, fecha_minima, fecha_maxima
+

config.toml.txt

@@ -0,0 +1,6 @@
+[theme]
+base = 'dark'
+primaryColor = 'F63366'
+font = 'sans serif'
+[server]
+enableCORS = false

entrenamiento_modelo.py

@@ -0,0 +1,50 @@
+import pandas as pd
+import numpy as np
+
+
+# data = Conjunto de datos. Es un dataframe
+# vocab = el vocabulario obtenido desde los documentos. Es una lista de cadenas.
+# document_index = Nombre de la columna del dataframe en donde esta el id de los documentos
+# text = Nombre de la columna del dataframe donde esta el texto de los documentos
+
+def term_document_matrix (df, vocab, document_index, text):
+    
+    vocab_index = pd.DataFrame(columns=df[document_index], index=vocab).fillna(0)
+    
+    for word in vocab_index.index:
+        for doc in df[document_index]:
+            freq = df[df[document_index]==doc][text].values[0].count(word)
+            vocab_index.loc[word,doc]=freq
+    return vocab_index        # Devuelve un dataframe con la matriz de los documentos y sus frecuencias 
+
+
+
+# vocab_index = Es el term document matrix que se calcula en la seccion anterior
+# document_index = Serie conteniendo los ids de los documentos. 
+# inv_df = Nombre de la columna que contiene la frecuencia inversa de los documentos calculada
+
+
+def tf_idf_score(vocab_index, document_index, inv_df='inverse_document_frequency'):
+    
+    total_docx=len(document_index)
+    vocab_index['document_frequency']=vocab_index.sum(axis=1)
+    vocab_index['inverse_document_frequency']=np.log2(total_docx/vocab_index['document_frequency'])
+    
+    for word in vocab_index.index:
+        
+        for doc in document_index:
+            
+            tf_idf=np.log2(1+vocab_index.loc[word,doc]) * np.log2(vocab_index.loc[word][inv_df])
+            vocab_index.loc[word]['tf_idf_'+str(doc)]=tf_idf
+                           
+        return vocab_index    # Devuelve un dataframe que contiene: matriz de los terminos del documento,
+                              # la frecuencia de los documentos, la frecuencia inversa de los documentos,
+                              # y el score tf_idf 
+    
+    
+
+def generar_archivo_indexado():
+
+
+
+    return 0   

preprocesamiento_articulos.py

@@ -0,0 +1,106 @@
+import pandas as pd
+import numpy as np
+import nltk
+from nltk.tokenize import word_tokenize, RegexpTokenizer
+from nltk.corpus import stopwords
+from nltk.stem import SnowballStemmer
+import textacy
+
+from sklearn.feature_extraction.text import CountVectorizer
+import csv
+import re
+
+nltk.download('stopwords')
+nltk.download('punkt')
+stopwords_es = stopwords.words('spanish')
+spanish_stemmer = SnowballStemmer('spanish')
+
+
+
+
+def remove_html_markup(s):
+    tag = False
+    quote = False
+    out = ""
+
+    for c in s:
+            if c == '<' and not quote:
+                tag = True
+            elif c == '>' and not quote:
+                tag = False
+            elif (c == '"' or c == "'") and tag:
+                quote = not quote
+            elif not tag:
+                out = out + c
+
+    return out
+
+def remove_URL(s):
+    """Remove URLs from a sample string"""
+    return re.sub(r"http\S+", "", s)    
+    
+def eliminar_puntuacion(articulo):
+    deletetion_symbols = ['!','(',')',"'",'-','[',']','{','}',';',':','"','“','’','”',"'",'`','‘','``','\\' ,'/','|',',','|','<','>','.','..','...','?','@',"#",'$','^','&','*','_','~','+','%','=','¿','¡',"''"]
+    new_articulo = ""
+    for x in articulo:
+        if x not in deletetion_symbols:
+            new_articulo += x
+    return new_articulo  
+
+def remove_emoji(s):
+    regrex_pattern = re.compile(pattern = "["
+        u"\U0001F600-\U0001F64F"  # emoticons
+        u"\U0001F300-\U0001F5FF"  # symbols & pictographs
+        u"\U0001F680-\U0001F6FF"  # transport & map symbols
+        u"\U0001F1E0-\U0001F1FF"  # flags (iOS)
+                           "]+", flags = re.UNICODE)
+    return regrex_pattern.sub(r'',s)
+
+def remover_casos_especiales(s):
+    #Removiendo texto que termina con .-, ya que usualmente es un texto que se usa como inicio de algunos articulos
+    s= re.sub(r'^\w+(,)*([\s]\w+)*([\s]\(\w+\))*.-','',s)    
+    return s
+
+def frases_remover(s):
+    lista_frases_remover=['La entrada', 'la entrada', '(Seguir leyendo…)', 'se publicó primero en', 'Remolacha - Noticias Republica Dominicana', 'Read more ›', 'Read more','[…]', 'RELACIONADAS']
+    for l in lista_frases_remover:
+        s = s.replace(l, '')
+    return s            
+
+def eliminar_stopwords(articulo):
+
+    articulo_splitted=articulo.split()
+    new_articulo = ""
+    for x in articulo_splitted:
+        if x not in stopwords_es:
+            new_articulo += " " + x
+    return new_articulo  
+
+def obtener_raices(articulo):
+
+    articulo_splitted=articulo.split()
+    new_articulo = ""
+    for x in articulo_splitted:
+        x_new = spanish_stemmer.stem(x)
+        new_articulo += " " + x_new
+    return new_articulo 
+    
+def limpieza_articulos(df):
+    
+    df_titulos=pd.DataFrame(df['titulo'], columns=['titulo'])
+    # Colocando texto en minusculas
+    df_titulos['titulo']= df_titulos['titulo'].apply(lambda x: x.lower())
+    # Eliminando signos de puntuacion
+    df_titulos['titulo']= df_titulos['titulo'].apply(lambda x: eliminar_puntuacion(x))
+    # Eliminando palabras vacias (stopwords) utilizando el corpus para estos fines que tiene nltk
+    df_titulos['titulo']= df_titulos['titulo'].apply(lambda x: eliminar_stopwords(x))
+    all_text = ' '. join(df_titulos['titulo'])
+    vocab= np.unique(word_tokenize(all_text))
+    return vocab
+
+def obtener_kpes(df):
+    df_titulos=pd.DataFrame(df['titulo'], columns=['titulo'])
+    all_text = '. '. join(df_titulos['titulo'])
+    titulos=textacy.make_spacy_doc(all_text, lang='es_core_news_sm')
+    return textacy.extract.keyterms.textrank(titulos,normalize='lower',topn=10)
+    

requirements.txt

@@ -0,0 +1,14 @@
+fastapi[all]
+openai
+python-dotenv
+pydantic==1.*
+langchain
+bs4
+tiktoken
+nltk
+scikit-learn
+transformers
+tf-keras
+accelerate
+textacy
+https://github.com/explosion/spacy-models/releases/download/es_core_news_sm-3.7.0/es_core_news_sm-3.7.0.tar.gz

resultados_consulta.py

@@ -0,0 +1,86 @@
+import pandas as pd
+import numpy as np
+from preprocesamiento_articulos import remove_URL, remove_html_markup, eliminar_puntuacion, eliminar_stopwords, obtener_raices
+import streamlit as st
+
+
+# La idea aqui es colocar el query en minusculas y limpiar el query de palabras vacias y algunos caracteres
+
+def query_processing (query):
+    query=eliminar_puntuacion(query) # Quitando signos de puntuacion
+    query = query.strip().lower() # Minusculas
+    query = eliminar_stopwords(query)
+    query = obtener_raices(query)
+    return query
+
+
+# vocab_index = Matriz de terminos del documento, con todas las frecuencias calculadas. En nuestro caso
+                # es lo que tenemos en el csv. Se debe cargar a un dataframe.
+# Query       = Consulta realizada
+
+def query_score(vocab_index, query):
+    for word in np.unique(query.split()):
+        freq=query.count(word)
+        if word in vocab_index.index:
+            tf_idf = np.log2(1+freq) * np.log2(vocab_index.loc[word].inverse_document_frequency)
+            vocab_index.loc[word,"query_tf_idf"] = tf_idf
+            vocab_index['query_tf_idf'].fillna(0, inplace=True)
+                
+    return vocab_index # Matriz tf_idf para los terminos de los documentos y para el los terminos del query. Es un DF.
+            
+
+ # vocab_index = DataFrame que contiene los scores tf-idf por termino para cada documento y para cada query
+# document_index = Lista de los IDs de los documentos
+# query_scores = Nombre de la columna del dataframe que contiene los scores tf_idf del query
+        
+
+def cosine_similarity(vocab_index, document_index, query_scores):
+   
+    cosine_scores = {}
+    
+    query_scalar = np.sqrt(sum(vocab_index[query_scores] ** 2))
+    
+    for doc in document_index:
+            
+        doc_scalar = np.sqrt(sum(vocab_index[str(doc)] ** 2))
+        dot_prod = sum(vocab_index[str(doc)] * vocab_index[query_scores])
+        cosine = (dot_prod / (query_scalar * doc_scalar))
+        
+        cosine_scores[doc] = cosine
+        
+    return pd.Series(cosine_scores) # Es una serie pandas que devuelve las puntuaciones de similitud del query para cada
+                                    # documento
+
+
+# data: Dataframe que contiene los ids y el texto de los documentos
+# cosine_scores: Serie que contiene los scores de coseno de los documentos
+# document_index: Nombre de la columna que contiene los ids de los documentos en el dataframe data
+
+def retrieve_index(data,cosine_scores, document_index, topn=10):
+    
+    data = data.set_index(document_index)
+    data['scores'] = cosine_scores
+    df_top_scores=data.reset_index().sort_values('scores',ascending=False).head(topn)
+    cutoff=np.average(df_top_scores['scores'])+0.75*np.std(df_top_scores['scores']) # Se usa una formula sugerida en la literatura como score de corte
+    df_top_scores=df_top_scores[df_top_scores['scores'] > cutoff]
+    
+    return df_top_scores.index # Dataframe original con los scores 
+                               # del coseno en una columna nueva 
+
+
+def resultados_consulta(df,articulos_indexados, query):
+    indices = pd.Index([], dtype='int64')
+    query=query_processing(query)
+    qs=query_score(articulos_indexados,query)
+    if 'query_tf_idf' in qs.columns:
+        cosenos = cosine_similarity(qs, df['ID'].values, 'query_tf_idf')
+        indices = retrieve_index(df, cosenos, 'ID', len(df))
+    return indices
+    
+def detalles_resultados(df,indices):   
+    top=df.loc[indices]
+    top['resumen']=top['resumen'].apply(lambda x: remove_html_markup(x))
+    top['resumen']=top['resumen'].apply(lambda x: remove_URL(x))
+    top['resumen']=top['resumen'].apply(lambda x: x[0:600] + '[...]' if len(x)>600  else x)
+    top=top.loc[:,['titulo', 'link', 'fecha', 'resumen', 'seccion', 'feed']]
+    return top