Upload 12 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+articulos.csv filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,17 @@
----
-title: Buscador Periodicos Dominicanos
-emoji: 📈
-colorFrom: blue
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.33.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Personal Intelligent Agent: This is Your Personal Intelligent Agent for doing research work, answering questions, and solving problems
+
+Steps: 
+0. Search API:
+serper api free credits:
+https://serper.dev/dashboard
+
+1. Test on portal:
+pip install streamlit
+streamlit run app.py
+
+
+2. Test on API:
+run fast api:
+uvicorn app:app --host 0.0.0.0 --port 10000
+
+python test_server.py

app.py

@@ -0,0 +1,72 @@
+import pandas as pd
+import streamlit as st
+from transformers import pipeline
+from carga_articulos import cargar_articulos
+from preprocesamiento_articulos import limpieza_articulos
+from entrenamiento_modelo import term_document_matrix, tf_idf_score
+from resultados_consulta import resultados_consulta, detalles_resultados
+
+def crear_indice():
+    df=cargar_articulos()
+    vocab = limpieza_articulos(df)
+
+    td_matrix=term_document_matrix(df, vocab, 'ID', 'titulo')
+    td_idf_matrix=tf_idf_score(td_matrix, df.ID.values)
+
+    td_idf_matrix.to_csv('articulos_indexados.csv') 
+
+def load_qa_model():
+    model = pipeline("question-answering")
+    return model
+
+# 4. Use streamlit to create a web app
+def main():
+
+    #crear_indice()  
+
+    st.set_page_config(page_title="Buscador de noticias periodicos dominicanos", page_icon="📰")
+    st.header('El Repartidor Dominicano')
+    st.image('repartidor_periodicos.jpeg', width=150)
+
+    df=cargar_articulos()
+    articulos_indexados = pd.read_csv('articulos_indexados.csv')
+    articulos_indexados = articulos_indexados.set_index('Unnamed: 0')
+    qa = load_qa_model()
+    sentence="The house is blue"
+
+    query = st.text_input(
+        "Escribe tus términos de búsqueda o haz una pregunta terminando con el caracter ?:"
+    )
+
+    if query:
+
+        if ('?' in query):
+           st.write("Contestando a: ", query)
+           answers = qa(question=query, context=sentence)
+           st.info(answers['answer'])     
+
+        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:
+                #st.write(detalles_resultados(df,result), unsafe_allow_html=True)
+                df_results=detalles_resultados(df,result)
+                N_cards_per_row = 1
+                for n_row, row in df_results.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]:
+                        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']}")
+if __name__ == "__main__":
+    main()

articulos.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae2500b42f5dcd8fbc7e7553228236e4fd97a32d29d24e8afbaa12b111b08889
+size 99898509

carga_articulos.py

@@ -0,0 +1,14 @@
+import pandas as pd
+import streamlit as st
+
+@st.cache_data
+def cargar_articulos():
+    articulos = pd.read_csv('articulos.csv')
+    articulos=articulos.iloc[0:100,:] # Cargando solo 20
+    # 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])
+    # Retornando el dataframe con los articulos 
+    return articulos

config.toml

@@ -0,0 +1,4 @@
+[theme]
+base = 'dark'
+primaryColor = 'F63366'
+font = 'sans serif'

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,38 @@
+import pandas as pd
+import numpy as np
+from nltk.tokenize import word_tokenize, RegexpTokenizer
+from nltk.corpus import stopwords
+from sklearn.feature_extraction.text import CountVectorizer
+import csv
+
+stopwords_es = stopwords.words('spanish')
+
+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 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 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

requirements.txt

@@ -0,0 +1,9 @@
+fastapi[all]
+openai
+python-dotenv
+pydantic==1.*
+langchain
+bs4
+tiktoken
+nltk
+scikit-learn

resultados_consulta.py

@@ -0,0 +1,80 @@
+import pandas as pd
+import numpy as np
+from preprocesamiento_articulos import eliminar_puntuacion, eliminar_stopwords
+
+
+# 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)
+    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)
+    df_top_scores=df_top_scores[df_top_scores['scores'] > 0]
+    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', 100) # LUEGO PARAMETRIZAR ESTE NUMERO
+    return indices
+    
+def detalles_resultados(df,indices):   
+    top=df.loc[indices]
+    top=top.loc[:,['titulo', 'link', 'fecha', 'resumen', 'seccion', 'feed']]
+    return top
+