AshenClock commited on
Commit
4c13256
·
verified ·
1 Parent(s): ac52c4d

Update app.py

Browse files
Files changed (1) hide show
  1. app.py +52 -24
app.py CHANGED
@@ -21,7 +21,9 @@ client = InferenceClient(api_key=API_KEY)
21
  # File RDF
22
  RDF_FILE = "Ontologia.rdf"
23
 
 
24
  # Caricamento RDF (riassunto)
 
25
  def load_rdf_summary():
26
  """
27
  Carica un riassunto dell'ontologia dal file RDF.
@@ -53,7 +55,9 @@ def load_rdf_summary():
53
  rdf_context = load_rdf_summary()
54
  logger.info("RDF Summary: %s", rdf_context)
55
 
 
56
  # Validazione SPARQL
 
57
  def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
58
  """
59
  Verifica la validità della query SPARQL.
@@ -67,18 +71,23 @@ def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
67
  logger.error(f"Errore durante la validazione della query SPARQL: {e}")
68
  return False
69
 
 
70
  # Prompt di Sistema
 
71
  def create_system_message(rdf_context: str) -> str:
 
 
 
72
  return f"""
73
- Sei un assistente esperto nella generazione di query SPARQL basate su un'ontologia RDF, nell'interpretazione dei risultati delle query SPARQL in risposte naturali, e nel fare chatting minimale con i visitatori. In base alla domanda dell'utente, devi decidere se:
74
-
75
  1. Generare una query SPARQL per interrogare la base di conoscenza.
76
  2. Fornire una risposta naturale basata sui risultati di una query SPARQL.
77
  3. Rispondere con una risposta di chat minimale.
78
-
79
  Ecco un riassunto dell'ontologia su cui devi lavorare:
80
  {rdf_context}
81
-
82
  Regole TASSATIVE:
83
  1. Se la domanda richiede una query SPARQL, restituisci la query SPARQL come testo semplice.
84
  2. Se la domanda richiede l'interpretazione di risultati SPARQL, restituisci una risposta naturale basata sui risultati.
@@ -88,25 +97,30 @@ Regole TASSATIVE:
88
  5. NON generare alcun altro prefisso o URI inventato.
89
  6. Se non puoi rispondere con una query SPARQL valida, interpretare i risultati o fare chatting, scrivi:
90
  "Non posso generare una query SPARQL, interpretare i risultati o fare una risposta di chat per questa richiesta."
91
-
92
  Esempi:
93
  - Domanda: "Quali sono le statue esposte del periodo medievale?"
94
  Risposta:
95
- PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/> SELECT ?statua WHERE { ?statua a base:Statua . ?statua base:Periodo_Storico "Medioevo" . }
96
-
97
  - Domanda: "La query ha restituito 5 statue. Puoi descriverle?"
98
  Risposta:
99
  Ecco le 5 statue medievali trovate: Statua1, Statua2, Statua3, Statua4, Statua5.
100
-
101
  - Domanda: "Ciao!"
102
  Risposta:
103
  Ciao! Come posso aiutarti oggi?
104
-
105
  RISPONDI ESCLUSIVAMENTE CON IL FORMATO SPECIFICATO.
106
  """
107
 
 
108
  # Funzione per chiamare il modello
 
109
  async def call_model(messages, temperature=0.7, max_tokens=2048):
 
 
 
110
  try:
