import os import pandas as pd from datetime import date import gradio as gr from pyvis.network import Network import ast from openai import OpenAI import json import string from datetime import datetime import random EMM_RETRIEVERS_OPENAI_API_BASE_URL = "https://api-gpt.jrc.ec.europa.eu/v1" #with open('./data/gpt_token.json', 'r') as file: # config = json.load(file) # EMM_RETRIEVERS_OPENAI_API_KEY = config['EMM_RETRIEVERS_OPENAI_API_KEY'] EMM_RETRIEVERS_OPENAI_API_KEY = os.environ['key_gptjrc'] client1 = OpenAI( api_key=EMM_RETRIEVERS_OPENAI_API_KEY, base_url="https://api-gpt.jrc.ec.europa.eu/v1", ) df = pd.read_csv("https://jeodpp.jrc.ec.europa.eu/ftp/jrc-opendata/ETOHA/storylines/emdat2.csv", sep=',', header=0, dtype=str, encoding='utf-8') def gpt_story(storyline): prompt = ( "Use the information provided to create a short, clear, and useful narrative about a disaster event. " "The goal is to help decision-makers (e.g. policy makers, disaster managers, civil protection) understand what happened, why, and what it caused. " "Keep it short and focused.\n\n" "Include all key information, but keep the text concise and easy to read. Avoid technical jargon.\n\n" "Steps to Follow:\n" "1. Start with what happened: Briefly describe the disaster event (what, where, when, who was affected).\n" "2. Explain why it happened: Use the evidence provided to describe possible causes or triggers (e.g. heavy rainfall, poor infrastructure, heatwave).\n" "3. Show the impacts: Highlight key impacts such as fatalities, displacement, health effects, or damage.\n" "4. Connect the dots: Show how different factors are linked. Use simple cause-effect language (e.g. drought led to crop failure, which caused food insecurity).\n" "5. Mention complexity if needed: If there were multiple contributing factors or reinforcing effects (e.g. climate + conflict), briefly explain them.\n" "6. Keep it useful: Write with a decision-maker in mind. Focus on what matters: drivers, impacts, and lessons for preparedness or response.\n\n" f"Information: {storyline}" ) completion = client1.chat.completions.create( model='gpt-4o', messages=[ {"role": "system", "content": "You are a disaster manager expert in risk dynamics."}, {"role": "user", "content": prompt} ] ) # Extract the content from the response message_content = completion.choices[0].message.content return message_content # DataFrame to store evaluation data evaluation_df = pd.DataFrame(columns=["DisNo.", "TPN", "TPL", "FPN", "FPL", "FNN", "FNL", "User ID"]) def try_parse_date(y, m, d): try: if not y or not m or not d: return None return date(int(float(y)), int(float(m)), int(float(d))) except (ValueError, TypeError): return None def plot_cgraph_pyvis(grp): if not grp: return "
No data available to plot.
" net = Network(notebook=False, directed=True) edge_colors_dict = {"causes": "red", "prevents": "green"} for src, rel, tgt in grp: src = str(src) tgt = str(tgt) rel = str(rel) net.add_node(src, shape="circle", label=src) net.add_node(tgt, shape="circle", label=tgt) edge_color = edge_colors_dict.get(rel, 'black') net.add_edge(src, tgt, title=rel, label=rel, color=edge_color) net.repulsion( node_distance=200, central_gravity=0.2, spring_length=200, spring_strength=0.05, damping=0.09 ) net.set_edge_smooth('dynamic') html = net.generate_html() html = html.replace("'", "\"") # Adjust the iframe style to center the graph and fit the container html_s = f"""
""" return html_s def generate_unique_user_id(): # Generate a timestamp string timestamp_str = datetime.now().strftime("%Y%m%d%H%M%S") # Generate a random string of 5 letters random_str = ''.join(random.choices(string.ascii_letters, k=5)) # Combine both to form a unique User ID return f"{timestamp_str}_{random_str}" def save_data_to_csv(): # Save the evaluation DataFrame to a CSV file evaluation_df.to_csv("evaluation_data.csv", index=False) print("Data saved to CSV successfully.") def save_data(dis_no, tpn, tpl, fp_node, fp_link, fn_node, fn_link): global evaluation_df # Debug: Print input values to ensure they're being received correctly print( f"Inputs received - DisNo: {dis_no}, TPN: {tpn}, TPL: {tpl}, FPN: {fp_node}, FPL: {fp_link}, FNN: {fn_node}, FNL: {fn_link}") # Check if a valid disaster number has been selected if not dis_no or dis_no == "Select a Disaster Event": print("Invalid input. Ensure a disaster event is selected.") return # Ensure no output is returned # Generate a unique User ID user_id = generate_unique_user_id() # Append the new data to the DataFrame new_data = pd.DataFrame([[dis_no, tpn, tpl, fp_node, fp_link, fn_node, fn_link, user_id]], columns=["DisNo.", "TPN", "TPL", "FPN", "FPL", "FNN", "FNL", "User ID"]) evaluation_df = pd.concat([evaluation_df, new_data], ignore_index=True) # Debug: Print the updated DataFrame to verify the new row addition print("Updated DataFrame:") print(evaluation_df) # Save the DataFrame to a CSV file save_data_to_csv() print( f"Data saved: DisNo: {dis_no}, TPN: {tpn}, TPL: {tpl}, FPN: {fp_node}, FPL: {fp_link}, FNN: {fn_node}, FNL: {fn_link}, User ID: {user_id}") def update_row_dropdown(disaster_type=None, country=None): # Start with the entire dataframe filtered_df = df # Step 1: Filter by Disaster Type if disaster_type: filtered_df = filtered_df[filtered_df['Disaster Type'] == disaster_type] # Step 2: Further filter by Country if country: filtered_df = filtered_df[filtered_df['Country'] == country] # Step 3: Generate the DisNo. choices based on the filtered DataFrame choices = filtered_df['DisNo.'].tolist() if not filtered_df.empty else [] # Add a placeholder option at the beginning choices = ["Select a Disaster Event"] + choices print(f"Available DisNo. for {disaster_type} in {country}: {choices}") # Return the update for the dropdown, defaulting to the placeholder return gr.update(choices=choices, value=choices[0] if choices else None) def display_info(selected_row_str, country): if not selected_row_str or selected_row_str == 'Select a Disaster Event': print("No valid disaster event selected.") return ('No valid event selected.', '
No graph available.
', '', '') print(f"Selected Country: {country}, Selected Row: {selected_row_str}") # Filter the dataframe for the selected disaster number row_data = df[df['DisNo.'] == selected_row_str].squeeze() if not row_data.empty: print(f"Row data: {row_data}") # Combine the relevant columns into a single storyline with labels storyline_parts = [ f"Key Information: {row_data.get('key information', '')}", f"Severity: {row_data.get('severity', '')}", f"Key Drivers: {row_data.get('key drivers', '')}", f"Main Impacts, Exposure, and Vulnerability: {row_data.get('main impacts, exposure, and vulnerability', '')}", f"Likelihood of Multi-Hazard Risks: {row_data.get('likelihood of multi-hazard risks', '')}", f"Best Practices for Managing This Risk: {row_data.get('best practices for managing this risk', '')}", f"Recommendations and Supportive Measures for Recovery: {row_data.get('recommendations and supportive measures for recovery', '')}" ] storyline = "\n\n".join(part for part in storyline_parts if part.split(': ')[1]) # Include only non-empty parts cleaned_storyline = gpt_story(storyline) causal_graph_caption = row_data.get('llama graph', '') grp = ast.literal_eval(causal_graph_caption) if causal_graph_caption else [] causal_graph_html = plot_cgraph_pyvis(grp) # Parse and format the start date start_date_str = f"{row_data['Start Year']}-{row_data['Start Month']}-{row_data['Start Day']}" # Parse and format the end date end_date_str = f"{row_data['End Year']}-{row_data['End Month']}-{row_data['End Day']}" return ( cleaned_storyline, causal_graph_html, start_date_str, end_date_str ) else: print("No valid data found for the selection.") return ('No valid data found.', '
No graph available.
', '', '') def build_interface(): with gr.Blocks() as interface: gr.Markdown( """ # From Complexity to Clarity: Leveraging AI to Decode Interconnected Risks Welcome to our Gradio application, developed and maintained by [JRC](https://joint-research-centre.ec.europa.eu/index_en/) Units: **E1**, **F7**, and **T5**. This is part of the **EMBRACE Portfolio on Risks**.

