prima versione funzionante

app.py

@@ -3,6 +3,9 @@ import os
 from transformers import pipeline
 from HFBot import HFBot
 from textutils import ParagraphDocumentProcessor, WholeTextDocumentProcessor, SmallFragmentDocumentProcessor
+import pandas as pd
+from ragpipeline import RAGPipeline, Retriever
+
 def main():
     modelliLLM = [
             'Almawave/Velvet-2B',
@@ -15,28 +18,36 @@ def main():
     UPLOAD_DIR="/tmp/"
     if "indice_creato" not in st.session_state:
         st.session_state["indice_creato"] = False
+    if "faiss_builder" not in st.session_state:
+        ragpipeline = RAGPipeline( )
+    codice_tabella = f"<table><tr><td>💡AURA:</td><td> AI-Utilizzata per la Regolarità Amministrativa</td></tr></table>"
+    st.markdown(codice_tabella, unsafe_allow_html=True)
+    st.title("Cosa è AURA?")
+    st.write("""
+             Questo strumento, sperimentale, è stato realizzato per eseguire i controlli di 
+             regolarità amministrativa ex art. 147-bis del D.Lgs 267/2000 relativamente agli atti del PNRR.
+             E' in continua evoluzione. Per testarne il funzionamento è suddiciente caricare un file PDF contenente una determinazione dirigenziale.
+             AURA risponderà in base ad una check list predefinita di domande.
+             
+             """)
 
-    testi = []
+    st.warning("Attenzione questo tool è sperimentale. AURA può sbagliare")
     modello_scelto = st.selectbox("Seleziona un modello:", modelliLLM, index=0)
     st.write(f"Hai selezionato: {modello_scelto}")
 
     LLM = HFBot(model_name=modello_scelto)
-    domanda ="Valuta questo testo"
-    Istruzioni = "Rispondi sinteticamente"
-    frammenti = [
-        "visto il DPR 445/2000" , "con sui si elegge il presidente della repubblica"
-    ]
+ 
     
      #res = LLM.chat(domanda=domanda, istruzioni= Istruzioni, frammenti=frammenti)
     #st.write(f"Domanda {domanda} - risposta {res}")
     st.title("Suddivisione in paragrafi")
     docprocessor_options = {
         "ParagraphDocumentProcessor": ParagraphDocumentProcessor(),
-        "WholeText": WholeTextDocumentProcessor(),
-        "Small Fragments": SmallFragmentDocumentProcessor(),
+      #  "WholeText": WholeTextDocumentProcessor(),
+        "Small Fragments (più veloce ma poco preciso)": SmallFragmentDocumentProcessor(),
     }
     selected_docprocessor = st.selectbox("Divisione in paragrafi", docprocessor_options.keys())
-    docprocessor = docprocessor_options[selected_docprocessor]
+    ragpipeline.docprocessor = docprocessor_options[selected_docprocessor]
     st.write(f"Hai selezionato: **{selected_docprocessor}**")
     
     if not st.session_state["indice_creato"]:
@@ -51,19 +62,55 @@ def main():
                     save_path = os.path.join(UPLOAD_DIR, main_pdf.name)
                     with open(save_path, "wb") as f:
                         f.write(main_pdf.read())
+                        ragpipeline.aggiungi_file_pdf(save_path)
                     st.success(f"✅  Determinazione caricata con successo! File salvato in: `{save_path}`")
-                    testi= docprocessor.estrai_da_pdf(save_path)
-                    st.write(testi[:400])
-                    #ßragpipeline.aggiungi_file_pdf(save_path)
+                    ragpipeline.crea_indice( )
+                    st.success("Indice FAISS generato e caricato.")
                     st.session_state["indice_creato"] = True
                 except Exception as e:
                     st.error(f"❌ Errore nel salvataggio del file: {e}")
             else:
                 st.warning("Nessun PDF di Determinazione caricato.")
         if st.session_state["indice_creato"]:
-            st.write("Eseguo riassunto")
-            summary = LLM.riassumi(testi)
-            st.success(summary)
+            st.write("Eseguo controlli")
+            csv_file ="domandePNRR.xlsx"
+
+
+            df = pd.read_excel(csv_file)
+            if "domanda" in df.columns:
+                domande = df["domanda"].tolist()
+                istruzioni = df["istruzioni"].tolist();
+                #print(f"ISTRUZIONI {istruzioni}")
+                st.success(f"Caricate {len(domande)} domande!")
+                if ragpipeline.indice is not None :
+                    #cb = ChatBot(model_name="flaollama", model_orig=modello_scelto)
+                    st.write("**Risposte automatiche per ciascuna domanda **:")
+                    i = 0
+                    for domanda in domande:
+                        istruzione = istruzioni[i]
+                        ret = Retriever (indice=ragpipeline.indice,
+                                         sentence_transformer_model=ragpipeline.sentence_transformer_model,
+                                         query=domanda ,
+                                         documenti=ragpipeline.documenti,
+                                         frammenti_indicizzati= ragpipeline.frammenti_indicizzati,
+                                         attributi_frammenti= ragpipeline.attributi_frammenti
+                                         )
+                        ret.esegui_query( top_k=3  )
+                        risposta = LLM.generate(query=domanda,
+                                               relevant_docs=ret.passaggi_rilevanti,attributi_frammenti_rilevanti=ret.attributi_rilevanti,
+                                               istruzioni=istruzione)
+                        st.markdown(
+                            f"<p><strong>Domanda:</strong> {domanda}  Istruzioni:  <em>{istruzione}</em><br/><br/>"
+                            f"<strong>Risposta:</strong><em> {risposta}</em></p>",
+                            unsafe_allow_html=True
+                        )
+                    
+
+                        i = i+1
+
+
+
+            
 
 if __name__ == "__main__":
     main()

ragpipeline.py

@@ -0,0 +1,99 @@
+from textutils import ParagraphDocumentProcessor, DocumentProcessor
+from sentence_transformers import SentenceTransformer
+from transformers import AutoTokenizer, AutoModel
+import faiss
+import os
+import csv
+import re
+import pandas as pd
+
+
+class RAGPipeline:
+    def __init__(self, 
+                 model_name: str = "flaollama",
+                 model_orig: str = "mistral",
+                 docprocessor = ParagraphDocumentProcessor(),
+                 sentence_transformer_name: str = 'paraphrase-multilingual-MiniLM-L12-v2',
+                 numero_frammenti = 10
+                )       :
+        self.model_name = model_name
+        self.model_orig = model_orig
+        self.docprocessor = docprocessor
+        self.sentence_transformer_name = sentence_transformer_name
+        self.sentence_transformer_model = SentenceTransformer(             self.sentence_transformer_name         )
+        self.numero_frammenti = numero_frammenti
+        
+        self.documenti = []
+        self.files_pdf =[]
+        self.indice =False
+        
+        ##attrributi_frammenti contiene una lista di frammenti con attribui es:
+        ##
+        ##
+        ##
+        self.attributi_frammenti = [] #elenco di dizionari di tutti i frammenti
+        ##LISTA DI FRAMMENTI INDICIZZATI (lista di testi)
+        self. frammenti_indicizzati = [] #sonoi testi dei vari frammenti
+        #print(f"NUMERODI FRAMMENTIIIII {self.numero_frammenti} param {numero_frammenti}")
+    
+
+    def crea_indice(self):
+            # Converte i documenti in vettori
+        docId  = 0
+        fraId = 0
+        for documento in self.documenti:
+            frammenti = self.docprocessor.scomponi_in_frammenti(documento, self.numero_frammenti )
+            for frammento in frammenti:
+                dizionario_frammenti = {
+                                                'id': f"{docId}-{fraId}",  
+                                               "documento": docId, 
+                                               "frammento": fraId, 
+                                        
+                                                'testo_frammento':frammento 
+                                                }
+                self.attributi_frammenti.append( dizionario_frammenti )
+                self.frammenti_indicizzati.append(frammento)
+                fraId = fraId +1
+            docId = docId +1
+        self.doc_embeddings = self.sentence_transformer_model.encode(self.frammenti_indicizzati)
+        # Creazione dell'indice Faiss
+        dimension = self.doc_embeddings.shape[1]
+        self.indice = faiss.IndexFlatL2(dimension)  # Indice L2 (distanza euclidea)
+        self.indice.add(self.doc_embeddings)
+
+    def aggiungi_file_pdf(self, filename: str)    :
+        text= self.docprocessor.estrai_da_pdf(filename)
+        self.documenti.append(text)
+        self.files_pdf.append(filename)
+
+class Retriever:
+    def __init__(self,
+         indice , 
+         sentence_transformer_model ,
+         query : str,
+         documenti =[],
+         frammenti_indicizzati = [], #tutti i frammenti ??
+         attributi_frammenti = [] ##elenco attrivuti frammenti
+
+    ):
+        self.indice = indice
+        self.sentence_transformer = sentence_transformer_model
+        self.query = query
+        self.documenti = documenti
+        self.frammenti_indicizzati = frammenti_indicizzati
+        self.attributi_frammenti = attributi_frammenti
+        self.passaggi_rilevanti = []  ## documenti rilevanti per la query (recuperati)
+        self.attributi_rilevanti = [] ## atteributi dei frammenti rilevanti
+    
+    def esegui_query(self, top_k = 5):
+        # Embedding della query
+        query_embedding = self.sentence_transformer.encode([self.query])
+
+        # Recupero dei documenti più simili
+        distances, indices = self.indice.search(query_embedding, top_k)
+
+    # documenti rilevanti e passaggi rilevanti
+        self.passaggi_rilevanti = [self.frammenti_indicizzati[j] for j in indices[0]] #frammenti rilevanti
+        self.attributi_rilevanti = [self.attributi_frammenti[j] for j in indices[0]] #passaggi rilevanti
+        
+

textutils.py

@@ -151,7 +151,7 @@ class SmallFragmentDocumentProcessor(DocumentProcessor):
     def scomponi_in_frammenti(self, testo:str, numero_frammenti: int = 1):
          return self.dividi_testo_in_frammenti(testo)
     
-    def dividi_testo_in_frammenti(self,testo, lunghezza_massima=500):
+    def dividi_testo_in_frammenti(self,testo, lunghezza_massima=1000):
         frammenti = []
         inizio = 0