111
  response = client.chat.completions.create(
112
  model="Qwen/Qwen2.5-72B-Instruct",
@@ -123,24 +137,38 @@ async def call_model(messages, temperature=0.7, max_tokens=2048):
123
  logger.error(f"Errore nel modello: {e}")
124
  raise HTTPException(status_code=500, detail=str(e))
125
 
 
126
  # Funzione di Interpretazione dei Risultati SPARQL
127
- def interpret_sparql_results(results):
 
128
  """
129
- Trasforma i risultati di una query SPARQL in una risposta naturale.
130
  """
131
  if not results:
132
- return "Non sono state trovate informazioni corrispondenti alla tua richiesta."
133
 
134
- # Esempio semplice: elenca gli elementi trovati
135
- interpreted = "Ecco i risultati trovati: "
136
- items = []
137
- for row in results:
138
- items.append(", ".join([f"{k}: {v}" for k, v in row.asdict().items()]))
139
- interpreted += "; ".join(items) + "."
 
 
 
 
 
 
 
 
 
140
 
141
- return interpreted
 
142
 
 
143
  # FastAPI
 
144
  app = FastAPI()
145
 
146
  class QueryRequest(BaseModel):
@@ -171,14 +199,14 @@ async def generate_response(request: QueryRequest):
171
  g = Graph()
172
  g.parse(RDF_FILE, format="xml")
173
  results = g.query(sparql_query)
174
- # Interpreta i risultati in una risposta naturale
175
- interpreted_response = interpret_sparql_results(results)
176
- return {"type": "SPARQL", "response": interpreted_response}
177
  except Exception as e:
178
  logger.error(f"Errore durante l'esecuzione della query SPARQL: {e}")
179
- return {"type": "SPARQL", "response": "Errore nell'esecuzione della query SPARQL."}
180
  else:
181
- return {"type": "SPARQL", "response": "Query SPARQL non valida."}
182
 
183
  elif "Non posso generare una query SPARQL" in response_text:
184
  # Risposta di errore dal modello
 
21
  # File RDF
22
  RDF_FILE = "Ontologia.rdf"
23
 
24
+ ####################################
25
  # Caricamento RDF (riassunto)
26
+ ####################################
27
  def load_rdf_summary():
28
  """
29
  Carica un riassunto dell'ontologia dal file RDF.
 
55
  rdf_context = load_rdf_summary()
56
  logger.info("RDF Summary: %s", rdf_context)
57
 
58
+ ####################################
59
  # Validazione SPARQL
60
+ ####################################
61
  def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
62
  """
63
  Verifica la validità della query SPARQL.
 
71
  logger.error(f"Errore durante la validazione della query SPARQL: {e}")
72
  return False
73
 
74
+ ####################################
75
  # Prompt di Sistema
76
+ ####################################
77
  def create_system_message(rdf_context: str) -> str:
78
+ """
79
+ Crea il messaggio di sistema per il modello di linguaggio naturale.
80
+ """
81
  return f"""
82
+ Sei un'assistente esperta nella generazione di query SPARQL basate su un'ontologia RDF, nell'interpretazione dei risultati delle query SPARQL in risposte naturali, e nel fare chatting minimale con i visitatori. In base alla domanda dell'utente, devi decidere se:
83
+
84
  1. Generare una query SPARQL per interrogare la base di conoscenza.
85
  2. Fornire una risposta naturale basata sui risultati di una query SPARQL.
86
  3. Rispondere con una risposta di chat minimale.
87
+
88
  Ecco un riassunto dell'ontologia su cui devi lavorare:
89
  {rdf_context}
90
+
91
  Regole TASSATIVE:
92
  1. Se la domanda richiede una query SPARQL, restituisci la query SPARQL come testo semplice.
93
  2. Se la domanda richiede l'interpretazione di risultati SPARQL, restituisci una risposta naturale basata sui risultati.
 
97
  5. NON generare alcun altro prefisso o URI inventato.
98
  6. Se non puoi rispondere con una query SPARQL valida, interpretare i risultati o fare chatting, scrivi:
99
  "Non posso generare una query SPARQL, interpretare i risultati o fare una risposta di chat per questa richiesta."
100
+
101
  Esempi:
102
  - Domanda: "Quali sono le statue esposte del periodo medievale?"
103
  Risposta:
104
+ PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/> SELECT ?statua WHERE {{ ?statua a base:Statua . ?statua base:Periodo_Storico "Medioevo" . }}
105
+
106
  - Domanda: "La query ha restituito 5 statue. Puoi descriverle?"
107
  Risposta:
108
  Ecco le 5 statue medievali trovate: Statua1, Statua2, Statua3, Statua4, Statua5.
109
+
110
  - Domanda: "Ciao!"
111
  Risposta:
112
  Ciao! Come posso aiutarti oggi?
113
+
114
  RISPONDI ESCLUSIVAMENTE CON IL FORMATO SPECIFICATO.
115
  """
116
 
117
+ ####################################
118
  # Funzione per chiamare il modello
119
+ ####################################
120
  async def call_model(messages, temperature=0.7, max_tokens=2048):
121
+ """
122
+ Chiama il modello di linguaggio naturale con i messaggi forniti.
123
+ """
124
  try:
125
  response = client.chat.completions.create(
126
  model="Qwen/Qwen2.5-72B-Instruct",
 
137
  logger.error(f"Errore nel modello: {e}")
138
  raise HTTPException(status_code=500, detail=str(e))
139
 
140
+ ####################################
141
  # Funzione di Interpretazione dei Risultati SPARQL
142
+ ####################################
143
+ async def interpret_sparql_results(results):
144
  """
145
+ Invia i risultati delle query SPARQL al modello per ottenere una risposta naturale.
146
  """
147
  if not results:
148
+ return "Mi dispiace, non sono riuscita a trovare le informazioni che stavi cercando."
149
 
150
+ # Converti i risultati in una stringa leggibile
151
+ results_str = "\n".join([", ".join([f"{k}: {v}" for k, v in row.asdict().items()]) for row in results])
152
+
153
+ # Crea un prompt per il modello per interpretare i risultati
154
+ interpret_prompt = f"""
155
+ Mi hai fornito i seguenti risultati di una query SPARQL:
156
+ {results_str}
157
+
158
+ Per favore, interpreta questi risultati e fornisci una risposta naturale ed enfatica come farebbe una guida museale femminile.
159
+ """
160
+
161
+ messages = [
162
+ {"role": "system", "content": interpret_prompt},
163
+ {"role": "user", "content": ""}
164
+ ]
165
 
166
+ natural_response = await call_model(messages, temperature=0.7, max_tokens=2048)
167
+ return natural_response
168
 
169
+ ####################################
170
  # FastAPI
171
+ ####################################
172
  app = FastAPI()
173
 
174
  class QueryRequest(BaseModel):
 
199
  g = Graph()
200
  g.parse(RDF_FILE, format="xml")
201
  results = g.query(sparql_query)
202
+ # Interpreta i risultati in una risposta naturale tramite il modello
203
+ interpreted_response = await interpret_sparql_results(results)
204
+ return {"type": "NATURAL", "response": interpreted_response}
205
  except Exception as e:
206
  logger.error(f"Errore durante l'esecuzione della query SPARQL: {e}")
207
+ return {"type": "ERROR", "response": "Mi dispiace, c'è stato un errore nell'esecuzione della tua richiesta."}
208
  else:
209
+ return {"type": "ERROR", "response": "La query SPARQL generata non è valida. Per favore, riprova con una domanda diversa."}
210
 
211
  elif "Non posso generare una query SPARQL" in response_text:
212
  # Risposta di errore dal modello