**Overview**: This application employs advanced AI techniques like Retrieval-Augmented Generation (RAG) on [EMM](https://emm.newsbrief.eu/) news. It extracts relevant media content on disaster events recorded in [EM-DAT](https://www.emdat.be/), including floods, wildfires, droughts, epidemics, and disease outbreaks.

**How It Works**: For each selected event (filterable by Disaster Type, Country, and Disaster Number), the app: - Retrieves pertinent news chunks via the EMM RAG service. - Uses multiple LLMs from the [GPT@JRC](https://gpt.jrc.ec.europa.eu/) portfolio to: - Extract critical impact data (e.g., fatalities, affected populations). - Transform unstructured news into coherent, structured storylines. - Build causal knowledge graphs — *impact chains* — highlighting drivers, impacts, and interactions.

**Explore Events**: Use the selectors below to explore events by **Disaster Type**, **Country**, and **Disaster Number (DisNo)**.
Once an event is selected, the app will display the **causal impact-chain graph**, illustrating key factors and their interrelationships.
Below the graph, you'll find the **AI-generated narrative**, presenting a structured storyline of the event based on relevant news coverage.

**Outcome**: These outputs offer a deeper understanding of disaster dynamics, supporting practitioners, disaster managers, and policy-makers in identifying patterns, assessing risks, and enhancing preparedness and response strategies. """ ) # Create dropdowns for Disaster Type, Country, and Disaster Event # disaster_type_dropdown = gr.Dropdown( choices=[''] + df['Disaster Type'].unique().tolist(), label="Select Disaster Type" ) country_dropdown = gr.Dropdown( choices=[''], # Initially empty; will be populated based on disaster type label="Select Country" ) row_dropdown = gr.Dropdown( choices=[], label="Select Disaster Event #", interactive=True ) with gr.Column(): disaster_type_dropdown country_dropdown row_dropdown gr.Markdown("### AI-Generated Storyline:") # Title outputs = [ gr.Textbox(label="Storyline", interactive=False, lines=10), gr.HTML(label="Causal Graph") # Change from gr.Plot to gr.HTML ] # Inputs for evaluation metrics, placed after the graph with gr.Row(): tpn_input = gr.Number(label="Num of Correct Nodes (TPN)", value=0, interactive=True) tpl_input = gr.Number(label="Num of Correct Links (TPL)", value=0, interactive=True) fp_node_input = gr.Number(label="False Positive Nodes (FPN)", value=0, interactive=True) fp_link_input = gr.Number(label="False Positive Links (FPL)", value=0, interactive=True) fn_node_input = gr.Number(label="False Negative Nodes (FNN)", value=0, interactive=True) fn_link_input = gr.Number(label="False Negative Links (FNL)", value=0, interactive=True) # Button to save the data save_button = gr.Button("Save Data") # Update country choices based on selected disaster type disaster_type_dropdown.change( fn=lambda disaster_type: gr.update( choices=[''] + df[df['Disaster Type'] == disaster_type]['Country'].unique().tolist(), value='' ), inputs=disaster_type_dropdown, outputs=country_dropdown ) # Update DisNo. choices based on selected disaster type and country country_dropdown.change( fn=update_row_dropdown, inputs=[disaster_type_dropdown, country_dropdown], outputs=row_dropdown ) # Display information based on selected DisNo. row_dropdown.change( fn=display_info, inputs=[row_dropdown, country_dropdown], outputs=outputs ) # Handle saving data on button click save_button.click( fn=save_data, inputs=[row_dropdown, tpn_input, tpl_input, fp_node_input, fp_link_input, fn_node_input, fn_link_input], outputs=[] ) return interface app = build_interface() app.launch()