Spaces:
Running
on
Zero
Running
on
Zero
| import gradio as gr | |
| import json | |
| import requests | |
| import os | |
| import pandas as pd | |
| import folium | |
| from folium.plugins import MeasureControl, Fullscreen, MarkerCluster | |
| from geopy.geocoders import Nominatim | |
| from geopy.exc import GeocoderTimedOut, GeocoderServiceError | |
| import time | |
| import random | |
| from typing import List, Tuple, Optional | |
| import io | |
| import tempfile | |
| import warnings | |
| warnings.filterwarnings("ignore") | |
| # Map Tile Providers with reliable sources | |
| MAP_TILES = { | |
| "GreenMap": { | |
| "url": "https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}", | |
| "attr": "Esri" | |
| } | |
| } | |
| # NuExtract API configuration | |
| API_URL = "https://api-inference.huggingface.co/models/numind/NuExtract-1.5" | |
| headers = {"Authorization": f"Bearer {os.environ.get('HF_TOKEN', '')}"} | |
| class SafeGeocoder: | |
| def __init__(self): | |
| user_agent = f"location_mapper_v1_{random.randint(1000, 9999)}" | |
| self.geolocator = Nominatim(user_agent=user_agent, timeout=10) | |
| self.cache = {} | |
| self.last_request = 0 | |
| def _respect_rate_limit(self): | |
| current_time = time.time() | |
| elapsed = current_time - self.last_request | |
| if elapsed < 1.0: | |
| time.sleep(1.0 - elapsed) | |
| self.last_request = time.time() | |
| def get_coords(self, location: str): | |
| if not location or pd.isna(location): | |
| return None | |
| location = str(location).strip() | |
| if location in self.cache: | |
| return self.cache[location] | |
| try: | |
| self._respect_rate_limit() | |
| result = self.geolocator.geocode(location) | |
| if result: | |
| coords = (result.latitude, result.longitude) | |
| self.cache[location] = coords | |
| return coords | |
| self.cache[location] = None | |
| return None | |
| except Exception as e: | |
| print(f"Geocoding error for '{location}': {e}") | |
| self.cache[location] = None | |
| return None | |
| def extract_info(template, text): | |
| try: | |
| prompt = f"<|input|>\n### Template:\n{template}\n### Text:\n{text}\n\n<|output|>" | |
| payload = { | |
| "inputs": prompt, | |
| "parameters": { | |
| "max_new_tokens": 1000, | |
| "do_sample": False | |
| } | |
| } | |
| response = requests.post(API_URL, headers=headers, json=payload) | |
| if response.status_code == 503: | |
| response_json = response.json() | |
| if "error" in response_json and "loading" in response_json["error"]: | |
| estimated_time = response_json.get("estimated_time", "unknown") | |
| return f"⏳ Model is loading (ETA: {int(float(estimated_time)) if isinstance(estimated_time, (int, float, str)) else 'unknown'} seconds)", "Please try again in a few minutes" | |
| if response.status_code != 200: | |
| return f"❌ API Error: {response.status_code}", response.text | |
| result = response.json() | |
| if isinstance(result, list) and len(result) > 0: | |
| result_text = result[0].get("generated_text", "") | |
| else: | |
| result_text = str(result) | |
| if "<|output|>" in result_text: | |
| json_text = result_text.split("<|output|>")[1].strip() | |
| else: | |
| json_text = result_text | |
| try: | |
| extracted = json.loads(json_text) | |
| formatted = json.dumps(extracted, indent=2) | |
| except json.JSONDecodeError: | |
| return "❌ JSON parsing error", json_text | |
| return "✅ Success", formatted | |
| except Exception as e: | |
| return f"❌ Error: {str(e)}", "{}" | |
| def create_map(df, location_col): | |
| m = folium.Map( | |
| location=[20, 0], | |
| zoom_start=2, | |
| control_scale=True | |
| ) | |
| folium.TileLayer( | |
| tiles=MAP_TILES["GreenMap"]["url"], | |
| attr=MAP_TILES["GreenMap"]["attr"], | |
| name="GreenMap", | |
| overlay=False, | |
| control=False | |
| ).add_to(m) | |
| Fullscreen().add_to(m) | |
| MeasureControl(position='topright', primary_length_unit='kilometers').add_to(m) | |
| geocoder = SafeGeocoder() | |
| coords = [] | |
| marker_cluster = MarkerCluster(name="Locations").add_to(m) | |
| processed_count = 0 | |
| for idx, row in df.iterrows(): | |
| if pd.isna(row[location_col]): | |
| continue | |
| location = str(row[location_col]).strip() | |
| additional_info = "" | |
| for col in df.columns: | |
| if col != location_col and not pd.isna(row[col]): | |
| additional_info += f"<br><b>{col}:</b> {row[col]}" | |
| try: | |
| locations = [loc.strip() for loc in location.split(',') if loc.strip()] | |
| if not locations: | |
| locations = [location] | |
| except: | |
| locations = [location] | |
| for loc in locations: | |
| point = geocoder.get_coords(loc) | |
| if point: | |
| popup_content = f""" | |
| <div style="min-width: 200px; max-width: 300px"> | |
| <h4 style="font-family: 'Source Sans Pro', sans-serif; margin-bottom: 5px;">{loc}</h4> | |
| <div style="font-family: 'Source Sans Pro', sans-serif; font-size: 14px;"> | |
| {additional_info} | |
| </div> | |
| </div> | |
| """ | |
| folium.Marker( | |
| location=point, | |
| popup=folium.Popup(popup_content, max_width=300), | |
| tooltip=loc, | |
| icon=folium.Icon(color="blue", icon="info-sign") | |
| ).add_to(marker_cluster) | |
| coords.append(point) | |
| processed_count += 1 | |
| if coords: | |
| m.fit_bounds(coords) | |
| custom_css = """ | |
| <style> | |
| @import url('https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@400;600&display=swap'); | |
| .leaflet-container { | |
| font-family: 'Source Sans Pro', sans-serif; | |
| } | |
| .leaflet-popup-content { | |
| font-family: 'Source Sans Pro', sans-serif; | |
| } | |
| .leaflet-popup-content h4 { | |
| font-weight: 600; | |
| margin-bottom: 8px; | |
| } | |
| </style> | |
| """ | |
| m.get_root().header.add_child(folium.Element(custom_css)) | |
| return m._repr_html_(), processed_count | |
| def process_excel(file, places_column): | |
| if file is None: | |
| return None, "No file uploaded", None | |
| try: | |
| if hasattr(file, 'name'): | |
| df = pd.read_excel(file.name) | |
| elif isinstance(file, bytes): | |
| df = pd.read_excel(io.BytesIO(file)) | |
| else: | |
| df = pd.read_excel(file) | |
| print(f"Spalten in der Excel-Tabelle: {list(df.columns)}") | |
| if places_column not in df.columns: | |
| return None, f"Column '{places_column}' not found in the Excel file. Available columns: {', '.join(df.columns)}", None | |
| map_html, processed_count = create_map(df, places_column) | |
| with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp: | |
| processed_path = tmp.name | |
| df.to_excel(processed_path, index=False) | |
| total_locations = df[places_column].count() | |
| success_rate = (processed_count / total_locations * 100) if total_locations > 0 else 0 | |
| stats = f"Found {processed_count} of {total_locations} locations ({success_rate:.1f}%)" | |
| return map_html, stats, processed_path | |
| except Exception as e: | |
| import traceback | |
| trace = traceback.format_exc() | |
| print(f"Error processing file: {e}\n{trace}") | |
| return None, f"Error processing file: {str(e)}", None | |
| custom_css = """ | |
| <style> | |
| @import url('https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@300;400;600;700&display=swap'); | |
| body, .gradio-container { | |
| font-family: 'Source Sans Pro', sans-serif !important; | |
| color: #333333; | |
| } | |
| h1 { | |
| font-weight: 700 !important; | |
| color: #2c6bb3 !important; | |
| font-size: 2.5rem !important; | |
| margin-bottom: 1rem !important; | |
| } | |
| h2 { | |
| font-weight: 600 !important; | |
| color: #4e8fd1 !important; | |
| font-size: 1.5rem !important; | |
| margin-top: 1rem !important; | |
| margin-bottom: 0.75rem !important; | |
| } | |
| .gradio-button.primary { | |
| background-color: #ff7518 !important; | |
| } | |
| .info-box { | |
| background-color: #e8f4fd; | |
| border-left: 4px solid #2c6bb3; | |
| padding: 15px; | |
| margin: 15px 0; | |
| border-radius: 4px; | |
| } | |
| .file-upload-box { | |
| border: 2px dashed #e0e0e0; | |
| border-radius: 8px; | |
| padding: 20px; | |
| text-align: center; | |
| transition: all 0.3s ease; | |
| } | |
| /* Fix for map container spacing */ | |
| #map-container { | |
| height: 35vh !important; | |
| margin-bottom: 0 !important; | |
| padding-bottom: 0 !important; | |
| } | |
| /* Stats box styling */ | |
| .stats-box { | |
| margin-top: 10px !important; | |
| margin-bottom: 0 !important; | |
| padding: 10px; | |
| background: #f8f9fa; | |
| border-radius: 4px; | |
| } | |
| /* Remove extra space around components */ | |
| .gr-box { | |
| margin-bottom: 0 !important; | |
| } | |
| </style> | |
| """ | |
| with gr.Blocks(css=custom_css, title="Daten Strukturieren und Analysieren") as demo: | |
| gr.HTML(""" | |
| <div style="text-align: center; margin-bottom: 1rem"> | |
| <h1>Daten Strukturieren und Analysieren</h1> | |
| <p style="font-size: 1.1rem; margin-top: -10px;">Dies ist eine Demoversion für die Extrahierung und Visualisierung von Daten</p> | |
| </div> | |
| <p style="font-size: 1.1rem; margin-top: -10px;">In dieser Unterrichtseinheit befassen wir uns mit einer innovativen Methode zur Strukturierung unstrukturierter historischer Texte. Im Kern verbindet unsere Anwendung die systematische Strukturierung von Daten mit einem spezialisierten Sprachmodell, das auf der Question-Answering-Methode basiert. | |
| Methodik: Vom unstrukturierten Text zur strukturierten Information | |
| Die grundlegende Herausforderung bei der Arbeit mit historischen Quellen ist, dass relevante Informationen in langen Fließtexten eingebettet sind und manuell mühsam extrahiert werden müssen. Unser Ansatz automatisiert diesen Prozess. | |
| Wie funktioniert die Informationsextraktion? | |
| Template-Definition: Sie definieren ein JSON-Template mit den Informationstypen, die Sie extrahieren möchten: | |
| json{"earthquake location": "", "dateline location": ""} | |
| Question-Answering-Methode: Das Sprachmodell interpretiert jedes leere Feld als implizite Frage: | |
| "earthquake location": "" → "Wo ist das Erdbeben passiert?" | |
| "dateline location": "" → "Von wo wird berichtet?" | |
| Sprachmodell-Verarbeitung: Das NuExtract-1.5 Modell (ein Sequence-to-Sequence Transformer) analysiert den Text vollständig und identifiziert die relevanten Informationen für jedes Template-Feld. | |
| Strukturierte Ausgabe: Das Modell füllt das Template mit den extrahierten Informationen: | |
| json{"earthquake location": "Japan, Yokohama", "dateline location": "Tokio"} | |
| Technische Funktionsweise des Sprachmodells | |
| Das Modell verarbeitet den Input in diesem Format: | |
| <|input|> | |
| ### Template: | |
| {"earthquake location": "", "dateline location": ""} | |
| ### Text: | |
| Neues Erdbeben in Japan. Aus Tokio wird berichtet, daß in Yokohama bei einem Erdbeben sechs Personen getötet... | |
| <|output|> | |
| Intern erfolgt die Verarbeitung in mehreren Schritten: | |
| Tokenisierung: Der Text wird in bearbeitbare Einheiten zerlegt. | |
| Kontextuelle Analyse: Der Transformer-Mechanismus ermöglicht die Analyse von Beziehungen zwischen allen Textteilen gleichzeitig. | |
| Selektive Aufmerksamkeit: Das Modell fokussiert sich auf Textpassagen, die Antworten auf die impliziten Fragen enthalten könnten. | |
| Generierung: Die erkannten Informationen werden in das vorgegebene Template eingefügt. | |
| Im Gegensatz zu regelbasierten Systemen oder klassischen Named Entity Recognition-Ansätzen versteht dieses Modell den semantischen Zusammenhang und kann flexibel auf verschiedene Extraktionsaufgaben angepasst werden.</p> | |
| """) | |
| with gr.Tabs() as tabs: | |
| with gr.TabItem("🔍 Text Extrahierung"): | |
| gr.HTML(""" | |
| <div class="info-box"> | |
| <h3 style="margin-top: 0;">Extrahieren Sie strukturierte Daten aus unstrukturiertem Text</h3> | |
| <p>Verwenden Sie das Sprachmodell NuExtract-1.5 um automatisch Informationen zu extrahieren.</p> | |
| </div> | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| template = gr.Textbox( | |
| label="JSON Template", | |
| value='{"earthquake location": "", "dateline location": ""}', | |
| lines=5 | |
| ) | |
| text = gr.Textbox( | |
| label="Hier unstrukturierten Text einfügen", | |
| value="Nene Erdbeben in Japan. London, 15. Jan. (Drahtber.) Reuter meldet aus Osaka: Die telephonische Verbindung zwischen Osaka und Tokio ist heute um 5.45 Uhr durch ein Erdbeben unterbrochen worden. Die Straßenbahnen in Tokio liegen still. Der Eisenbahnverkehr Tokio — Osaka ist unterbrochen. Die kaiserliche Familie ist in Sicherheit. In Suvamo, einer Borstadt Tokios, sind Brände ausgebrochen. Ein Eisenbahnzug stürzte in den Bajubawo, einem Fluß zwischen Gotemba und Tokio. Sechs Züge wurden umgeworfen. Nenqork, 15. Jan. (Drahtber.) Aus Tokio wird berichtet, daß in Uokohama bei dem Erdbeben sechs Personen getötet und 22 verletzt wurden. In Tokio wurden vier Personen getötet und 20 verletzt. In Nokohama wurden 800 Häuser zerstört.", | |
| lines=8 | |
| ) | |
| extract_btn = gr.Button("Extrahieren Sie Informationen", variant="primary") | |
| with gr.Column(): | |
| status = gr.Textbox(label="Status") | |
| output = gr.Textbox(label="Output", lines=10) | |
| extract_btn.click( | |
| fn=extract_info, | |
| inputs=[template, text], | |
| outputs=[status, output] | |
| ) | |
| with gr.TabItem("📍 Mapping von strukturierten Daten"): | |
| gr.HTML(""" | |
| <div class="info-box"> | |
| <h3 style="margin-top: 0;">Visualisieren Sie Daten auf Karten</h3> | |
| <p>Laden Sie eine Excel-Tabelle hoch und erstelle eine interaktive Karte.</p> | |
| </div> | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| excel_file = gr.File( | |
| label="Upload Excel File", | |
| file_types=[".xlsx", ".xls"], | |
| elem_classes="file-upload-box" | |
| ) | |
| places_column = gr.Textbox( | |
| label="Name der Tabellenspalte mit Ortsname", | |
| value="earthquake_location", | |
| placeholder="Füge den Namen der Spalte mit den Orten ein" | |
| ) | |
| process_btn = gr.Button("Erstellen Sie die Karte", variant="primary") | |
| with gr.Column(): | |
| map_output = gr.HTML( | |
| label="Interaktive Karte", | |
| value=""" | |
| <div style="text-align:center; height:35vh; width:100%; display:flex; align-items:center; justify-content:center; | |
| background-color:#f5f5f5; border:1px solid #e0e0e0; border-radius:8px;"> | |
| <div> | |
| <img src="https://cdn-icons-png.flaticon.com/512/854/854878.png" width="100"> | |
| <p style="margin-top:20px; color:#666;">Your map will appear here after processing</p> | |
| </div> | |
| </div> | |
| """, | |
| elem_id="map-container" | |
| ) | |
| stats_output = gr.Textbox( | |
| label="Status", | |
| lines=2, | |
| elem_classes="stats-box" | |
| ) | |
| processed_file = gr.File( | |
| label="Bearbeitete Daten herunterladen", | |
| visible=True, | |
| interactive=False | |
| ) | |
| def process_and_map(file, column): | |
| if file is None: | |
| return None, "Hier bitte die Excel-Tabelle hochladen", None | |
| try: | |
| map_html, stats, processed_path = process_excel(file, column) | |
| if map_html and processed_path: | |
| responsive_html = f""" | |
| <div style="width:100%; height:35vh; margin:0; padding:0; border:1px solid #e0e0e0; border-radius:8px; overflow:hidden;"> | |
| {map_html} | |
| </div> | |
| """ | |
| return responsive_html, stats, processed_path | |
| else: | |
| return None, stats, None | |
| except Exception as e: | |
| import traceback | |
| trace = traceback.format_exc() | |
| print(f"Error in process_and_map: {e}\n{trace}") | |
| return None, f"Error: {str(e)}", None | |
| process_btn.click( | |
| fn=process_and_map, | |
| inputs=[excel_file, places_column], | |
| outputs=[map_output, stats_output, processed_file] | |
| ) | |
| gr.HTML(""" | |
| <div style="text-align: center; margin-top: 2rem; padding-top: 1rem; border-top: 1px solid #eee; font-size: 0.9rem; color: #666;"> | |
| <p>Made with <span style="color: #e25555;">❤</span> for historical research</p> | |
| </div> | |
| """) | |
| if __name__ == "__main__": | |
| demo.launch() |