Data Cleaning | FDMLab@LABW

82. Südwestdeutscher Archivtag 2023

Thu, 22 Jun 2023 11:00:00 +0000

Entfernungen zu GPX Tracks mit OpenRefine ermitteln

Thu, 27 Oct 2022 00:00:00 +0000

In diesem Beitrag verarbeiten wir XML in Form von GPX-Dateien mit OpenRefine und berechnen via WebAPIs die Entfernung von unserem Standort zu dem Startpunkt der GPX-Tracks.

Aktuelle Wanderführer bieten die darin beschriebenen Wanderungen häufig zusätzlich als GPX-Datei zum Nachwandern als Download an. Auch Tourismusbüros/verbände/gemeinschaften/… bieten in Kooperation mit Diensten wie OutdoorActive lokale Wanderungen digital an. Planen wir einen Betriebsausflug, oder eine Wanderung, dann ist die Länge der Anfahrt zum jeweiligen Startpunkt durchaus ein wesentliches Entscheidungskriterium für oder gegen eine Wanderung. Anstatt manueller Einzelrecherchen testen wir in diesem Beitrag, wie sich mit OpenRefine die Entfernung und Fahrtdauer mit dem Auto bzw. dem öffentlichen Nahverkehr von unserem Standort zu den Startpunkten der einzelnen Wanderungen berechnen lässt.

Dabei kombinieren wir OpenRefine mit Geodaten im XML basierten GPX-Format und fragen mit den extrahierten Daten verschiedene WebAPIs an.

Unsere Testdaten

Als Testdaten verwenden wir die aktuell 21 Wanderungen aus dem Programm der hochgehberge. Diese lassen sich direkt von der Webseite als GPX-Datei einzeln herunterladen. Dafür muss nach Auswahl einer Tour etwas nach oben gescrollt werden. Wie in Abbildung 1 gezeigt, aktivieren wir zusätzlich die Checkbox bei “Verknüpfte Wegpunkte exportieren”. Das ermöglicht uns bei den Daten der “hochgehberge” nicht nur einen Abgleich mit dem Startpunkt der Wanderungen durchzuführen, sondern auch mit alternativen Parkplätzen, die sich als Einstieg zur Tour eignen.

Bildschirmfoto der Webseite hochgehberge.de mit GPX-Download.

Routing APIs

Wir verwenden für unseren Test die WebAPIs von Google Maps, HERE und OpenRouteService. Für all diese Dienste benötigen wir einen Account und müssen einen API Schlüssel erstellen, um mit OpenRefine eine Anfrage stellen zu können. Alle Dienste haben ein “freies” Kontingent, welches für unsere Anwendung vollkommen ausreichend ist. Im Falle von Google Maps ist jedoch eine Kreditkarte notwendig, um den Dienst aktivieren zu können.

Da das Warten auf die Bestätigungs-E-Mail manchmal mehrere Minuten dauert, lohnt es sich die Registrierung schon jetzt durchzuführen. Wie das funktioniert und wie bei den einzelnen Diensten API Schlüssel erstellt wird, ist in der jeweiligen Dokumentation deutlich besser und umfangreicher beschrieben, als wir es hier können.

Daten importieren und aufarbeiten

Daten in OpenRefine importieren

Bei vielen Dateien oder verschachtelten Strukturen mit Unterordnern empfiehlt es sich, diese in eine ZIP-Datei zu packen, was das Laden in OpenRefine vereinfacht. Wie in Abbildung 2 gezeigt, kann eine ZIP-Datei direkt als Datenquelle für ein neues Projekt ausgewählt werden.

Bildschirmfoto der Dateiauswahl für neue Projekte in OpenRefine.

Wie in Abbildung 3 gezeigt, werden die einzelnen Dateien vor dem Import aus den Unterordnern geladen, und können in einem separaten Dialog nach Dateityp gefiltert werden. Auch eine Filterung basierend auf Mustern im Dateinamen ist möglich.

Bildschirmfoto des Dialogs zum Filtern von Dateien in OpenRefine.

Im XML-Import-Dialog wählen wir anschließend das GPX-Wurzelelement aus und erhalten die in Abbildung 4 gezeigten Daten in OpenRefine angezeigt.

Bildschirmfoto der importierten GPX Dateien in OpenRefine.

Überflüssige Spalten entfernen

In Standard GPX-Tracks würden wir hier einfach den ersten Punkt des GPX-Tracks verwenden und den Rest verwerfen. Da wir in den GPS-Daten der “hochgehberge” aber pro Tour teilweise mehrere mögliche Parkplätze zum Starten als Wegpunkte hinterlegt haben, machen wir den Abgleich hier über die Wegpunkte und verwerfen die Track-Daten.

Wie in Abbildung 5 gezeigt, entfernen wir dafür überflüssige Spalten via “All" "Edit columns" "Re-order / remove columns…”.

Bildschirmfoto des Dialogs zum Löschen und Sortieren von Spalten in OpenRefine.

Die folgenden Spalten behalten wir vorläufig:

File => als Record Identifier, also Zuordnung von Startpunkten zu einzelnen Touren.
WPT lon, lat => Zur Routenplanung via API.
WPT Name + Type => zum Filtern von Startpunkten (Parkplätzen).
WPT DESC + Link => ggf. zur weiteren Recherche hilfreich.
Metadata Name + Link => Information über Wanderung.

Spalten umbenennen

Um auf die Werte einfacher zugreifen zu können, benennen wir die restlichen Spalten passend nach folgendem Schema um:

gpx - wpt - lon Lon
gpx - wpt - lat Lat
gpx - wpt - name Wegpunkt Name
gpx - wpt - type Wegpunkt Typ
gpx - wpt - desc Wegpunkt Beschreibung
gpx - wpt - link-href Wegpunkt Link
gpx -metadata - name Name
gpx - metadata - link - href Link

Spalten sortieren

Nachdem wir geprüft haben, dass die Spalte “Name” für jeden GPS-Track eindeutig ist (Text Facet oder Duplicates Facet), löschen wir die Spalte “File” und verschieben die Spalte “Name” ganz nach links. Dadurch wird der “Name” zum neuen Record Identifier der einzelnen Wanderungen. Ordnungsliebend verschieben wir die Spalte “Link” direkt daneben auf die zweite Position. Das geht in einem Bearbeitungsschritt über den Dialog zum Löschen und Umsortieren mehrerer Spalten via “All" "Edit columns" "Re-order / remove columns…”.

Überflüssige Zeilen entfernen

Wir haben in den Daten einige Leerzeilen, da wir die Spalten zu den einzelnen Trackpunkten gelöscht haben. Außerdem haben wir einige Wegpunkte, die wir ebenfalls noch löschen wollen, da wir uns auf die Parkplätze konzentrieren wollen.

Dies machen wir in vier Schritten:

Werte in Spalte “Name” nach unten auffüllen via “Name" "Edit cells" "Fill down”.
Werte in Spalte “Link” nach unten auffüllen via “Link" "Edit cells" "Fill down”.
Wie in Abbildung 6, ein Text Facet auf der Spalte “Wegpunkt Typ” erstellen, dort die Wegpunkte vom Typ “Parkplatz” auswählen, und die Auswahl invertieren.
Die überflüssigen Zeilen entfernen via “All" "Edit rows" "Remove matching rows”.

Bildschirmfoto des Text Facets zum Filtern von Wegpunkten in OpenRefine.

Nochmal überflüssige Spalten entfernen

Bei den Parkplätzen sind die Spalten “Wegpunkt Link” und “Wegpunkt Beschreibung” nicht mit hilfreichen Informationen versehen, so dass wir sie löschen können.

Auf Duplikate prüfen

Der Vollständigkeit halber prüfen wir mit dem “Duplicates Facet” oder dem “Text Facet” die Spalte “Wegpunkt” auf mögliche Duplikate und löschen diese. Dafür die entsprechenden Zeilen zum Beispiel mit Flaggen markieren, via “Flag Facet” filtern und anschließend löschen.

Records erstellen

Um wieder eine Record Struktur zu erstellen, bei der es zu jeder Tour mehrere mögliche Parkplätze als Startpunkte gibt, machen wir das “Fill down” auf den Spalten “Name” und “Link” aus dem vorherigen Schritt wieder rückgängig, indem wir analog dazu auf beiden Spalten “Name|Link" "Edit cells" "Blank down” verwenden.

Die fertig gefilterten Daten sind in Abbildung 7 zu sehen.

Bildschirmfoto der gefilterten Daten in OpenRefine.

Startkoordinaten suchen

Für einen Abgleich via WebAPI benötigen wir noch die Startkoordinaten. Der Einfachheit halber kopieren wir diese von Google Maps und fügen sie als neue Spalten “Start Lon” und “Start Lat” dem Projekt hinzu (wir starten von unserer Zentrale in der Eugenstraße 7 in Stuttgart). Um Geokoordinaten von Google Maps zu kopieren klicken wir mit dem rechten Maustaste auf den gesuchten Punkt oder den Marker auf der Karte. Wie in Abbildung 8 gezeigt, erscheint anschließend ein Kontextmenü, wo die Geokoordinaten mit einem Linksklick direkt in die Zwischenablage übernommen werden können. Der erste Wert stellt den Breitengrad (Latidude) dar, der zweite den Längengrad (Longitude).

Bildschirmfoto des Kontextmenüs in Google Maps zum Kopieren von Geokoordinaten.

Wegstrecke mit WebAPIs ermitteln

Nun haben wir alle Daten für unseren Datenabgleich zusammen. In Abbildung 9 sind diese noch einmal abgebildet, wobei wir zur Übersichtlichkeit die ersten beiden Spalten ausgeblendet haben. Im nächsten Schritt berechnen wir die Entfernung zwischen unserem Standort und den möglichen Startpunkten der einzelnen Wanderungen.

Bildschirmfoto des aufbereiteten Projektes in OpenRefine.

Um die Daten von einer WebAPI abzurufen, verwenden wir so genannte GET-Requests (siehe HTTP-Anfragemethoden auf Wikipedia). Das hat den Vorteil, dass wir die Daten direkt mit der OpenRefine Funktion des Hinzufügens neuer Spalten via URL abfragen können.

Bei der (prinzipiell) für diese Art von Anfragen empfohlene POST-Request Methode, müssten wir zusätzlich in OpenRefine mit Clojure oder Python programmieren, was wir aus Gründen der Komplexität für dieses Experiment vermeiden möchten.

Verwendung von HERE

Bei HERE handelt es sich um ein ehemaliges Berliner Startup, welches mehrfach verkauft wurde und inzwischen hauptsächlich aus dem Automotive Bereich bekannt ist.

Für die Verwendung der HERE Routing API benötigen wir einen Account und einen API Schlüssel. Die Benutzung der API ist in der Entwickler Dokumentation beschrieben.

Daten abrufen

In Abbildung 10 ist der Dialog zum Hinzufügen neuer Spalten via URLs gezeigt. Diesen können wir aufrufen via “Beliebige Spalte" "Edit columns" "Add column by fetching URLs…”.

Bildschirmfoto des Dialogs zum Abfragen der HERE Routing API mit OpenRefine.

Die neue Spalte nennen wir “HERE” und die URL bauen wir für jede Zeile dynamisch zusammen:

"https://router.hereapi.com/v8/routes?transportMode=car&origin="+row.cells["Start Lat"].value +","+row.cells["Start Lon"].value+"&destination="+row.cells["Lat"].value +","+row.cells["Lon"].value+"&return=summary&apikey={YOUR_API_KEY}"

Wir geben in dieser Anfrage an, dass wir die Route für ein Auto planen möchten und laden die Start- und Zielkoordinaten aus den entsprechenden OpenRefine Spalten. Hier ist der Platzhalter {YOUR_API_KEY} durch einen eigenen API Key zu ersetzen.

Bei HERE haben wir zusätzlich die Möglichkeit, lediglich die Zusammenfassung zurückgeben zu lassen und damit auf die expliziten Einzelschrittanweisungen für die Route zu verzichten.

Das Vorhandensein des API Schlüssels direkt in der URL ist aus Sicherheitsaspekten eher unschön, weshalb hierfür generell andere Methoden empfohlen werden (POST, Header, OAuth). Für unser kleines bzw. einmaliges Experiment ist dieses Vorgehen aus Gründen der Einfachheit vorzuziehen. Wir können die API Schlüssel nach dem Experiment direkt wieder deaktivieren bzw. löschen.

Daten aufbereiten

Die Antwort der HERE Routing API erfolgt im JSON Format. In OpenRefine ist das JSON nicht menschenlesbar formatiert, so dass wir es mit dem Online Service JSON formatter menschenlesbar formatieren.

{
 "routes": [
 {
 "id": "5dae984c-da74-4bf3-b126-a4b8f44f35f7",
 "sections": [
 {
 "id": "ff1eaf83-4cae-498e-b0f0-b2fe68227106",
 "type": "vehicle",
 "departure": {
 "time": "2022-10-24T11:10:38+02:00",
 "place": {
 "type": "place",
 "location": {
 "lat": 48.7789779,
 "lng": 9.1864948
 },
 "originalLocation": {
 "lat": 48.7792369,
 "lng": 9.186687
 }
 }
 },
 "arrival": {
 "time": "2022-10-24T12:17:31+02:00",
 "place": {
 "type": "place",
 "location": {
 "lat": 48.389022,
 "lng": 9.3690754
 },
 "originalLocation": {
 "lat": 48.388977,
 "lng": 9.369079
 }
 }
 },
 "summary": {
 "duration": 4013,
 "length": 62748,
 "baseDuration": 3617
 },
 "transport": {
 "mode": "car"
 }
 }
 ]
 }
 ]
}

Die für uns interessanten Daten sind im Bereich summary zu finden. Unter length finden wir die Entfernung in Metern und unter baseDuration die von der aktuellen Verkehrssituation unabhängige und daher optimistisch berechnete Fahrtdauer in Sekunden. Weitere Informationen zu unterschiedlichen Angaben zur Fahrdauer und wie sie angefragt werden können, sind in der Entwickler Dokumentation zu finden.

Das Routing via öffentlichem Nahverkehr befand sich zum Zeitpunkt der Durchführung dieses Experimentes im Beta Stadium und wurde daher nicht getestet.

Um aus dem JSON die für uns relevanten Daten in OpenRefine Spalten zu überführen, nutzen wir die Funktion “HERE" "Edit columns" "Add column based on this column…”.

Die erste neue Spalte nennen wir “HERE Entfernung” und verwenden den folgenden GREL Ausdruck zur Extraktion und Umwandlung der Entfernung in Kilometern:

(value.parseJson().routes[0].sections[0].summary.length/1000).round()

Die zweite neue Spalte nennen wir “HERE Dauer” und verwenden den folgenden GREL Ausdruck zur Extraktion und Umwandlung der Dauer in Minuten:

(value.parseJson().routes[0].sections[0].summary.baseDuration/60)

Verwendung von OpenRouteService

Bei OpenRouteService handelt es sich um einen OpenSource Geodatendienst, welcher auf Daten von OpenStreepMaps basiert. Die Anmeldung und die Verwendung ist sehr einfach gehalten. Entsprechend ist auch die API im Vergleich zu den hier verwendeten kommerziellen Diensten nicht ganz so umfangreich. Die Verwendung der API zur Berechnung von Routen ist in der Entwickler Dokumentation beschrieben.

Daten abrufen

Das Vorgehen zur Abfrage einer WebAPI via GET-Requests haben wir schon bei der Verwendung der HERE Routing API beschrieben.

Wir laden die Daten in eine neue Spalte namens “OpenRouteService”. Der GREL Code zum dynamischen Erstellen der URLs für die einzelnen Zeilen sieht wie folgt aus:

"https://api.openrouteservice.org/v2/directions/driving-car?start="+row.cells["Start Lon"].value +","+row.cells["Start Lat"].value+"&end="+row.cells["Lon"].value +","+row.cells["Lat"].value+"&api_key={YOUR_API_KEY}"

Daten aufbereiten

Die JSON Antwort von OpenRouteService besteht aus mehreren tausend Elementen im JSON Format, da wir hier zusätzlich die komplette Route mitgeschickt bekommen. Die für uns interessanten Daten finden wir wieder im Element summary. Die Entfernung ist wieder in Metern und die Dauer in Sekunden angeben.

{
 ...
 "summary": {
 "distance": 62204.3,
 "duration": 3993.7
 }
 ...
}

Um aus dem JSON die für uns relevanten Daten in OpenRefine Spalten zu überführen, nutzen wir die Funktion “OpenRouteService" "Edit columns" "Add column based on this column…”.

Die erste neue Spalte nennen wir “ORS Entfernung” und verwenden den folgenden GREL Ausdruck zur Extraktion und Umwandlung der Entfernung in Kilometern:

(value.parseJson().features[0].properties.summary.distance/1000).round()

Die zweite neue Spalte nennen wir “ORS Dauer” und verwenden den folgenden GREL Ausdruck zur Extraktion und Umwandlung der Dauer in Minuten:

(value.parseJson().features[0].properties.summary.duration/60).round()

Verwendung von Google Maps

Google hat bei den hier verwendeten Webdiensten das weitaus umfangreichste API Angebot. Der Account Setup ist hier jedoch im Vergleich auch etwas aufwendiger.

Wir verwenden die Directions API von Google Maps. Es gibt zwar auch eine neuere Routes API, die derzeit in einer Vorschau-Version zur Verfügung steht. Diese bietet jedoch zum Zeitpunkt dieses Experiments (noch?) keine GET-Requests oder Routing via ÖPNV an.

Daten abrufen

Über die Directions API von Google Maps lassen sich auch Routen mit dem öffentlichen Nahverkehr planen. Daher fokussieren wir uns bei diesem Dienst auf diese Funktionalität.

Da Ausflüge wie Wanderungen häufig an Sonntagen stattfinden, dort jedoch der öffentliche Nahverkehr anders getaktet ist als unter der Woche, geben wir bei dieser Abfrage zusätzlich unsere gewünschte Ankunftszeit an (Sonntag, 31. Oktober 2022 um 10:00 Uhr). Die Zeitangaben werden in “Sekunden seit dem 1. Januar 1970” angegeben. In OpenRefine berechnen wir das mit dem folgenden GREL Ausdruck:

"2022-10-31 10:00".toDate("yyyy-MM-dd HH:mm").datePart("time")/1000

Hier eingefügt in den GREL-Code zur dynamischen Erstellung von URLs für das Hinzufügen neuer Spalten via URLs für OpenRefine:

"https://maps.googleapis.com/maps/api/directions/json?origin="+row.cells["Start Lat"].value +","+row.cells["Start Lon"].value+"&destination="+row.cells["Lat"].value +","+row.cells["Lon"].value+"&mode=transit&arrival_time="+ "2022-10-31 10:00".toDate("yyyy-MM-dd HH:mm").datePart("time")/1000 +"&language=de&key={YOUR_API_KEY}"

Daten aufbereiten

Die JSON Antwort der Google Maps Direction API ist recht ausführlich, wenn denn eine funktionierende Strecke gefunden werden konnte. Hier ein kleiner Ausschnitt:

{
 ...
 "copyrights": "Map data ©2022 GeoBasis-DE/BKG (©2009)",
 "legs": [
 {
 "arrival_time": {
 "text": "10:22",
 "time_zone": "Europe/Berlin",
 "value": 1667208156
 },
 "departure_time": {
 "text": "09:06",
 "time_zone": "Europe/Berlin",
 "value": 1667203588
 },
 "distance": {
 "text": "48,2 km",
 "value": 48218
 },
 "duration": {
 "text": "1 Stunde, 16 Minuten",
 "value": 4568
 },
 "end_address": "Panorama Therme, 72660 Beuren, Deutschland",
 "end_location": {
 "lat": 48.5655941,
 "lng": 9.3967464
 },
 "start_address": "Eugenstraße 7, 70182 Stuttgart, Deutschland",
 "start_location": {
 "lat": 48.77899370000001,
 "lng": 9.1865211
 },
 "steps": ...
}

Interessant ist hier, dass wir die Werte für die Entfernung und Dauer sowohl als Text, als auch in Metern bzw. Sekunden erhalten. Wir extrahieren auch hier die Zahlenwerte, da diese einfacher in ein einheitliches Format umgewandelt werden können.

Die erste neue Spalte nennen wir “Google Entfernung (ÖPNV)” und verwenden den folgenden GREL Ausdruck zur Extraktion und Umwandlung der Entfernung in Kilometern:

(value.parseJson().routes[0].legs[0].distance.value/1000).round()

Die zweite neue Spalte nennen wir “Google Dauer (ÖPNV)” und verwenden den folgenden GREL Ausdruck zur Extraktion und Umwandlung der Dauer in Minuten:

(value.parseJson().routes[0].legs[0].duration.value/60).round()

Formate anpassen

Zur Verbesserung der Lesbarkeit, ergänzen wir die Entfernungsspalten um die Angabe “km”. Dafür nutzen wir “Spalte" "Edit cells" "Transform” und den folgenden GREL Ausdruck.

value+"km"

In den Spalten zur Dauer wandeln wir die Angaben von Minuten in Stunden und Minuten um.

with(value.toDate("mm"), d,
 with(d.datePart("h"), h,
 with(d.datePart("min"), min,
 if(h > 0,
 h + "h " + min + "min",
 min + "min"))))

Das Endergebnis ist in Abbildung 11 gezeigt.

Bildschirmfoto des fertigen Projektes in OpenRefine.

Fazit

Dieser Artikel ist überraschend lang geworden. Das liegt hauptsächlich daran, dass wir versuchen Hintergründe zu erklären, mit der Auswertung der Wegpunkte einen etwas komplizierteren Fall durchspielen und uns gleich drei unterschiedliche WebAPIs ansehen.

In einem vereinfachten Test mit einem anderen Datensatz unter der Verwendung des ersten Punktes der Wanderung als Zielpunkt und nur einer API, haben wir die Bearbeitung in etwa 10 Minuten abgeschlossen. Und zwar inklusive Export in eine Software für Tabellenkalkulation und anschließender visueller Formatierung für den Druck.

Generell waren wir überrascht, wie wenig aufwendig es ist, eine Menge von GPX-Dateien im XML-Format in OpenRefine einzulesen, die relevanten Geokoordinaten herauszufiltern und damit Anfragen an eine WebAPI zu stellen.

Bei den WebAPIs hat uns OpenRouteService in seiner Einfachheit gefallen. Der Funktionsumfang der API ist nicht so umfangreich, wie bei den kommerziellen Anbietern. Jedoch ist der initiale Aufwand für die Account Registrierung geringer, sowie die Erstellung eines API Schlüssels sehr übersichtlich gehalten.

Das Erstellen eines Accounts und API Schlüssels für die HERE Routing API war ebenfalls sehr direkt und die Arbeit mit der API machte uns sofort Spaß. Die HERE Routing API lädt dazu ein, noch viel mehr und umfangreicher mit ihr zu arbeiten.

Bei Google fühlten wir uns zuerst von der Menge der Dienste und möglichen Alternativen erschlagen. Die Google Maps Direction API ist dann auch sehr umfangreich, so dass wir im Vergleich mit den anderen APIs etwas länger brauchten, um genau unseren Use-Case damit abzubilden. Dafür konnten wir damit problemlos die Anfahrt mit dem Öffentlichen Personennahverkehr berechnen.

Auch wenn es sich bei den Daten für dieses Experiment nicht um “klassische” Archivdaten handelt, so hilft uns das Experiment besser zu verstehen, wie OpenRefine uns dabei unterstützt Daten aus unterschiedlichen Quellen zusammenzuführen. Im Kontext der einfachen Installation von OpenRefine steigert die Anbindung von generischen WebAPIs ohne Programmierkenntnisse die Attraktivität von OpenRefine weiter.

Probleme mit Umlauten in OpenRefine

Tue, 19 Jul 2022 00:00:00 +0000

Bei der Verarbeitung deutschsprachiger Texte stoßen wir hin und wieder auf Probleme mit Umlauten und anderen Sonderzeichen. In diesem Artikel haben wir einige typischen Probleme und ihre Lösungen aufgelistet.

Umlaute in Metadaten sorgen für Speicherprobleme in OpenRefine 3.5

OpenRefine hat in der Version 3.5 ein Problem mit Umlauten und anderen Sonderzeichen in den Metadaten. Zu den Metadaten gehören zum Beispiel der Projektname, die Schlagworte, der Dateiname der importierten Datei, Templates für den Export, …

Diese fehlerhaft gespeicherten Sonderzeichen in den Metadaten verdoppeln sich bei jedem (Neu)Start von OpenRefine (siehe Grafiken 1 - 3).

Bildschirmfoto des Projektes nach dem Import.

Bildschirmfoto des Projektes nach dem ersten Neustart.

Bildschirmfoto des Projektes nach dem zweiten Neustart.

Da es sich hierbei um ein exponentielles Wachstum handelt, ist es möglich, dass wir nach einiger Zeit Metadaten in der Größe von mehreren Gigabyte produzieren. Dadurch kann OpenRefine irgendwann nicht mehr starten und meldet beim Start: HTTP ERROR 500 java.lang.OutOfMemoryError: Java heap space. Der Reflex die Größe des Heaps (max memory heap size) in der openrefine.l4j.ini anzupassen hilft zwar erst einmal, jedoch werden die Metadaten weiterhin schneller wachsen, als man Arbeitsspeicher nachkaufen kann.

Um das Problem vorübergehend zu mitigieren, benötigen wir zuerst eine Liste der betroffenen OpenRefine Projekte. Dafür ermitteln wir, wo die OpenRefine Projekte gespeichert sind.

In diesem Verzeichnis identifizieren wir ungewöhnlich große metadata.json Dateien. Dabei ist ungewöhnlich groß abhängig von der Art der Projekte mit denen wir arbeiten. Normalerweise sind metadata.json Dateien mit einer Größe, die in Megabyte oder größer gemessen wird, ein Grund sie genauer anzusehen.

Zur Identifikation der großen metadata.json Dateien können auch Werkzeuge verwendet werden. Für Windows gibt es unter anderem TreeSize und WinDirStat.

Die betroffenen Projektordner können dann (temporär) aus dem OpenRefine Projektordner herausgenommen und ihre ID aus der Datei workspace.json entfernt werden.

Um die metadata.json Dateien zu korrigieren, kann eine Kombination der Kommandozeilenwerkzeuge find und jq verwendet werden, wie es auf GitHub unter Out of memory errors from large metadata.json files being parsed during OpenRefine Project Open beschrieben wird.

Alternativ können die metadata.json Dateien auch manuell korrigiert werden. Dafür werden diese mit einem Texteditor geöffnet, der in der Lage ist diese großen Dateien darzustellen. Unter Windows kann dafür der Standard Texteditor (NotePad) verwendet werden.

Erfahrungsgemäß ist es dabei einfacher, die nicht betroffenen Teile der JSON-Datei in eine neue Datei zu kopieren, anstatt zu versuchen Megabytes an Sonderzeichen zu löschen.

Der Fehler wird mit OpenRefine 3.6 gefixt, jedoch werden die schon vermehrten Umlaute nicht automatisiert aufgeräumt. Generell ist es zu empfehlen, dass betroffene Benutzer möglichst früh zur Version 3.6 von OpenRefine wechseln.

Daten richtig in OpenRefine laden

OpenRefine ist prinzipiell schon recht gut darin die richtige Kodierung beim Import der Daten für ein Projekt zu erkennen. In Abbildung 4 wurde hier schon korrekt die Kodierung “UTF-8” erkannt. Es ist prinzipiell trotzdem zu empfehlen in der Vorschau der Daten zu prüfen, ob Umlaute und Sonderzeichen auch richtig angezeigt werden.

Bildschirmfoto der Optionen für den Projektimport.

Gegebenenfalls muss das Encoding noch angepasst werden. Dafür auf das Encoding-Feld klicken. In Abbildung 4 ist es das Feld mit Text “UTF-8”. Daraufhin öffnet sich ein Dialog mit einer Schnellauswahl von üblichen Kodierungen (Abbildung 5) und einen Tab “All Encodings”, mit einer ausführlichen Liste aller unterstützten Kodierungen (Abbildung 6).

So kann das Encoding der Datei noch vor dem Projektimport manuell angepasst werden.

Bildschirmfoto der Optionen für das Encoding.

Bildschirmfoto der erweiterten Optionen für das Encoding.

Nachgeladene Daten anpassen

Wir laden häufig auch Daten aus externen Quellen in ein existierendes Projekt. Hierbei kann es vorkommen, dass die Kodierung der eingehenden Daten nicht zu den Daten im Projekt passt.

Dafür gibt es die Möglichkeit die Daten mit der GREL Funktion reinterpret() anzupassen.

Die Kodierung des OpenRefine Projektes findet man in den Metadaten unter import option metadata (JSON). Die Kodierung der eingehenden Daten ist abhängig vom Projekt bzw. der API von der die Daten abgeholt werden.

Reguläre Ausdrücke mit Umlauten

Dem Thema Umlaute bei regulären Ausdrücken in OpenRefine haben wir eine eigene Aufgabe in unserem OpenRefine Workshop für Fortgeschrittene gewidmet.

Hier die Kurzzusammenfassung: OpenRefine verwendet Java zur Auswertung der regulären Ausdrücke, wobei die Unicode Unterstützung separat aktiviert werden muss. Das hat zur Folge, dass “Sonderzeichen” wie unsere Umlaute äöü, oder die in der französischen Sprache gebräuchlichen Buchstaben mit Akzenten éêè, nicht von den Mustern [a-z] oder \w berücksichtigt werden.

Um zum Beispiel auch Umlaute zu berücksichtigen gibt es mehrere Möglichkeiten:

Umlaute explizit auflisten: [a-zäöüß]
Spezielle Klasse für Buchstaben (letter) verwenden: \p{L}
Spezielle Klasse für alphabetische Zeichen verwenden: \p{IsAlphabetic}
Unicode Modus mit inline Flag aktivieren: (?U)\w

Probleme mit Textfilter und Umlauten

Manchmal haben wir in UTF-8 kodierten Projekten das Problem, dass Umlaute zwar korrekt dargestellt, Begriffe mit Umlauten z.B. über die Textfilter jedoch nicht gefunden werden.

Das kann daran liegen, dass Umlaute in UTF-8 sowohl als einzelnes Zeichen wie ä kodiert sein können, als auch als kombiniertes Zeichen aus a und " dargestellt werden können. ¹ Suchen wir dann zum Beispiel nach Gemälde, so wird der als Gema"lde kodierte Begriff nicht gefunden.

Um zu prüfen, ob das in einem OpenRefine Projekt der Fall ist, gibt es mehrere Möglichkeiten:

Einen Begriff mit Umlauten aus dem OpenRefine Projekt in einer separaten Datei speichern und mit einem Hex-Editor analysieren.
Mit einem Custom Text Facet und dem GREL Ausdruck value.unicode() prüfen, ob es kombinierte Zeichen wie das UTF-Zeichen 771 für den ergänzenden " gibt.
In einem Textfilter reguläre Ausdrücke aktivieren und die Sonderzeichen im Suchbegriff durch einen bzw. zwei Punkte .. (universeller Platzhalter) ersetzen. Also nach Gem.lde und nach Gem..lde suchen. Gibt es Ergebnisse mit Umlauten bei einem Punkt, dann sind die Umlaute mit einem Zeichen kodiert, gibt es Ergebnisse mit Umlauten nur bei zwei Punkten, sind sie als getrennte Zeichen kodiert.

GREL bietet zwar die Möglichkeit mit reinterpret den Text in eine andere Kodierung umzuwandeln, jedoch nicht die interne Kodierung von UTF-8 anzupassen.

Dafür benötigen wir entweder die Normalizer Standardfunktionalität von Java via Clojure, oder die Standardbibliothek unicodedata von Python via Jython.

Hier ist der entsprechende Ausdruck in Clojure:

(java.text.Normalizer/normalize value java.text.Normalizer$Form/NFC)

Hier der entsprechende Ausdruck in Python/Jython:

from unicodedata import normalize
return normalize("NFC", value)

Diese Schnippsel können z.B. via “All" "Transform” auf ausgewählte oder alle Spalten im OpenRefine Projekt angewendet werden.

Fazit

Die Unterstützung von Sonderzeichen und damit speziell Umlauten in der deutschen Sprache ist in OpenRefine nicht optimal. Das ist in den meisten Fällen technisch begründbar und es gibt Lösungen, jedoch ist es gerade für technische Laien problematisch das Problem so zu formulieren, dass die entsprechenden Lösungsansätze dafür gefunden werden.

Mit diesem Artikel hoffen wir, die Sichtbarkeit der möglichen Lösungen für Umlautprobleme in OpenRefine zu erhöhen.

Siehe dazu den Artikel zu Normalisierung von Unicode auf Wikipedia. ↩︎

Workshop - Arbeiten mit GREL

Sun, 01 May 2022 00:00:00 +0000

In diesem Tutorial beschäftigen wir uns mit der “General Refine Expression Language” (GREL).

Einführung

GREL in der OpenRefine Dokumentation.
GREL Rezepte im OpenRefine Wiki.

Dieser Workshop wurde erstellt mit OpenRefine Version 3.5.0.
Dieser Workshop wurde zuletzt getestet mit OpenRefine Version 3.9.3.

Mit der General Refine Expression Language (GREL) werden in OpenRefine die einzelnen Operationen auf den Daten ausgeführt. Die meisten Funktionen und Dialoge in OpenRefine sind quasi nur ein Eingabeformular für GREL Ausdrücke, die in den Facets angezeigten Daten basieren auf GREL Ausdrücken und in verschiedenen Dialogen können wir auch direkt GREL Ausdrücke verwenden, um zum Beispiel Daten zu transformieren.

Die Syntax von GREL ist dabei an die Programmiersprache JavaScript angelehnt, die unterliegende Technologie basiert jedoch auf der Programmiersprache Java. Dadurch entstehen Verständnisprobleme, wenn zum Beispiel reguläre Ausdrücke im Stil von JavaScript geschrieben werden, dann jedoch in OpenRefine intern von Java ausgewertet werden und entsprechend die Funktionalität von regulären Ausdrücken in Java unterstützen.

Die Eingabe von GREL Ausdrücken erfolgt (meistens) über Dialogfenster wie in Abbildung 1. Hier sehen wir nicht nur eine Vorschau der Umwandlung, die wir gerade anstreben, sondern können auch vorherige oder gespeicherte (Starred) GREL Ausdrücke laden.

Bildschirmfoto eines Dialog Fensters zur Transformation von Daten in OpenRefine.

Werte, Variablen, Objekte

In Programmiersprachen gibt es verschiedene Konzepte um mit Daten zu arbeiten.

Ein Konzept ist die Typisierung von Daten. So wird bei Werten zum Beispiel zwischen Text und Zahlen unterschieden. Mit diesen Werten können dann verschiedene Operationen und Berechnungen durchgeführt werden.

5 > 2
> true

Diesen Werten können via Variablen auch Namen zugewiesen werden.

laenge = 5
breite = 2
laenge > breite
> true

Oder es gibt spezielle Funktionen für Werte eines bestimmten Typs:

text = "Lorem ipsum"
length(text)
> 11

Werte und Funktionen lassen sich zu Objekten zusammenfassen. Via Variable kann ein bestimmtes Objekt gespeichert und darauf zugegriffen werden.

Rechteck(laenge, breite):
 laenge = leange
 breite = breite
 flaeche()
 return laenge * breite

rechteck1 = Rechteck(5, 2)
rechteck2 = Rechteck(4, 2)

rechteck1.flaeche > rechteck2.flaeche
> true

In GREL verwenden wir hauptsächlich schon existierende Variablen, Funktionen und Objekte.

Datentypen

In der OpenRefine Oberfläche arbeiten wir mit vier Datentypen: boolean, date, number und string. In GREL gibt es noch die Datentypen array, object und regex. Texte (string) können zusätzlich in eine Repräsentation für HTML, JSON oder XML geparsed werden. Das bedeutet vereinfacht, dass die (Text-)Daten intern von OpenRefine in eine Repräsentation überführt werden, die zum Beispiel XML versteht und dafür passende Funktionen anbietet. Also zum Beispiel die Funktion über alle XML-Knoten mit einem bestimmten Namen zu iterieren.

Typ	Kürzel	GUI	Beispiel(e)
array	a		`["a", "b", "c"]`
boolean	b	Ja	`true`, `false`
date	d	Ja	`[date 2022-05-03T15:00:00Z]`
number	n	Ja	`1`, `3.1415`
object	o		`[object Cell]`
regex	p		`/\d{4}/`
string	s	Ja	`Lorem ipsum...`

Variablen

Beim Arbeiten mit GREL stehen uns zusätzlich einige Umgebungsvariablen zur Verfügung.

Variable	Alternative	Beschreibung
cell	row.cells[columnName]	Aktuelle Zelle der ausgewählten Spalte.
cell.recon		Reconciliation Daten für die Zelle.
cell.recon. …		Dokumentation zu Recon.
cell.value	value	Wert der Zelle.
cell. ….		Dokumentation zu Cell.
columnName		Name der ausgewählten Spalte.
row		Aktuelle Zeile.
row.cells	cells	Zellen in der aktuellen Zeile.
row.cells. …		Dokumentation zu Cells
row.index	rowIndex	Index der aktuellen Zeile.
row.record		Record der aktuellen Zeile.
row.record. …		Dokumentation zu Record
row. ….		Dokumentation zu Row.
value1		Neu seit OpenRefine 3.9 für Distanz basiertes Clustering.
value2		Neu seit OpenRefine 3.9 für Distanz basiertes Clustering.

Die Variablen beinhalten teilweise einfache Werte (value, rowIndex) wie einen Text oder eine Zahl. Teilweise verweisen sie auf komplexe Objekte, worin die Werte gesammelt oder verschachtelt gespeichert sind (row). Manche Variablen stellen auch Abkürzungen dar. So kann auf den Wert der aktuellen Zeile in der ausgewählten Spalte direkt mit value zugegriffen werden, anstatt dies via row.cells[columnName].value machen zu müssen.

Hier eine Übersicht der Objekte und Variablen.

--- title: Datenstruktur config: look: handDrawn theme: neutral --- flowchart LR columnName row.index[index] row.cells[cells] row.columnNames[columnNames] row.starred[starred] row.flagged[flagged] row.record[record] row.cells.cell[cell...] row.cells.cell.value[value] row.cells.cell.recon[recon] row.cells.cell.recon.properties[...] row.cells.cell.errorMessage[errorMessage] row.cells.cell.errorMessage.value[value] row.record.index[index] row.record.cells[cells] row.record.fromRowIndex[fromRowIndex] row.record.toRowIndex[toRowIndex] row.record.rowCount[rowCount] row --> row.index & row.cells & row.columnNames & row.starred & row.flagged & row.record row.cells --> row.cells.cell row.cells.cell --> row.cells.cell.value & row.cells.cell.recon & row.cells.cell.errorMessage row.cells.cell.errorMessage --> row.cells.cell.errorMessage.value row.cells.cell.recon --> row.cells.cell.recon.properties row.record --> row.record.index & row.record.cells & row.record.fromRowIndex & row.record.toRowIndex & row.record.rowCount cell -.-> row.cells.cell cells -.-> row.cells rowIndex -.-> row.index value -.-> row.cells.cell.value

Fortsetzung für Reconciliation Daten einer Zelle:

--- title: Datenstruktur - recon config: look: handDrawn theme: neutral --- flowchart LR row.cells.cell.recon[row.cells.cell....recon] row.cells.cell.recon.judgment[judgment] row.cells.cell.recon.judgmentAction[judgmentAction] row.cells.cell.recon.judgmentHistory[judgmentHistory] row.cells.cell.recon.matched[matched] row.cells.cell.recon.match[match] row.cells.cell.recon.best[best] row.cells.cell.recon.features[features] row.cells.cell.recon.candidates[candidates] row.cells.cell.recon.features.typeMatch[typeMatch] row.cells.cell.recon.features.nameMatch[nameMatch] row.cells.cell.recon.features.nameLevenshtein[nameLevenshtein] row.cells.cell.recon.features.nameWordDistance[nameWordDistance] match.id[id] match.name[name] match.type[type] match.score[score] row.cells.cell.recon --> row.cells.cell.recon.judgment & row.cells.cell.recon.judgmentAction & row.cells.cell.recon.judgmentHistory & row.cells.cell.recon.matched & row.cells.cell.recon.match & row.cells.cell.recon.best & row.cells.cell.recon.features & row.cells.cell.recon.candidates row.cells.cell.recon.match --> match.id & match.name & match.type row.cells.cell.recon.best --> match.id & match.name & match.type & match.score row.cells.cell.recon.candidates --> match.id & match.name & match.type & match.score row.cells.cell.recon.features --> row.cells.cell.recon.features.typeMatch & row.cells.cell.recon.features.nameMatch & row.cells.cell.recon.features.nameLevenshtein & row.cells.cell.recon.features.nameWordDistance

Auf Attribute eines Objekts kann punktnotiert row.cells oder via Klammern row["cells"] zugegriffen werden. Prinzipiell empfiehlt es sich aus Gründen der Lesbarkeit die Punktnotation zu verwenden und die Variante mit Klammern nur, wenn der Name in einer Variablen steht cells[columnName] oder wir mit Spaltennamen arbeiten, die potentiell “Sonderzeichen” beinhalten können cells["GND-ID"].

Aktuell kann nicht auf alle Werte einer Spalte zugegriffen werden. Man kann aber auf alle Werte einer Spalte eines Records zugreifen: row.record.cells[columnName].

Kontrollstrukturen

Etwas verwirrend ist das Definieren von eigenen Variablen in GREL. Das geschieht mit einer with Anweisung. Im folgenden Beispiel setzen wir die Variable jahr auf den Wert 1988 und berechnen dann den Ausdruck jahr < 2000.

with(1988, jahr, jahr < 2000) == true

Wir geben das erwartete Ergebnis der GREL Ausdrücke in den Beispielen zusätzlich via == ... an, so dass das Ergebnis auch abgelesen werden kann, ohne den Ausdruck in OpenRefine oder im Kopf auswerten zu müssen.

Eine der essentiellen Kontrollstrukturen in der Informatik ist die Verzweigung. In GREL wird dies mit if realisiert. Im folgenden Beispiel setzen wir wie zuvor die Variable jahr auf den Wert 1988, geben aber abhängig von dem Ergebnis einer Prüfung unterschiedliche Werte zurück. Die if-Anweisungen können auch ineinander verschachtelt werden.

with(1988, jahr, if((jahr >= 1980).and(jahr < 1990), "80er", "Sonstiges")) == "80er"

Anstatt einer Verzweigung ist es manchmal auch nötig eine komplette Liste (technisch Array) von Werten zu filtern. Dafür gibt es in GREL eine filter() Funktion. Im folgenden Beispiel erstellen wir einen Array aus einem Text indem wir ihn mit split() am Trennzeichen , trennen. Anschließend wandeln die einzelnen Elemente mit toNumber() in Zahlen um und filtern anschließend nur die geraden Zahlen via mod(number, 2) == 2. Um das Ergebnis in OpenRefine ausgeben zu können, wandeln wir die Daten im Array anschließend mit join() wieder in einen Text um, da OpenRefine in der GUI keine Arrays anzeigen kann.

filter("1,2,3,4,5,6,7,8,9,10".split(","), v, mod(v.toNumber(), 2) == 0).join(",") == "2,4,6,8,10"

Um alle Werte einer Liste (technisch Array) durchzugehen, gibt es in GREL die forEach Anweisung. Im folgenden Beispiel erstellen wir mit split() einen Array aus einem Text und fügen mit + zu jedem Element die Endung “er” hinzu. Anschließend fügen wir die Daten im Array mit join() wieder zu einen Text zusammen.

forEach("70,80,90".split(","), v, v + "er").join(",") == "70er,80er,90er"

Zusätzlich gibt es noch weitere Helfer. Um den Typ eines Wertes zu prüfen gibt es verschiedene Varianten von is…, um einen bestimmten Bereich aufzuzählen forRange oder um eine Liste (technisch Array) aufzuzählen forEachIndex.

Extra: forNonBlank

Da sie etwas verwirrend ist, geben wir der Funktion forNonBlank hier noch einen separaten Absatz. Angenommen wir wollen eine Liste (technisch Array) von Werten durchgehen und dabei nur Werte bearbeiten, die einen Inhalt haben. Also zum Beispiel die ["1", "2", "", "4", "5"] umwandeln in 1,2,0,4,5.

forNonBlank(["1", "2", "", "4", "5"], v, v, 0).join(",") == "1,2,,4,5"

Das klappt so nicht, da forNonBlank(v, ...) eine andere Schreibweise für if(isNonBlank(v), ...) ist. Der korrekte Weg ist also einer der beiden folgenden Ausdrücke.

forEach(["1", "2", "", "4", "5"], v, if(isNonBlank(v), v, 0)).join(",") == "1,2,0,4,5"
forEach(["1", "2", "", "4", "5"], v, forNonBlank(v, v, v, 0)).join(",") == "1,2,0,4,5"

Standardbibliothek

Üblicherweise haben Programmiersprachen eine Standardbibliothek von Funktionen zum Arbeiten mit den zur Verfügung gestellten Datentypen.

Diese ist bei GREL im Vergleich zu anderen Programmiersprachen zwar recht übersichtlich, kann hier aber trotzdem nicht vollständig besprochen werden. Wir empfehlen daher, die Liste der in OpenRefine verfügbaren Funktionen als Referenz verfügbar zu halten.

Wir gehen hier auf ein paar Besonderheiten von GREL ein.

Syntax für Funktionsaufrufe

Eine Besonderheit in GREL ist, dass Funktionen zur besseren Lesbarkeit auch in Punktnotation aufgerufen werden können. Also length(value) auch geschrieben werden kann als value.length().

Aliase

Es gibt Funktionen, die unter mehreren Namen verfügbar sind.

Beispielsweise sind trim() und strip() bis auf ihre Namen identisch und wurden auch gleichzeitig in OpenRefine eingeführt. Vermutlich sollte das Quereinsteigern von anderen Programmiersprachen den Einstieg vereinfachen.

Vorbereitung: Projekt erstellen

Wir laden die folgende Datei in ein OpenRefine Projekt.

💾 Wir benötigen die folgende Datei (Rechtsklick und “Ziel speichern unter…”):

Kretschmann Kabinett III

Wie in Abbildung 2 beinhaltet die Datei das Kabinett Kretschmann III mit den Berufen.

Bildschirmfoto des Projektes direkt nach dem Laden.

Aufgabe 1: GREL Variablen nutzen

Das Geburtsdatum ist in drei Spalten aufgeteilt, wir wollen das Geburtsdatum jedoch in einer Spalte haben und dabei den Monat auch noch ausgeschrieben haben. Das haben wir in 03 Transformieren: Aufgabe 5 so ähnlich schon einmal mit Funktionen in der Benutzeroberfläche gelöst. Hier wollen wir GREL Funktionen verwenden, um die Bearbeitung in einem Schritt durchzuführen.

Dafür verwenden wir “Geburtsjahr" "Edit column" "Add column based on this column” und entwickeln schrittweise den in Abbildung 3 gezeigten GREL Ausdruck.

Bildschirmfoto des Dialogs zur Transformation.

Schritt 1: Geburtsmonat umwandeln

Um die Spalte “Geburtsmonat” in einen Namen umzuwandeln verwenden wir den Zugriff über row.cells["Geburtsjahr"] und die Funktionen toDate() und toString().

row.cells["Geburtsmonat"].value.toDate("M").toString("MMMM")

Schritt 2: Spalten zusammenfügen

Um die Spalten zusammenzufügen verwenden wir den Operator +.

row.cells["Geburtstag"].value + ". "
+ row.cells["Geburtsmonat"].value + " "
+ row.cells["Geburtsjahr"].value

Schritt 3: Verzweigung einbauen

Für manche Zeilen wird entweder eine Fehlermeldung oder null angezeigt. Das sind die Zeilen, wo kein Geburtstag und kein Geburtsmonat vorhanden sind.

Diese behandeln wir separat mit einer Verzweigung und passen dabei den Typ der Inhalte der Spalte “Geburtsjahr” an.

if(
 isBlank(row.cells["Geburtstag"]),
 row.cells["Geburtsjahr"].value.toString(),
 ...
)

Aufgabe 1

Fügen Sie die drei obigen GREL Ausdrücke zu einem GREL Ausdruck zusammen.

Lösung:

if(
 isBlank(row.cells["Geburtstag"]),
 row.cells["Geburtsjahr"].value.toString(),
 row.cells["Geburtstag"].value + ". "
 + row.cells["Geburtsmonat"].value.toDate("M").toString("MMMM") + " "
 + row.cells["Geburtsjahr"].value
)

Aufgabe 2: Werte aufräumen und sortieren

Die Werte in der Spalte “Beruf oder Beschäftigung” sind nicht sortiert, haben teilweise Duplikate und teilweise numerische Referenzen hinter den Berufsbezeichnungen. Diese Spalte wollen wir daher in einem Schritt mit einem GREL Ausdruck aufräumen und dabei die numerischen Referenzen entfernen, Duplikate entfernen und die Werte alphabetisch sortieren.

Dafür verwenden wir den Dialog “Beruf oder Beschäftigung" "Edit cells" "Transform” und erarbeiten uns einen GREL Ausdruck.

Schritt 1: Text in Liste umwandeln

Um die einzelnen Werte im Text in eine Liste (technisch Array) umzuwandeln, verwenden wir split() mit , als Trennzeichen.

"Politiker, Abgeordneter, Lehrer, Regierungschef, Politiker (5), Lehrer (3)".split(", ")

Schritt 2: Numerische Referenzen entfernen

Um die numerischen Referenzen zu entfernen verwenden wir replace() mit einem regulären Ausdruck und entfernen zusätzliche Leerzeichen.

"Politiker (5)".replace(/\(\d+\)/, "").trim()

Schritt 3: Funktion auf alle Elemente anwenden

Um die Ersetzung der numerischen Referenzen auf alle Elemente in der Liste (technisch Array) anzuwenden nutzen wir forEach.

forEach(
 ["Politiker, Abgeordneter, Lehrer, Regierungschef, Politiker (5), Lehrer (3)"],
 v,
 ...
)

Schritt 4: Werte vereinheitlichen und sortieren

Um die Werte zu vereinheitlichen und zu sortieren nutzen wir uniques() und sort().

["Politiker, Abgeordneter, Lehrer, Regierungschef, Politiker, Lehrer"].uniques().sort()

Schritt 5: Text aus Liste erstellen

Um aus der Liste (technisch Array) wieder einen Text zu erzeugen, verwenden wir join() mit , als Trennzeichen.

["Abgeordneter", "Lehrer", "Politiker", "Regierungschef"].join(", ")

Aufgabe 3

Fügen Sie die fünf obigen GREL Ausdrücke zu einem GREL Ausdruck zusammen. Das Ergebnis sollte in etwa wie in Abbildung 4 aussehen.

Bildschirmfoto des Projektes nach der Bearbeitung.

Lösung:

forEach(
 value.split(", "),
 v,
 v.replace(/\(\d+\)/, "").trim())
 .uniques()
 .sort()
 .join(", ")

Fazit

Viele Umwandlungen lassen sich in Einzelschritten über die graphische Oberfläche von OpenRefine ansteuern und umsetzen. So kommt man auch ohne in GREL zu programmieren in OpenRefine recht weit. Das Wissen um den Zugriff auf die Umgebungsvariablen und nützliche Funktionen wie find(), replace() oder Datumsumwandlungen ersetzt viele manuelle Schritte.

Das explizite Programmieren mit Verzweigungen und Schleifen ergänzt Arbeitsschritte oder reduziert mehrere Einzelschritte in der graphischen Oberfläche zu einem Schritt. Beim Export von XML in OpenRefine (Templating) sind die Kontrollstrukturen noch einmal relevant.

Im nächsten Teil behandeln wir das Konzept von “Records” in OpenRefine.

10 Arbeiten mit Records

Workshop - Arbeiten mit regulären Ausdrücken

Sun, 01 May 2022 00:00:00 +0000

Ein wichtiges Werkzeug beim Arbeiten mit Daten sind reguläre Ausdrücke. Diese werden in OpenRefine von verschiedenen Funktionen unterstützt.

Einführung

Reguläre Ausdrücke in der OpenRefine Dokumentation.

Dieser Workshop wurde erstellt mit OpenRefine Version 3.5.0.
Dieser Workshop wurde zuletzt getestet mit OpenRefine Version 3.9.3.

Mit regulären Ausdrücken können wir Muster definieren, mit denen wir bestimmte Zeichenfolgen in einem Text finden, extrahieren und/oder ersetzen können. Dies funktioniert nicht nur in Programmiersprachen wie Python oder Programmen wie OpenRefine, sondern auch in frei verfügbaren Text Editoren wie Notepad++ oder Visual Studio Code.

Perl Problems von Randall Munroe unter CC BY-NC Lizenz.

Bei Memes zu regulären Ausdrücken wird wie in Abbildung 1 häufig der Eindruck erweckt, dass sie mehr Probleme erzeugen als sie tatsächlich lösen. Richtig dosiert sind sie jedoch ein hilfreiches Werkzeug bei der Datenextraktion.

Das Vorgehen beim Entwickeln von regulären Ausdrücken unterscheidet sich von Person zu Person. Wir zeigen hier unser bevorzugtes Vorgehen, von dem gerne abgewichen werden darf.

Zum Entwickeln, Testen und Verstehen von regulären Ausdrücken, nutzen wir RegEx101 (Alternative: RegExr). Hier bekommen wir wie in Abbildung 2 visuelles Feedback, auf welche Textzeilen unsere regulären Ausdrücke passen und was die einzelnen Bestandteile bedeuten.

Bildschirmfoto von RegEx101 mit Art ECMAScript, einem regulären Ausdruck zur Extraktion von Datumsangaben in der Mitte oben, mehreren Beispielen direkt darunter und hilfreichen Informationen auf der rechten Seite.

Die Verwendung eines visuell unterstützenden Werkzeuges wie RegEx101 hat den Vorteil, dass wir einen übersichtlichen regulären Ausdruck entwickeln können, den wir dann in unsere Ursprungsanwendung, wie zum Beispiel OpenRefine, übertragen können. Ein Nachteil ist, dass zum Beispiel in OpenRefine nicht alle Features von regulären Ausdrücken unterstützt werden und der reguläre Ausdruck nachträglich ggf. angepasst werden muss.

Vorbereitung

Wir erstellen uns eine kleine Sammlung von Beispielen für Daten, die wir mit einem regulären Ausdruck bearbeiten wollen. Dazu ergänzen wir einige Negativbeispiele, also Beispiele, die von unserem regulären Ausdruck nicht extrahiert werden sollten.

Die Beispiele für dieses Tutorial sind im Folgenden gelistet und wir kopieren sie in das Testfenster von RegEx101.

2021-11-25 Einsteigerworkshop 1
2021-12-08 Einsteigerworkshop 2
2022-04-07 Einsteigerworkshop 3
2022-04-13 Einsteigerworkshop 4
2022-05-03 Fortgeschrittenenworkshop
1970-01-01
2005-1-1
- - - - - - - - - - - - - - - - - - -
Do not match!
1234-56-78
2022-13-01
2022-01-32
12-34-56
abcd-ef-gh

Wir werden bei den folgenden Aufgaben teilweise keine “perfekten” regulären Ausdrücke entwickeln, also teilweise Treffer in der Liste der Negativbeispiele haben!

Reguläre Ausdrücke werden von verschiedenen Programmiersprachen und Werkzeugen unterstützt. Dabei unterscheidet sich die Art, wie reguläre Ausdrücke als solche markiert werden. Außerdem werden je nach Programmiersprache, Version der Programmiersprache oder Werkzeug nicht alle Features von regulären Ausdrücken unterstützt.

In RegEx101 können wir daher ein so genanntes Flavor für die Eingabe der regulären Ausdrücke auswählen. Wir verwenden für unser Tutorial “ECMAScript (JavaScript)”. Das hat den Hintergrund, dass sich GREL an der Syntax für JavaScript orientiert, auch wenn es im Hintergrund Java zur Auswertung verwendet. Reguläre Ausdrücke werden hier durch zwei Schrägstriche /.../ markiert.

Hinter dem regulären Ausdruck gibt es optional noch Optionen. Wir verwenden für RegEx101 die Optionen g und m. Das sind die Standardoptionen, die bewirken, dass ein regulärer Ausdruck auf den kompletten Text (g für global) und auch Zeilen übergreifend (m für multiline) angewendet werden kann.

Wir haben sie in den Beispielen explizit gesetzt, damit sie beim Kopieren und Einfügen von regulären Ausdrücken hier aus dem Tutorial nicht ungewollt deaktiviert werden. In OpenRefine benötigen wir diese Optionen für unser Tutorial nicht.

Aufgabe 1: Zeichenauswahl (Character Classes)

Wir wollen die Datumsangaben extrahieren. Diese haben das Muster Jahreszahl-Monat-Tag bzw. ZahlZahlZahlZahl-ZahlZahl-ZahlZahl. Ein erster Ansatz ist es, dies direkt zu formulieren.

/(0|1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)-(0|1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)-(0|1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)/gm

Mit dem Pipe-Symbol | können wir in regulären Ausdrücken Alternativen formulieren. Also zum Beispiel 0|1. Mit den runden Klammern ( und ) können wir die Alternativen gruppieren.

Dies ist etwas umständlich und unleserlich. Daher gibt es in regulären Ausdrücken auch ein Muster zur Zeichenauswahl, welches die eckigen Klammern [ und ] verwendet. Mit den Character Classes lässt sich der obige Ausdruck vereinfachen zu:

/[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]/gm

Die Zeichenauswahl lässt sich kombinieren und limitieren. So lassen sich Zahlen im Hexadezimalsystem identifizieren mit [0-9A-F].

Aufgabe: Passen Sie den obigen regulären Ausdruck so an, dass das erste Zeichen der Jahreszahl des Datums nur eine 1 oder 2 sein darf.

Lösung:

/[1-2][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]/gm
/(1|2)[0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]/gm

Aufgabe 2: Zeichenklassen (Shape Matching)

Alternativ zu der recht flexiblen Zeichenauswahl gibt es vordefinierte Zeichenklassen, die es einfacher machen, die Form des Musters zu beschreiben.

Klasse	Steht für	Zeichenauswahl	Beschreibung
`\d`	digit	`[0-9]`	Beliebige Zahl
`\w`	word	`[a-zA-Z0-9_]`	Buchstaben in Groß- oder Kleinschreibung, Zahlen und Unterstrich.
`\s`	space		Leerraum: Leerzeichen, Tabulator, …
`\b`	boundary		Wortgrenze, erfasst kein separates Zeichen.

Mit der Klasse \d für Zahlen sieht der reguläre Ausdruck aus Aufgabe 1 wie folgt aus:

/\d\d\d\d-\d\d-\d\d/gm

Aufgabe: Passen Sie den obigen regulären Ausdruck so an, dass er (nur) auf das Datumsformat 2005-1-1 passt.

Lösung:

/\d\d\d\d-\d-\d/gm

Aufgabe 3: Verneinungen

Die Zeichenauswahl oder Zeichenklasse lässt sich auch negieren. Bei der Zeichenauswahl funktioniert das mit dem Sonderzeichen ^, bei den Zeichenklassen durch Großschreibung.

Negierte Zeichenauswahl für Zahlen: [^0-9]
Negierte Zeichenklasse für Zahlen: \D

Aufgabe: Negieren Sie die regulären Ausdrücke für das Datum aus Aufgabe 1 und Aufgabe 2.

Lösung:

/[^0-9][^0-9][^0-9][^0-9]-[^0-9][^0-9]-[^0-9][^0-9]/gm
/\D\D\D\D-\D\D-\D\D/gm

Aufgabe 4: Quantoren (Quantifiers)

Anstatt Zeichen, Zeichenauswahl oder Zeichenklassen wiederholt zu schreiben, lassen sich Wiederholungen auch durch Quantoren definieren.

Quantor	Alternative	Beschreibung
`{2,}`		Mindestens zweimal
`{1,2}`		Mindest einmal, höchstens zweimal
`?`	`{0,1}`	Kann vorkommen
`+`	`{1,}`	Kann sich wiederholen
`*`	`{0,}`	Kann vorkommen und sich wiederholen

Ein möglicher regulärer Ausdruck für unsere Daten wäre also:

/\d{4}-\d\d?-\d\d?/gm

Aufgabe: Schreiben Sie den obigen regulären Ausdruck so um, dass er den ? Quantor nicht mehr verwendet.

Lösung:

/\d{4}-\d{1,2}-\d{1,2}/gm

Aufgabe 5: Gruppierungen (Group Constructs)

Mit den runden Klammern ( und ) lassen sich Gruppen in regulären Ausdrücken definieren. Das ist nicht nur hilfreich, wenn man mit dem Pipe Symbol | Alternativen definieren möchte, sondern auch um einzelne Bestandteile zu markieren.

Setzen wir die einzelnen Bestandteile des regulären Ausdrucks in runde Klammern, dann zeigt uns RegEx101 wie in Abbildung 3 in Gruppe 1 die Jahreszahl, in Gruppe 2 den Monat und in Gruppe 3 den Tag. Auch bei der Verwendung von regulären Ausdrücken in OpenRefine können wir auf die einzelnen Gruppen zugreifen.

/(\d{4})-(\d{1,2})-(\d{1,2})/gm

Bildschirmfoto von RegEx101 mit den extrahierten Gruppen.

Die einzelnen Gruppen können auch benannt werden um dann wie in Abbildung 4 über den Gruppennamen aufgerufen werden.

/(?<Jahr>\d{4})-(?<Monat>\d{1,2})-(?<Tag>\d{1,2})/gm

Bildschirmfoto von RegEx101 mit den benannten Gruppen.

Aufgabe: Erstellen Sie einen regulären Ausdruck mit den zwei benannten Gruppen Datum und Event. Das erwartete Ergebnis ist in Abbildung 5 gezeigt.

Bildschirmfoto von RegEx101 mit den erwarteten Ergebnissen.

Lösung:

/(?<Datum>\d{4}-\d{1,2}-\d{1,2}) (?<Event>[a-zA-Z0-9 ]+)/gm
/(?<Datum>\d{4}-\d{1,2}-\d{1,2}) (?<Event>.+)/gm

In OpenRefine 3.5, 3.6 und 3.7 werden benannte Gruppierungen nicht überall unterstützt. Beispielsweise wird bei find() immer nur der vollständige Treffer zurückgegeben und bei match() die Gruppen ausschließlich durchnummeriert. Lediglich bei replace() lässt sich auf die benannten Gruppen zugreifen.

Der folgende GREL Ausdruck nutzt benannte Gruppen um mit replace() die Reihenfolge des Datums umzudrehen:

value.replace(/(?<Jahr>\d{4})-(?<Monat>\d{1,2})-(?<Tag>\d{1,2})/, "${Tag}-${Monat}-${Jahr}")

Aufgabe 6: Look-around (Look-ahead/Look-behind)

Manchmal möchte man die Daten weiter einschränken.

Hier ein einfaches Beispiel um nur Daten aus dem Jahr 2022 zu extrahieren:

/2022-\d{1,2}-\d{1,2}/gm

Aufwendiger wird es, wenn ein Datum nur extrahiert werden soll, wenn ein bestimmter Begriff dahinter steht. Dies funktioniert mit so genannten Look-around Anweisungen. Man kann via positive Look-ahead (?=...) definieren, dass ein Begriff nach einem Muster vorkommen soll und via positive Look-behind (?<=...) kann definiert werden, dass ein Begriff vor einem Muster vorkommen soll.

So findet der folgende reguläre Ausdruck alle Daten unserer Einsteigerworkshops, ohne den Begriff “Einsteigerworkshop” mit in das Ergebnis aufzunehmen:

/\d{4}-\d{1,2}-\d{1,2}(?= Einsteigerworkshop)/gm

Die Look-around Anweisungen lassen sich auch verneinen, indem man das Gleichheitszeichen = durch ein Ausrufezeichen ! austauscht. So findet der folgende reguläre Ausdruck mit einem negative Look-ahead (?!...) alle Daten von nicht Einsteigerworkshops:

/\d{4}-\d{1,2}-\d{1,2} (?!Einsteigerworkshop)/gm

Aufgabe: Extrahieren Sie die Titel aller drei Workshops im Jahr 2022. Nutzen Sie dazu eine positive Look-behind Anweisung (?<=...).

Hinweise:

Quantoren wie +, *, ?, {1,9} werden in Look-around Gruppen nicht überall unterstützt! Das kommt auf die benutzte Programmiersprache, deren Version und/oder verwendeten Zusatzbibliotheken an. Daher im Zweifel erst einmal testen!
Look-around Anweisungen verlangsamen die Auswertung eines regulären Ausdrucks deutlich und sollten daher mit Bedacht eingesetzt werden.

Lösung:

/(?<=2022-\d\d-\d\d )(?<Titel>[a-zA-Z0-9 ]+)/gm

Aufgabe 7: Datums Einschränkungen

Mit einer Kombination von Alternativen, Gruppierungen, Zeichenauswahl und Quantoren lässt sich auch ein regulärer Ausdruck entwickeln, der ausschließlich valide Datumsangaben zwischen 1900 und 2029 extrahiert.

/(?<Jahr>19\d\d|20[0-2]\d)-(?<Monat>0?\d|1[0-2])-(?<Tag>[0-2]?\d|3[0-1])(?=\s)/gm

Auch wenn er fachlich und technisch richtig ist, welche Probleme treten bei diesem regulären Ausdruck eventuell auf?

Hinweise:

Der reguläre Ausdruck ist sehr komplex und schwer zu verstehen.
Überflüssig da es ggf. gar keine invaliden Datumsangaben gibt?
Ggf. möchte man falsch geschriebene Daten explizit mit in die Ergebnisse aufnehmen und nachkorrigieren?
Ggf. Datumsangaben vor 1900 oder nach 2029 übersehen?
Unterscheidet nicht zwischen Monaten mit 28/30 und 31 Tagen.
…

Aufgabe 8: Spezielle Zeichen

Es gibt eine Liste mit speziellen Zeichen, die bei Vorkommen in einem regulären Ausdruck mit einem Backslash \ escaped werden müssen um sie zu deaktivieren.

Zeichen	Bedeutung
`.`	Wildcard, beliebiges Zeichen
`^`	Zeilenbeginn oder Verneinung
`$`	Zeilenende
`\`	Escapezeichen
`+`	Quantor
`*`	Quantor
`?`	Quantor
`{`, `}`	Quantor
`(`, `)`	Gruppe
`[`, `]`	Zeichenklasse

Der folgende reguläre Ausdruck passt zum Beispiel auf Zeilen, in denen nur ein Datum steht.

/^\d{4}-\d{1,2}-\d{1,2}$/gm

Aufgabe: Schreiben Sie einen regulären Ausdruck, der in dem folgenden Text ausschließlich Dezimalzahlen in englischer Schreibweise mit Punkt . als Trennzeichen extrahiert.

Der Literpreis für Diesel ist erstmals über 2.00 Euro gestiegen.

Siehe auch Code AFE2A00F.

Lösung:

/\d+\.\d+/gm

Aufgabe 9: Reguläre Ausdrücke in OpenRefine

In OpenRefine kann anstelle von Text auch häufig ein regulärer Ausdruck verwendet werden. Zum Beispiel beim Suchen via Textfilter, dem Aufteilen von Spalten oder dem Replace-Dialog. Eine Liste der GREL Funktionen mit Unterstützung von regulären Ausdrücken gibt es in der OpenRefine Dokumentation.

Für diese Aufgabe wechseln wir zu OpenRefine und laden die Datei 08_kurzbiographien.csv in das Projekt “Kurzbiographien”.

💾 Wir benötigen die folgende Datei (Rechtsklick und “Ziel speichern unter…”):

Kurzbiographien als CSV

Die Datei 08_kurzbiographien.csv verwendet Texte von verschiedenen und in der Datei referenzierten Wikipedia Artikeln, die unter einer CC BY-SA 3.0 Lizenz veröffentlicht wurden. Die Datei 08_kurzbiographien.csv ist entsprechend ebenfalls lizenziert unter einer CC BY-SA 3.0 Lizenz.

Die Datei enthält aus Wikipedia gesammelte Kurzbiographien einiger Autoren einer bestimmten Literaturströmung.

Aufgabe: Wir wollen aus den Kurzbiographien mit Hilfe von regulären Ausdrücken vier neue Spalten erstellen: Geburtsdatum, Geburtsort, Sterbedatum und Sterbeort.

Bonusfrage: zu welcher Literaturströmung gehören die Autoren?

Hinweise:

Um mit einem regulären Ausdruck nur einen Teil der Daten aus einer Spalte in eine neue zu überführen bietet sich der “Add column based on this column…” Dialog und die GREL Funktion find() an.
Der GREL Ausdruck value.find(/\d{4}/)[0] findet beispielsweise alle Jahreszahlen in Form einer Liste (technisch Array) zurück und wir extrahieren mit [0] das erste Element.
Reguläre Ausdrücke werden in OpenRefine Funktionen mit /.../ eingefasst.

Lösung:

Es gibt unterschiedliche Lösungswege, hier ist eine recht einfache Variante aufgezeigt. Hierbei verzichten wir auf komplexe reguläre Ausdrücke und formulieren verständliche Einzelschritte.

Neue Spalte “Geburtsdatum” erstellen via “Kurzbiographie” “Edit column” “Add column based on this column…” und dem GREL Ausdruck value.find(/\*[^;]+/)[0].
Wiederhole Schritt 1 mit “Sterbedatum” und dem GREL Ausdruck value.find(/†[^\;)]+/)[0].
Die Spalte “Geburtsdatum” in zwei Spalten aufteilen via “Geburtsdatum” “Edit column” “Split into several columns…” und dem Seperator \s+in\s+ (Häkchen bei regular expression nicht vergessen).
Wiederhole Schritt 3 auf der Spalte “Sterbedatum”.
Spalten umbenennen
Unnötige Zeichen in Spalte “Geburtsdatum” ersetzen via “Geburtsdatum” “Edit cells” “Transform…” und dem GREL Ausdruck value.replace(/(\*\s*|†\s*)/, "") (alternativ geht das auch über den “Replace” Dialog).
Wiederhole Schritt 6 auf der Spalte “Sterbedatum”.

Alternative Lösung(en):

Wir verwenden match() und einen komplexen regulären Ausdruck um alle Datenbestandteile gleichzeitig zu extrahieren:

value.match(/.+\* (?<Geburtsdatum>\d{1,2}\. [a-zA-Zä]+ \d{4}) in (?<Geburtsort>[^;]+); † (?<Sterbedatum>\d{1,2}\. [a-zA-Zä]+ \d{4}) in (?<Sterbeort>[^;|\)]+).+/)

Diesen GREL Ausdruck können wir dann viermal mit “Kurzbiographie” “Edit column” “Add column based on this column…” anwenden und jeweils via value.match(...)[0] (Geburtsdatum) bis value.match(...)[3] (Sterbeort) die einzelnen Bestandteile für die jeweilige Spalte extrahieren.

Oder wir verwenden anstatt value.match(...)[...] die Funktion value.match(...).join(";") und teilen die neue Spalte anschließend an dem Trennzeichen ; in vier Spalten auf.

Oder wir extrahieren die Daten zuerst gemeinsam und transponieren sie anschließend, wie in Daten mit OpenRefine Transponieren beschrieben. Vor dem Transponieren müssen wir die Daten anhand von einem Zeilenumbruch \n in mehrere Zeilen aufteilen, die Spalte anhand von : in zwei Spalten aufteilen und mit “Edit cells” “Fill down” die restlichen Spalten auffüllen.

with(
 value.match(/.+\* (?<Geburtsdatum>\d{1,2}\. [a-zA-Zä]+ \d{4}) in (?<Geburtsort>[^;]+); † (?<Sterbedatum>\d{1,2}\. [a-zA-Zä]+ \d{4}) in (?<Sterbeort>[^;|\)]+).+/),
 v,
 "Geburtsdatum: " + v[0] +
 "\nGeburtsort: " + v[1] +
 "\nSterbedatum: " + v[2] +
 "\nSterbeort: " + v[3]
)

Aufgabe 10: Vorsicht bei Umlauten

Wie schon erwähnt basiert OpenRefine auf Java und in der hier im Tutorial eingesetzten OpenRefine Version 3.9.3 wird Java in Version 11 mitgeliefert. Eine Übersicht über alle von Java in dieser Version unterstützen Features von regulären Ausdrücken findet sich in der Java 11 Dokumentation zu RegEx Pattern. Die Unicode Unterstützung ist bei den Mustern in Java 11 optional und muss daher separat aktiviert werden. Das hat zur Folge, dass “Sonderzeichen” wie unsere Umlaute äöü, oder die in der französischen Sprache gebräuchlichen Buchstaben mit Akzenten éêè, nicht von den Mustern [a-z] oder \w berücksichtigt werden.

Um zum Beispiel auch Umlaute zu berücksichtigen gibt es mehrere Möglichkeiten:

Umlaute explizit auflisten: [a-zäöüß]
Spezielle Klasse für Buchstaben (letter) verwenden: \p{L}
Spezielle Klasse für alphabetische Zeichen verwenden: \p{IsAlphabetic}
Unicode Modus mit inline Flag aktivieren: (?U)\w

Aufgabe: Kopieren Sie den folgenden GREL Ausdruck in einen GREL Dialog und ersetzen Sie ... mit den oben genannten Möglichkeiten auch Unicode-Zeichen zu berücksichtigen.

"abcöüßéêè€$123!-".find(/.../)

Hinweise:

In RegEx101 wird bei der Auswahl des Flavors Java 8 die Unicode Unterstützung über das U Flag nach dem regulären Ausdruck aktiviert. Inline Flags werden dort nicht unterstützt.
In OpenRefine wird U nur als inline Flag und nicht als Regex Flag unterstützt.

Fazit

Bei der Verwendung von regulären Ausdrücken sollte stets die Balance zwischen Genauigkeit und Trefferquote im Hinterkopf behalten werden. Liegt die Priorität darauf nur genau die Daten zu finden, die einem sehr präzisen Muster folgen? Oder formulieren wir das Muster eher unpräzise und filtern die überflüssigen Treffer in einem separaten Schritt?

Wie bei der Lösung zur Aufgabe 9 angesprochen, ist es manchmal einfacher und verständlicher die Arbeiten in mehrere einfache Schritte zu teilen, anstatt sie in einem komplexen Schritt zu formulieren. Also zum Beispiel Geburtsdatum und Geburtsort zusammenhängend zu extrahieren und dann aufzusplitten, anstatt komplexe reguläre Ausdrücke für ein Geburtsdatum und den Geburtsort separat zu formulieren.

Im nächsten Teil beschäftigen wir uns mit der Programmiersprache GREL.

09 Arbeiten mit GREL

Workshop - Daten mit OpenRefine Transponieren

Sun, 01 May 2022 00:00:00 +0000

OpenRefine kann Zeilen und Spalten tauschen. Diese Transposition kann sowohl auf dem kompletten Datensatz, als auch nur auf einer Auswahl an Spalten durchgeführt werden. In diesem Tutorial besprechen wir zwei Varianten des Transponierens.

Einführung

Transponieren in der OpenRefine Dokumentation.

Dieser Workshop wurde erstellt mit OpenRefine Version 3.5.0.
Dieser Workshop wurde zuletzt getestet mit OpenRefine Version 3.9.3.

In der Praxis kommt es vor, dass wir Daten in Spalten organisiert bekommen, die wir eigentlich zeilenweise benötigen, oder umgekehrt. In der nächsten Tabelle ist ein Ausschnitt von Daten zu Politikern im Kabinett Kretschmann III gezeigt, mit dem wir im Laufe dieser Aufgabe arbeiten werden. Die Daten sind in Spalten gespeichert.

GND-ID	Name	Geschlecht	Geburtsdatum	Geburtsort
143926683	Kretschmann, Winfried	Männlich	1948-05-17	Spaichingen
122189930	Hermann, Winfried	Männlich	1952	Rottenburg am Neckar
…	…	…	…	…

In der nächsten Tabelle sind die gleichen Daten zeilenweise gespeichert. Mit der zusätzlichen “GND-ID” Spalte, die wir nicht mittransponiert haben, ergibt sich dadurch eine Record-Struktur, wie wir sie im letzten Teil des Workshops kennen gelernt und besprochen haben.

GND-ID	Schlüssel	Wert
143926683	Name Geschlecht Geburtsdatum Geburtsort	Kretschmann, Winfried Männlich 1948-05-17 Spaichingen
122189930	Name Geschlecht Geburtsdatum Geburtsort	Hermann, Winfried Männlich 1952 Rottenburg am Neckar
…	Name Geschlecht Geburtsdatum Geburtsort	…

Mit der Option Daten in OpenRefine zu transponieren, können wir Daten in den oben gezeigten Formaten ineinander umwandeln.

Vorbereitung: Projekt erstellen

Die folgende Datei in ein OpenRefine-Projekt laden.

💾 Wir benötigen die folgende Datei (Rechtsklick und “Ziel speichern unter…”):

Kretschmann III als CSV

Die importierten Daten sind in Abbildung 1 gezeigt.

Bildschirmfoto der Daten nach dem Import.

Aufgabe 1: Transponieren ohne Schlüsselspalte

Wir transponieren in dieser Aufgabe die in Abbildung 1 abgebildeten Daten in ein zeilenweises Datenformat. Dabei lassen wir die Spalte “GND-ID” stehen um anschließend eine Record-Struktur zu erzeugen.

Zum Transponieren gehen wir in den zugehörigen Dialog via “Name" "Transpose" "Transpose cells across columns into rows…” und wählen dort die zu transponierenden Spalten aus. Wie in Abbildung 2 geben wir als Zielformat an, dass wir die Daten in einer Spalte (One column) zusammengefasst bekommen möchten.

Bildschirmfoto des Dialoges zum Transponieren in eine Spalte.

Das Ergebnis ist in Abbildung 3 gezeigt. Wir haben nun eine Record-Struktur mit der GND-ID als Identifikator und allen zugehörigen Daten in einem Record-Feld.

Bildschirmfoto der Daten nach dem Transponieren in eine Spalte.

Der Schritt von einer zeilenweiser Speicherung zurück zu Spalten geht über “Daten" "Transpose" "Transpose cells in rows into columns…”. In dem Dialog geben wir 4 Zeilen zum Transponieren an. Das Ergebnis ist in Abbildung 4 gezeigt.

Bildschirmfoto der Daten nach dem Transponieren von einer Spalte.

Hier sind auch schon zwei Nachteile beim Transponieren ohne Schlüssel zu sehen:

Die Spalten müssen nachgearbeitet werden (Name ändern, Präfix entfernen).
Die Daten müssen einheitlich sein, also gleiche Anzahl an Elementen und gleiche Sortierung, da die Umwandlung sonst “verrutscht”.

Aufgabe 2: Transponieren mit Schlüsselspalte

Wir machen die Änderungen rückgängig und stellen den in Abbildung 1 gezeigten Ursprungszustand des Projektes wieder her.

Diesmal transponieren wir die Daten in zwei Spalten, indem wir eine separate Schlüsselspalte erzeugen lassen. Dies funktioniert über den gleichen Dialog wie in Aufgabe 1 über “Name" "Transpose" "Transpose cells across columns into rows…”. Die Einstellungen sind in Abbildung 5 gezeigt.

Bildschirmfoto des Dialoges zum Transponieren in zwei Spalten.

Das Ergebnis der Umwandlung ist in Abbildung 6 gezeigt. Wir haben eine Record-Struktur mit der GND-ID als Identifikator und allen zugehörigen Daten in einem Record-Feld.

Bildschirmfoto der Daten nach dem Transponieren in zwei Spalten.

Bevor wir von diesem Format zu einem Spaltenformat kommen, müssen wir zuerst die Records auflösen. Wir haben in diesem Datensatz nur eine Spalte (“GND-ID”) mit leeren Feldern, also genügt es diese über “GND-ID" "Edit cells" "Fill down” aufzufüllen.

Anschließend können wir diesmal über “Schluessel" "Transpose" "Columnize by key/value columns…” mit den in Abbildung 7 gezeigten Einstellungen wieder zum Ursprungsformat zurückgelangen.

Bildschirmfoto des Dialoges zum Transponieren von Schlüssel/Werte Spalten.

Diesmal benötigen wir anschließend keine Anpassungen oder im Vorfeld schon sortierte Daten. Lediglich die Schlüssel in der Spalte “Schluessel” sollten einheitlich geschrieben sein.

Aufgabe 3: Transponieren ausgewählter Spalten

Eine weitere praktische Anwendung des Transponierens liegt vor, wenn man mehrere Spalten von einem Typ hat, die man in einem Arbeitsgang zum Beispiel via Clustering vereinheitlichen oder mit einer Normdatenquelle abgleichen möchte. Für diese Aufgabe wurden exemplarisch die Daten des bisher verwendeten Datensatzes mit den jeweiligen Wirkorten der Politikerinnen und Politikern ergänzt. Das Ergebnis nach dem Import wird in Abbildung 8 gezeigt.

💾 Wir benötigen die folgende Datei (Rechtsklick und “Ziel speichern unter…”):

Kretschmann III als CSV

Bildschirmfoto der Daten mit mehreren Ortsspalten.

Um alle Orte in der Tabelle in einem Arbeitsgang mit z.B. der GND abzugleichen, müssen wir die Daten der einzelnen Spalten in eine gemeinsame Spalte überführen. Dabei müssen wir uns merken, aus welcher Spalte die einzelnen Orte kommen, um sie nach dem Abgleich wieder zurück schreiben zu können.

Hierfür eignet sich ebenfalls das Transponieren. Die Voraussetzung dafür ist, dass die zu transponierenden Spalten alle direkt nacheinander gelistet sind. Dies lässt sich relativ komfortabel mit “ALL" "Edit columns" "Re-order / remove columns…” erledigen.

Anschließend werden nur die Ortsspalten über “Geburtsort" "Transpose" "Transpose cells across columns into rows…” zusammengeführt. Die Einstellungen sind in Abbildung 9 gezeigt.

Bildschirmfoto des Dialoges zum Transponieren von Spalten in Zeilen.

Hierbei nicht vergessen, den Haken bei “Fill down in other columns” zu setzen. Das spart das spaltenweise Auffüllen der einzelnen Spalten vor der Rückumwandlung. Das Ergebnis nach der Umwandlung ist in Abbildung 10 gezeigt.

Bildschirmfoto der Daten mit den zusammengefassten Ortsspalten.

Nach dem Abgleich werden die Daten mit wie in Abbildung 11 gezeigt wieder in das Spaltenformat umgewandelt.

Bildschirmfoto des Dialoges zum zurückführen der Zeilen in Spalten.

Das Ergebnis der Rückumwandlung ist in Abbildung 12 gezeigt. Bei Bedarf kann man die Ortsspalten jetzt wieder einsortieren und/oder für jede Ortsspalte eine GND-ID Spalte hinzufügen mit “Ortsspalte" "Reconcile" "Add entity identifiers column…”.

Bildschirmfoto mit den mit der GND abgeglichenen Daten.

Automatischer Fill-down

Sollte man beim Umwandeln in das Zeilenformat vergessen haben, den Haken bei “Fill down in other columns” zu setzen, dann kann man das noch spaltenweise mit “Spaltenname" "Edit cells" "Fill down” nachholen.

Hat man sehr viele Spalten, so kann man stattdessen via “ALL" "Transform…” den folgenden GREL Ausdruck verwenden.

if(isBlank(value), row.record.cells[columnName][0].value, value)

Dabei ist darauf zu achten, dass man die ID-Spalte entweder auslässt und separat auffüllt, oder die ID-Spalte bei der Massenbearbeitung via “Drag&Drop” ans Ende verschiebt. Ansonsten ändert sich die “Record”-Struktur, bevor alle Spalten befüllt wurden und der GREL-Ausdruck funktioniert nicht mehr.

Alternative für GND-ID Spalten

Hat man sehr viele Ortsspalten, dann lässt sich die Erzeugung der GND-ID-Spalten auch etwas automatisieren.

Nachdem man die Daten mit der GND abgeglichen hat (also bevor man die Zeilen wieder in Spalten überführt), ergänzt man die GND-Nummer im Namen des Ortes über “Ort" "Edit cells" "Transform…” und dem folgenden GREL Ausdruck.

value + "||" + cell.recon.match.id

Anschließend werden die Werte via “Ort" "Edit cells" "Split multi-valued cells…” und den Trennzeichen || in mehrere Zeilen aufgeteilt.

Der zukünftige Spaltenname wird ergänzt via “Ortstyp" "Edit cells" "Transform…” und dem folgenden GREL Ausdruck.

if(isBlank(value), row.record.cells[columnName][0].value + " (GND-ID)", value)

Das Ergebnis sieht dann wie in Abbildung 13 aus. Dort müssen jetzt noch die restlichen Spalten vor der Umwandlung in das auf Spalten basierte Format zum Beispiel mit “Fill down” aufgefüllt werden

Bildschirmfoto ergänzten Zeilen für die zukünftigen GND-ID Spalten.

Fazit

Transponieren in OpenRefine hat noch weitere Features, wie zum Beispiel die Berücksichtigung von extra Spalten, mehreren Werten und separaten Spalten für Notizen. Dabei ist OpenRefine gerade beim Unwandeln von zeilenweisen Daten in spaltenweise sehr sensibel gegenüber der Sortierung der Werte in der Schlüsselspalte und ggf. weiteren Spalten, die nicht mit umgewandelt werden sollen.

Ein typischer Fehler ist zum Beispiel die Umwandlung von “Records” mit “Columnize by key/value columns” ohne die “Records” vorher mit “Fill down” aufzulösen. Das führt dazu, dass “Leer” als eigener Wert berücksichtigt wird und OpenRefine die Daten dadurch wie in Abbildung 8 sehr unerwartet sortiert.

Bildschirmfoto des Ergebnisses von Aufgabe 2 ohne ‘Fill down’.

Im nächsten Teil ergänzen wir mit OpenRefine ein Projekt mit Daten aus anderen Projekten.

12 Daten zwischen Projekten in OpenRefine abgleichen

Workshop - Die Welt der Facets in OpenRefine

Sun, 01 May 2022 00:00:00 +0000

Nachdem wir uns im Workshops für Einsteiger hauptsächlich mit den Text Facets in OpenRefine beschäftigt haben, betrachten wir in diesem Tutorial weitere nützliche Facets.

Einführung

Facets in der OpenRefine Dokumentation.
Reconciliation Facets in der OpenRefine Dokumentation.

Dieser Workshop wurde erstellt mit OpenRefine Version 3.5.0.
Dieser Workshop wurde zuletzt getestet mit OpenRefine Version 3.9.3.

Vorbereitung: Projekt erstellen

Wir verwenden das im Tutorial 12 Daten zwischen Projekten abgleichen erstellte Projekt “Staedte in BW”.

Aufgabe 1: Datentypen anpassen

Der Grundzustand des Projektes ist in Abbildung 1 gezeigt.

Bildschirmfoto des Projektes ‘Staedte in BW’ ohne Anpassungen.

An der schwarzen Farbe der Spalteninhalte erkennen wir, dass wir es hier ausschließlich mit Textspalten zu tun haben. Da wir in diesem Tutorial Facets für verschiedene Datentypen kennen lernen wollen, passen wir die Datentypen der einzelnen Spalten an.

Hierfür gibt es in OpenRefine schon Befehle, die wir im Spaltenmenü finden “…“ "Edit cells" "Common Transforms" ”…”

Aufgabe: Wir passen die Datentypen in den folgenden Spalten an:

Urkundlich erwaehnt: Datum (toDate)
Flaeche (km2): Zahl (toNumber)
Bevoelkerung (2021): Zahl (toNumber)
Weibliche Bevoelkerung (2021): Zahl (toNumber)
Maennliche Bevoelkerung (2021): Zahl (toNumber)

Das Ergebnis sollte dann aussehen wie in Abbildung 2.

Bildschirmfoto des Projektes ‘Staedte in BW’ nach Typanpassungen.

In der “All” Spalte gibt es Facets, die auf den ganzen Datensatz angewendet werden können. Neben den schon bekannten Facets zum Filtern von mit Sternen oder Flaggen markierten Zeilen sowie komplett leeren Zeilen gibt es auch Facets zum Filtern von leeren Einträgen in Spalten oder Records. In Abbildung 3 sind die beiden Facets für “Blank value per column” und “Non-blank value per column” gezeigt. Mit diesen Facets lassen sich schnell und übersichtlich Zeilen filtern, ohne das “Facet by blank” für jede Spalte separat aufzurufen.

Aufgabe: Überprüfen Sie die folgende Aussage.

“Alle Orte in diesem Datensatz ohne Angabe zum männlichen Bevölkerungsanteil haben auch keine Angabe zum weiblichen Bevölkerungsanteil.”

Aufgabe 3: Null oder Leer

Bei den einzelnen Spalten gibt es drei Facets zur Identifikation von leeren Zeilen. Das Äquivalent zu den in Aufgabe 2 vorgestellten Facets ist das “Facet by blank (null or empty string)”, welches in Abbildung 4 abgebildet ist. Das Facet wurde geöffnet mit “Urkundlich erwaehnt" "Facet" "Customized facets" "Facet by blank (null or empty string)”.

Aufgabe: Öffnen Sie auf der Spalte “Urkundlich erwaehnt” zusätzlich die Facets “Facet by null” und “Facet by empty string”. Worin unterscheiden sich die drei Facets?

Lösung:

OpenRefine unterscheidet zwischen nichts (null) und einem leeren Text (""), der ja zumindest vom Typ Text ist. Da wir aber häufig null und "" gemeinsam behandeln wollen, gibt es zusätzlich blank, was null und "" zusammenfasst.

OpenRefine bietet unterschiedliche visuelle Darstellungen für Zahlen in Facets an. In Abbildung 5 ist die Histogrammansicht gezeigt. Auf der X-Achse ist der Wertebereich abgebildet und auf der Y-Achse die Häufigkeit des entsprechenden Wertes. Der angezeigte Bereich lässt sich mit Schiebern an den Seiten einschränken.

Zusätzlich zu dem normalen “Numeric Facet” gibt es bei den “Customized Facets” noch eine logarithmische Darstellung (“Numeric log facet”) und eine begrenzte logarithmische Darstellung (“1-boundet numeric log facet”).

Eine andere Darstellung ist das “Scatterplot facet”, welches zuerst ein Streudiagramm über alle numerischen Spalten anzeigt (Abbildung 6) und durch Auswahl eines Streudiagramms dieses in die Facet Ansicht übernimmt (Abbildung 7).

Bildschirmfoto des Scatterplots über alle numerischen Spalten.

In dem Streudiagramm in Abbildung 7 lassen sich auch Werte und Bereiche mit der Maus auswählen und danach filtern.

Aufgabe: In dem Datensatz gibt es laut Streudiagramm eine Stadt mit einem leichten “Männerüberschuss”. Um welche Stadt handelt es sich dabei?

Lösung:

Bei der Stadt handelt es sich um Karlsruhe.

Es gibt ein separates Timeline Facet, welches auf eine Spalte vom Typ Datum (“date”) angewendet werden kann. Wie in Abbildung 8 zu sehen, ist das ähnlich wie beim “Numeric facet” ein Histogramm, nur dass die Daten auf der X-Achse nach Datum geordnet sind.

Da das bei Jahreszahlen auch recht schnell unübersichtlich wird, können wir so ein Facet auch selbst erstellen. Wir gehen dazu auf “Urkundlich erwaehnt" "Facet" "Custome Numeric Facet…” und verwenden den folgenden GREL-Ausdruck um das in Abbildung 9 gezeigte Facet zu erstellen.

value.datePart("year")

Aufgabe: Erstellen Sie ein Facet mit den Differenzen für “weibliche - männliche” Bevölkerung.

Lösung:

Dafür benötigen wir ein “Custom Numeric Facet” mit dem folgenden GREL-Ausdruck:

row.cells["Weibliche Bevoelkerung (2021)"].value -
row.cells["Maennliche Bevoelkerung (2021)"].value

Da wir in dem GREL Ausdruck die Spalten direkt aufrufen, ist es egal von welcher Spalte aus wir das Facet erstellen.

Aufgabe 6: Text Facets

Es gibt neben dem “normalen” Text Facet auch noch weitere Facets zum Umgang mit Text. In Abbildung 10 sind untereinander das “Text length facet”, das “Log of text length facet” und das “Unicode char-code facet” gezeigt.

Bildschirmfoto der Facets zu Textlängen und dem Unicode Zeichenbereich.

Ziemlich hilfreich bei Texten ist auch das in Abbildung 11 gezeigte “Word Facet”, welches alle in der Spalte vorkommenden Worte aufzählt.

In Abbildung 11 ist zum Beispiel bei “erwähnt,” zu sehen, dass das normale Wort Facet auch Satzzeichen berücksichtigt. Möchte man das vermeiden, so kann dies durch einen Klick auf das blaue “change” im Kopfbereich des Facets angepasst werden. Wir passen den GREL-Ausdruck wie folgt an und erhalten das in Abbildung 12 gezeigte Facet.

value.replace(/(?<=[a-z])[,.-]/, " ").split(' ')

Aufgabe: Erstellen Sie auf der Spalte “Kurzbiographie” ein Facet, welches alle darin vorkommenden Jahreszahlen darstellt.

Lösung:

Dafür benötigen wir ein “Custom Text Facet” mit dem folgenden GREL-Ausdruck:

value.find(/\d{3,4}/)

Es gibt spezielle Facets zur Unterstützung von Reconciliation Vorgängen. Zwei davon (“Jugment action type” und “Best candidate’s score”) werden automatisch geladen.

Es können weitere Facets nachgeladen werden. Dafür starten wir einen Reconciliation Vorgang über “Stadt" "Reconcile" "Start Reconciling” und verwenden als “Service” den “GND reconciliation for OpenRefine” Service von lobid (siehe 06 Reconciling mit OpenRefine und der GND für die grundlegende Einrichtung und Benutzung des Dienstes).

Wir suchen nach einem “Geografikum” und lassen gut passende Treffer automatisch auswählen. Die Einstellungen sind in Abbildung 13 abgebildet.

Bildschirmfoto der Einstellungen für den Reconciling Dialog.

Über “Stadt" "Reconcile" "Facets" ”…" können wir dann die restlichen Facets nachladen.

Gruppe 1: Entscheidung

By judgment (default)
Jugment action type
Jugment action timestamp

In der Gruppe 1 sind Facets zu den getroffenen Entscheidungen zu finden. Hier kann danach gefiltert werden, ob für eine Zeile schon eine Entscheidung getroffen wurde, ob die Entscheidung automatisch oder manuell getroffen wurde und sogar zu welchem Zeitpunkt (Zeitstempel) die Entscheidung getroffen wurde.

Gruppe 2: Treffer

Best candidate’s score (default)
Best candidate’s type match
Best candidate’s name match

Die zweite Gruppe bezieht sich auf die Treffer und zwar immer nur auf den “besten” Treffer. Hier gibt es das Standard Facet mit der Bewertung des Treffers durch den Reconciliation Service. Außerdem gibt es noch zwei Facets, welche nützlich sind, wenn man iterativ mehrere Reconciliation Versuche auf einer Spalte durchführt und dabei mit und ohne Typisierung sucht.

Gruppe 3: Treffer Ähnlichkeit

Best candidate’s name edit distance
Best candidate’s name work similarity

Der Algorithmus zur Auswahl von Treffern durch den Reconciliation Service ist häufig nicht transparent oder direkt nachvollziehbar. Daher lassen sich in OpenRefine zusätzliche Facets laden, die die Ähnlichkeit des Spalteninhalts mit dem jeweils besten Treffer anzeigen.

Die Editierdistanz basiert auf der Levenshtein Distanz, die wir schon in 05 Daten mit OpenRefine clustern kennen gelernt haben. Die Wortähnlichkeit hingegen wird berechnet, indem die Anzahl der übereinstimmenden Wörter ohne Stoppwörter zwischen Zellinhalt und bestem Treffer gezählt und normalisiert wird. Der Wertebereich geht dabei von 0 für keine Ähnlichkeit bis 1 für vollkommene Übereinstimmung.

Gruppe 4: Treffer Typ

Best candidate’s types

Die Liste der Typen, die sich aus dem jeweils besten Treffer für die einzelnen Zeilen ergeben.

Aufgabe: Beim Erstellen des Tutorials sind vier Städte automatisch mit einem Treffer gematcht worden. Ein Treffer ist jedoch falsch. Überlegen Sie, mit welcher Facet Kombination Sie diesen falschen Treffer schnell isolieren können.

Lösung:

Eine mögliche Kombination wäre im Facet “Jugment action type” den Wert auto auszuwählen und im Facet “Best candidate’s name edit distance” auf eine Distanz größer 1 zu filtern.

Der falsch zugeordnete Treffer ist dann “Freiburg im Breisgau”.

Da sich die Implementierung der Suchstrategie im lobid Reconciliation Server ändern kann, ist es möglich, dass Sie andere Ergebnisse erhalten.

Aufgabe 8: Duplikate

Das Duplikate Facet haben wir bewusst übersprungen und an das Ende verschoben.

Über “Urkundlich erwaehnt" "Facet" "Customized facets" "Duplicates facet” können wir uns Zeilen anzeigen lassen, deren Werte mehr als einmal vorkommen. Wir können hier aber keine Duplikate auswählen, markieren oder wie beim Clustern mit Ungenauigkeiten arbeiten.

Aufgabe: Überlegen Sie sich, wo das Duplikate Facet sinnvoll eingesetzt werden kann.

Mögliche Lösung:

Im FDMLab nutzen wir das Facet zur schnellen Überprüfung, ob zum Beispiel eine ID-Spalte nur eindeutige Werte beinhaltet.

Fazit

Mit Facets können wir uns durch die Daten filtern, sie für die explorative Datenanalyse verwenden oder beim Data Cleaning zu bearbeitende Gruppen identifizieren und diese gesammelt korrigieren. Mit einem Grundverständnis von GREL können wir uns selbst Facets programmieren oder den Code der voreingestellten Facets anpassen. In Kombination mit regulären Ausdrücken können wir auf spezifischen Mustern basierende Facets erstellen.

Da die Facets nicht selbst benannt werden können, gibt es jedoch das Risiko, sich in seinen eigenen Filtern zu verlaufen.

Im nächsten Teil beschäftigen wir uns mit dem Import und Export von XML in OpenRefine.

14 XML importieren und exportieren

OpenRefine Workshop für Einsteiger veröffentlicht

Tue, 19 Apr 2022 00:00:00 +0000

Was hat denn der Osterhase hier im Blog entdeckt? Da ist seit Anfang April ein OpenRefine Workshop versteckt!

Wir haben schon 2021 im FDMLab einen an die Bedürfnisse im Archiv angepassten Workshop für OpenRefine entwickelt. Diesen internen Workshop haben wir anschließend zum Nachlesen oder selbst Lernen für den FDMLab Blog aufbereitet und online gestellt.

Im Workshop für Einsteiger geben wir eine grundlegende Einführung in die Bedienung mit OpenRefine. Dabei behandeln wir das Filtern, Sortieren und Umwandeln von Daten. Anschließend beschäftigen wir uns mit den Funktionalitäten von OpenRefine um Daten zu Clustern, mit der Gemeinsamen Normdatei (GND) oder Wikidata abzugleichen.

Link zum Einsteiger Workshop für OpenRefine

Im Mai veröffentlichen wir darauf aufbauend einen Workshop für Fortgeschrittene. Hier werden wir uns uns mit regulären Ausdrücken und der Programmiersprache GREL beschäftigen. Anschließend vertiefen wir die Arbeit mit OpenRefine im Kontext von Records und dem Umgang mit XML. Als Bonus lernen wir die erweiterten Suchoptionen beim Abgleich mit dem lobid GND API kennen.

Link zum Fortgeschrittenen Workshop für OpenRefine

Workshop - Daten mit OpenRefine umwandeln

Fri, 01 Apr 2022 00:00:00 +0000

Wir lernen verschiedene Methoden kennen um Daten aufzuräumen und umzuwandeln.

Daten transformieren in der OpenRefine Dokumentation.

Dieser Workshop wurde erstellt mit OpenRefine Version 3.5.0.
Dieser Workshop wurde zuletzt getestet mit OpenRefine Version 3.9.3.

Hintergrund

OpenRefine bietet unterschiedliche Arten an Daten umzuwandeln. Dies kann manuell auf Zellebene passieren, in einem “Facet”, auf Spaltenebene oder für bestimmte Aktionen auf dem kompletten Datensatz.

In den folgenden Aufgaben werden wir nun aktiv Daten filtern, umwandeln und zusammenführen.

Aufgabe 1: Leere Zeilen identifizieren und löschen

Wie in Aufgabe 3 in 02 Filtern und Sortieren verwenden wir das “Facet by blank (null or empty string)” um Leerzeilen zu identifizieren. Denn in den 4.000 Einträgen (rows) sollte es 5 Leerzeilen geben. Diese werden jedoch nicht angezeigt, da sie nicht leer sind, sondern Leerzeichen beinhalten.

Die Leerzeichen können wir global über “All" "Edit all columns" "Trim leading and trailing whitespace” entfernen.

Anschließend können wir, wie in Abbildung 1, mit dem “Facet by blank (null or empty string)” die Leerzeilen auswählen und via “All" "Edit rows" "Remove matching rows” entfernen.

Gehen Sie noch einmal zurück zu den Bildschirmfotos der Importeinstellungen in Projekte in OpenRefine laden und verwalten und vergleichen diese für Aufgabe 1 und 2.

Wir können Probleme mit Leerzeilen schon beim Importieren lösen, indem wir, wie bei Aufgabe 2, das Kontrollkästchen bei “Trim leading & trailing whitespace from strings” aktivieren und das Kontrollkästchen bei “Store blank rows” abwählen. Das ist jedoch nicht immer möglich, oder manchmal wird es vergessen.

Aufgabe 2: Geschlechter vereinheitlichen

Die Geschlechtsbezeichnungen in der Spalte “Geschlecht (m/w)” sind sehr uneinheitlich. Wir wollen dies vereinheitlichen, so dass überall nur noch die Werte “m” und “w” stehen.

Dafür testen wir mehrere Methoden.

1. Einzeln bearbeiten

Wenn wir mit der Maus über eine Zelle gehen, dann erscheint wie in Abbildung 2 eine blaue Bedienfläche mit der Bezeichnung “edit”. Darüber können wir einzelne Zellen bearbeiten.

Bildschirmfoto von Edit Bedienfläche in Zelle.

Hinweise:

Die Bearbeitung auf diesem Weg kann zwar rückgängig gemacht, aber nicht als Aktion exportiert werden!

Wenn wir mit der Maus über einen Wert im Facet gehen, dann erscheint wie in Abbildung 3 ein blauer “edit” Link. Darüber können wir alle Zellen mit diesem Wert in der Spalte gleichzeitig bearbeiten.

3. Ersetzen in der Spalte

Im Spaltenmenü findet sich unter “Geschlecht (m/w)“ "Edit cells" "Replace” ein Dialog, mit dem in dieser Spalte Ersetzungen durchgeführt werden können.

4. Textfilter und Transform

Eine andere Methode ist eine Kombination aus Textfilter und “Transform”. Im Spaltenmenü wählen wir “Geschlecht (m/w)“ "Textfilter” und geben im Eingabefeld des Filters nur den Buchstaben “w” ein, der praktischerweise in “männlich” nicht vorkommt.

Im “Text Facet” für die Spalte Geschlecht, sehen wir analog zu Abbildung 4 die gefilterten Werte.

Bildschirmfoto mit Kombination aus Facet und Textfilter.

Anschließend rufen wir den Dialog zum Transformieren über das Spaltenmenü via “Geschlecht (m/w)“ "Edit cells" "Transform…” auf.

In dem Dialog könnte komplexer Code geschrieben werden, wir wollen den Inhalt jeder Zelle jedoch einfach mit dem Wert "w" ersetzen. Die Anführungszeichen sind wichtig, da wir dadurch OpenRefine mitteilen, dass wir den Wert w meinen, und keinen Programmcode.

Aufgabe 3: Spalte akad. Grad/Titel vereinheitlichen

In der Spalte “akad. Grad/Titel” sind die akademischen Grade uneinheitlich geschrieben (siehe auch Abbildung 5). Überlegen Sie, welche der in Aufgabe 2 gelernten Methoden hier geeignet wäre und vereinheitlichen Sie die Titel.

Bildschirmfoto mit Text Facet auf Spalte Titel.

Aufgabe 4: Spalten auftrennen

Bei den Ortsangaben sind der Ortsname und die GND-ID des Ortes mit | getrennt in einer Zelle. Wir wollen die Spalte “Geburtsort” auftrennen, so dass wir jeweils eine Spalte mit dem Ortsnamen und eine mit der zugehörigen GND-ID haben.

Dafür verwenden wir im Spaltenmenü den Dialog “Geburtsort" "Edit column" "Split into several columns…” mit den in Abbildung 6 gezeigten Einstellungen.

Bildschirmfoto vom Dialog zum Auftrennen von Spalten.

Anschließend entfernen wir überflüssige Leerzeichen via “Geburtsort" "Edit cells" "Common transforms" "Trim leading and trailing whitespace” und benennen die neuen Spalten entsprechend in “Geburtsort” und “Geburtsort (GND-ID)” um.

Hinweise:

Mit Hilfe des regulären Ausdrucks \s*\|\s* hätten wir die Leerzeichen beim Aufsplitten auch direkt entfernen können.
Vielleicht sind Ihnen Zeilen aufgefallen, wo anstelle des Ortes nur die GND-ID steht. Um diese kümmern wir uns später.

Aufgabe 5: Spalten zusammenführen

Beim Sterbedatum haben wir das umgekehrte Problem. Hier ist das Datum in drei Spalten aufgeteilt, wir wollen jedoch eine Spalte haben. Bevor wir die Spalten zusammenführen, prüfen wir, ob die Werte in den einzelnen Spalten sinnvoll sind, und korrigieren die Werte bei Bedarf.

Anschließend rufen wir im Spaltenmenü den Dialog zum Zusammenführen von Spalten auf “Todesdatum (Tag)“ "Edit column" "Join columns…” mit den in Abbildung 7 gezeigten Einstellungen.

Bildschirmfoto vom Dialog zum Zusammenführen von Spalten.

Aufgabe 6: Datum vereinheitlichen

In der Spalte “Geburtsdatum (exakt)” gibt es mehrere Formate für das Geburtsdatum:

“31.03.1920”
“31-03-1920”
“31. März 1920”

OpenRefine bietet verschiedene Funktionen an, um mit Daten zu arbeiten.

Datumsfunktionen in der OpenRefine Dokumentation.

Um die Daten in ein einheitliches Format zu bringen, wandeln wir sie zuerst in ein Datumsobjekt um und schreiben sie anschließend als Text wieder raus.

Dafür müssen wir OpenRefine noch mitteilen, wie die Eingabe- und Zielformate aussehen:

“dd.MM.yyyy”
“dd-MM-yyyy”
“dd. MMMM yyyy”

Um die Daten umzuwandeln öffnen wir den Dialog zum Transformieren über das Spaltenmenü von “Geburtsdatum (exakt)“ "Edit cells" "Transform” und verwenden den Ausdruck:

value.toDate("dd.MM.yyyy", "dd-MM-yyyy", "dd. MMMM yyyy").toString("dd.MM.yyyy")

Hinweise:

OpenRefine bietet die Möglichkeit Programmcode zu nutzen um Transformationen durchzuführen. Dazu gehören Clojure/Python und die General Refine Expression Language (GREL).
Die Datumsumwandlung gehört zu den Funktionen von GREL, die wir auf Grund ihrer Relevanz in diesen Einführungsworkshop mit aufgenommen haben.

Aufgabe 7: Daten mit Filter auf eine andere Spalte übertragen

In der Spalte “Geburtsort” ist bei einem Ort die GND-ID verrutscht und der Ortsname verloren gegangen. Bei dem Ort handelt es sich um “Breslau (Polen)” mit der GND-ID “4008216-7”.

Um dies zu beheben erstellen wir ein “Text Facet” für die Spalte “Geburtsort” und filtern nur die Einträge mit “4008216-7”. Es gibt nun verschiedene Möglichkeiten die Daten in die Spalte “Geburtsort (GND-ID)” zu übertragen.

Zellen einzeln bearbeiten
Ein weiteres “Text Facet” für die Spalte “Geburtsort (GND-ID)” erstellen und in beiden die Werte gesammelt bearbeiten.
Die Werte via Textfilter oder “Text Facet” filtern und die Spalten zusammenführen ( “Geburtsort" "Edit column" "Join columns…”), ohne die Original Spalte zu löschen.
Im Spaltenmenü via “Geburtsort (GND-ID)“ "Edit cells" "Transform” die Daten aus der anderen Spalte mit dem Ausdruck row.cells["Geburtsort"].value kopieren.

Alle Varianten haben ihre Berechtigung und je nach Kontext oder Anwendungsfall eignet sich die ein oder andere eher.

Fazit

Die Kombination aus Facets/Filtern und den Bearbeitungsmöglichkeiten machen OpenRefine zu unserem Liebling beim Aufräumen von Daten (Data Cleaning). Manchmal vermissen wir es jedoch größere Bereiche manuell auszuwählen und in eine andere Spalte zu Verschieben.

Im nächsten Teil lernen wir verschiedene Exportmöglichkeiten in OpenRefine kennen.

04 Daten mit OpenRefine exportieren

Gemeinsam an OpenRefine-Projekten arbeiten

Tue, 07 Dec 2021 00:00:00 +0000

Im FDMLab testeten wir verschiedene Möglichkeiten mit OpenRefine gemeinsam an Projekten zu arbeiten. Dieser Artikel fasst unsere Erfahrungen beim kollaborativen Arbeiten mit OpenRefine 3.5.0 zusammen.

Wir hatten in Fünf Dinge, die wir an OpenRefine mögen schon darüber berichtet, dass uns die Architektur von OpenRefine gefällt, da sie es ermöglicht OpenRefine sowohl auf einem Client (Laptop, Rechner), als auch auf einem Server laufen zu lassen. Die Bedienung erfolgt anschließend über den Browser.

--- title: OpenRefine Setup config: look: handDrawn theme: neutral --- flowchart LR subgraph server[fas:fa-server Server] server_or[fas:fa-gem OpenRefine] end subgraph laptop[fas:fa-laptop Laptop] browser[far:fa-window-maximize Browser] laptop_or[fas:fa-gem OpenRefine] end browser -.-> laptop_or & server_or

Da läge es nahe, dass OpenRefine auch eine Benutzerverwaltung und eine Möglichkeit zum Kollaborativen Arbeiten an Projekten anbietet. Dafür gab es Pläne ein Broker Protokoll für OpenRefine einzuführen, die bisher aber weder umgesetzt noch eingeplant wurden.

In der Dokumentation von OpenRefine wird folgendes Vorgehen empfohlen:

Die beste Art, mit einer anderen Person zusammenzuarbeiten, ist, Projekte zu exportieren und zu importieren, wobei alle Änderungen gespeichert werden, so dass Sie an der Stelle weiterarbeiten können, wo die andere Person aufgehört hat.

Übersetzt von Starting a project: Import a project, aufgerufen am 01.12.2021.

--- title: Gemeinsam arbeiten - Strategie 1 config: look: handDrawn theme: neutral --- flowchart TD subgraph a["fa:fa-user Alice"] vaa["fa:fa-table Version A"] vab["fa:fa-table Version B"] vac["fa:fa-table Version C"] vad["fa:fa-table Version D"] end subgraph b["fa:fa-user Bob"] vba["fa:fa-table Version A"] vbb["fa:fa-table Version B"] end subgraph c["fa:fa-user Charly"] vcb["fa:fa-table Version B"] vcc["fa:fa-table Version C"] end vaa -.Übergabe.-> vba --Arbeiten--> vbb -.Übergabe.-> vab -.Übergabe.-> vcb --Arbeiten--> vcc -.Übergabe.-> vac --Arbeiten--> vad

Konkret bedeutet das, dass bei einer Kooperation von Alice, Bob und Charly zwar alle an dem gleichen Projekt arbeiten können, jedoch nicht gleichzeitig. Nachdem Alice das Projekt an Bob übergeben hat, arbeitet Bob daran. Nachdem Bob fertig ist, übergibt er das Projekt an Alice zurück, die es an Charly übergibt. Nachdem Charly fertig ist, übergibt er das Projekt an Alice zurück, die dann erst daran weiterarbeiten kann. Das war für uns im FDMLab ein eher unbefriedigender Zustand, weshalb wir zu einer anderen Strategie gewechselt haben.

--- title: Gemeinsam Arbeiten - Strategie 2 config: look: handDrawn theme: neutral --- flowchart LR subgraph a["fa:fa-user Alice"] va["fa:fa-table Version A"] vb["fa:fa-table Version B"] vc["fa:fa-table Version C"] vd["fa:fa-table Version D"] end subgraph b["fa:fa-user Bob"] pa["fa:fa-table Part A"] end subgraph c["fa:fa-user Charly"] pb["fa:fa-table Part B"] end va -.-> pa vb -.-> pb pa -.-> vc pb -.-> vd va --Arbeiten--> vb --Arbeiten--> vc --Arbeiten--> vd

Wir haben angefangen Teile eines Projektes in OpenRefine auszulagern und nach erfolgreicher Bearbeitung wieder in das Originalprojekt einzupflegen. So kann in unserem Beispiel Alice weiter an dem Projekt arbeiten, während Bob und Charly sie durch die Bearbeitung einzelner Teile unterstützen. Diese Teile werden anschließend von Alice wieder in das Originalprojekt eingepflegt. Wie das funktioniert besprechen wir in den folgenden Unterpunkten.

Zeilenweise zusammenführen

Manchmal ist es möglich, ein Projekt zeilenweise aufzuteilen. Also dass Alice die ersten 100 Zeilen, Bob die nächsten 100 und Charly die letzten 75 Zeilen bearbeitet.

Die Ergebnisse können nach der Bearbeitung als CSV-Dateien exportiert und daraus anschließend ein neues OpenRefine-Projekt erstellt werden.

Bildschirmfoto der Dateiauswahl Oberfläche von OpenRefine.

Wie in Abbildung 1 gezeigt, kann OpenRefine ein Projekt aus mehreren Dateien erstellen. Das kann auch ein Dateiarchiv sein, dessen Dateien in ein neues Projekt importiert werden.

Bildschirmfoto des Dateifilter Oberfläche von OpenRefine.

Bevor das Projekt konfiguriert wird, gibt es wie in Abbildung 2 gezeigt, die Möglichkeit einzelne Dateien aus- oder abzuwählen. Im Idealfall haben die einzelnen Dateien schon die gleichen Spaltenüberschriften in der richtigen Reihenfolge. Ansonsten bietet OpenRefine mit der Möglichkeit Spalten zu verbinden und Spalten zu verschieben die Möglichkeit das nachträglich zu bereinigen.

Spaltenweise zusammenführen

Ein häufiger Anwendungsfall im FDMLab ist, dass das Aufräumen und Transformieren der Daten von einer Person erledigt wird, die zum Beispiel beim Reconciling oder dem Abgleich mit weiteren Datenquellen von weiteren Personen unterstützt wird. Dafür werden einzelne Spalten als CSV (oder Excel) exportiert, von der unterstützenden Person bearbeitet und die Ergebnisse dann wieder in das Originalprojekt übernommen.

Ein anderer Fall kann sein, dass es schon einen anderen Datensatz gibt, dessen Daten komplett oder teilweise übernommen werden sollen. Das haben wir in Findbuchdaten mit OpenRefine wiederverwenden teilweise besprochen.

Beispiel

In unserem fiktiven Beispiel arbeitet Alice mit einem Datensatz der 16 Bundesländer, wie er in Abbildung 3 gezeigt ist. Diesen gibt sie an Bob und Charly weiter.

Bildschirmfoto der Oberfläche von OpenRefine mit den 16 Bundesländern.

Bob unterstützt Alice, indem er für die 16 Bundesländer das “Motto” recherchiert, er kann jedoch nicht für alle Bundesländer ein Motto finden und liefert den in Abbildung 4 gezeigten Datensatz zurück. ¹

Bildschirmfoto der Oberfläche von OpenRefine mit dem Motto einiger Bundesländer.

Charly hat die Aufgabe die Hauptstädte der einzelnen Bundesländer zu recherchieren, und liefert den in Abbildung 5 gezeigten Datensatz zurück. Dabei wurden jedoch die Namen der Bundesländer teilweise geändert, also zum Beispiel der Begriff “Freistaat” aus dem Namen wegoptimiert.

Bildschirmfoto der Oberfläche von OpenRefine mit den Hauptstädten der 16 Bundesländer.

Datensätze herunterladen

Die drei beschriebenen Datensätze können hier heruntergeladen werden, um die vorgestellten Methoden zum Zusammenführen von Daten beim gemeinsamen Arbeiten in OpenRefine selbst auszuprobieren

💾 Wir benötigen drei Dateien (Rechtsklick und “Ziel speichern unter…”):

Bundesländer als CSV

Bundesländer Motto als CSV

Bundesländer Hauptstädte als CSV

ID Spalte erstellen

Wir werden die Daten auf drei Arten abgleichen:

Via einer dedizierten ID-Spalte
Mit einer improvisierten ID-Spalte (Name des Bundeslandes)
Via Reconciling

Idealerweise haben alle Datensätze eine einheitliche ID-Spalte zum Abgleichen. Diese lässt sich in OpenRefine über “Spaltenmenü" "Edit column" "Add column based on this column…” mit dem folgenden GREL Ausdruck anlegen:

row.index + 1

Wie in Abbildung 6 gezeigt, wird so eine ID-Spalte erzeugt, deren Nummerierung analog zur Nummerierung der Zeilen in OpenRefine verläuft.

Bildschirmfoto des Spalten hinzufügen Dialogs in OpenRefine.

Alternativ lassen sich manchmal auch ID-Spalten improvisieren, indem zum Beispiel bei Personen die Namen und Vornamen in eine ID-Spalte übernommen werden.

Zusammenführen mit cross()

Alice hat von Bob und Charly zwei CSV-Dateien bekommen, die sie in ihr OpenRefine-Projekt übernehmen möchte. Eine Möglichkeit, das innerhalb von OpenRefine zu erledigen, ist die Funktion cross().

Im OpenRefine-Wiki gibt es einige Beispiele zur Anwendung von cross(). Außerdem gibt es eine OpenRefine-Erweiterung für cross() um die Funktion über Dialoge in der Oberfläche von OpenRefine zu verwenden.

Wir verwenden die Funktion cross() ohne Erweiterung. Dafür erstellen wir für die drei Datensätze jeweils ein Projekt.

Projekt “Bundesländer” aus bundeslaender.csv
Projekt “Bundesländer Motto” aus bundeslaender-motto.csv
Projekt “Bundesländer Hauptstadt” aus bundeslaender-hauptstadt.csv

Wir verwenden absichtlich Umlaute und Leerzeichen im Projektnamen, um zu testen, ob OpenRefine beim Auflösen mit cross() damit klarkommt!

Zusammenführen via ID

Idealerweise haben wir eine eindeutige ID-Spalte, um die Projekte miteinander abzugleichen. Mit cross() können wir über die ID-Spalte Daten aus einem anderen OpenRefine-Projekt nachladen. Das funktioniert aber nur, wenn die IDs eindeutig sind.

Nachladen des Mottos

Zum Nachladen des Mottos der Bundesländer gehen wir im “Bundesländer”-Projekt über das Spaltenmenü “ID" "Edit column" "Add column based on this column…” und verwenden den folgenden GREL Ausdruck.

cell.cross("Bundesländer Motto", "ID").cells["Mottotext"].value[0]

Dabei ist “Bundesländer Motto” der Name des Projektes aus dem wir die Daten holen wollen, und “ID” die ID-Spalte im Projekt “Bundesländer Motto”.

Bildschirmfoto des Spalten hinzufügen Dialogs mit cross() für den Mottotext in OpenRefine.

Wie in Abbildung 7 gezeigt, werden die Daten (also der Mottotext) aus dem anderen Projekt nachgeladen. Es haben nicht alle Bundesländer einen Mottotext hinterlegt, was den Abgleich nicht weiter stört.

Nachladen der Hauptstadt

Zum Nachladen der Hauptstadt der Bundesländer gehen wir im “Bundesländer”-Projekt über das Spaltenmenü “ID" "Edit column" "Add column based on this column…” und verwenden den folgenden GREL Ausdruck.

cell.cross("Bundesländer Hauptstadt", "ID").cells["Hauptstadt"].value[0]

Dabei ist “Bundesländer Hauptstadt” der Name des Projektes aus dem wir die Daten holen wollen, und “ID” die ID-Spalte im Projekt “Bundesländer Hauptstadt”.

Bildschirmfoto des Spalten hinzufügen Dialogs mit cross() für die Hauptstadt in OpenRefine.

Wie in Abbildung 8 gezeigt, werden die Daten (hier die Hauptstadt) aus dem anderen Projekt nachgeladen. Es haben alle Bundesländer eine Hauptstadt, so dass der Abgleich hier für jeden Eintrag ein Ergebnis produziert.

Außerdem ist zu erwähnen, dass sich OpenRefine hier auch nicht daran stört, dass die ID-Spalte bei uns im Projekt “Bundesländer” als Zahl, im Projekt “Bundesländer Motto” jedoch als Typ Text gespeichert ist.

Zusammenführen via Werte

Es ist nicht immer eine eindeutige ID-Spalte vorhanden. Das kommt zum Beispiel vor, wenn die Daten aus verschiedenen Projekten stammen. Man kann auch ID-Spalten improvisieren, was aber nicht immer zum gewünschten Ergebnis führt. Wir werden den Abgleich mit cross() diesmal über die Spalte “Bundesland” durchführen.

Nachladen des Mottos

Zum Nachladen des Mottos der Bundesländer gehen wir im “Bundesländer”-Projekt diesmal über das Spaltenmenü “Bundesland“ "Edit column" "Add column based on this column…” und verwenden den folgenden GREL Ausdruck.

cell.cross("Bundesländer Motto", "Bundesland").cells["Mottotext"].value[0]

Wie in Abbildung 9 zu sehen ist, hat der Abgleich zwischen diesen beiden Projekten kein Problem, da die Bundesländer hier einheitlich geschrieben sind.

Bildschirmfoto des Spalten hinzufügen Dialogs mit cross() für den Mottotext in OpenRefine.

Nachladen der Hauptstadt

Zum Nachladen der Hauptstädte der Bundesländer gehen wir im “Bundesländer”-Projekt diesmal über das Spaltenmenü “Bundesland“ "Edit column" "Add column based on this column…” und verwenden den folgenden GREL Ausdruck.

cell.cross("Bundesländer Hauptstadt", "Bundesland").cells["Hauptstadt"].value[0]

Wie in Abbildung 10 zu sehen ist, hat der Abgleich hier Probleme, da die Bundesländer teilweise unterschiedlich geschrieben sind. Es fehlen Ergänzungen wie “Freistaat”. Daher können die Daten für diese Bundesländer nicht nachgeladen werden.

Bildschirmfoto des Spalten hinzufügen Dialogs mit cross() für die Hauptstadt in OpenRefine.

Ergebnis

Bildschirmfoto von OpenRefine mit den Bundesländern und den zusätzlichen Spalten aus anderen Projekten.

Der Abgleich mit cross() innerhalb von OpenRefine funktioniert recht einfach, solange es eine Spalte mit eindeutigen Werten gibt. Der Abgleich stört sich auch nicht an Sonderzeichen, Leerzeichen oder fehlenden Werten.

Problematisch wird es, wenn die Werte der Spalten, die abgeglichen werden, nicht komplett übereinstimmen. Diese sind in Abbildung 11 farblich hervorgehoben. In solchen Fällen empfiehlt sich das im nächsten Abschnitt besprochene lokale Reconciling.

Zusammenführen mit lokalem Reconciling

Wir hatten in Fünf Dinge, die wir an OpenRefine mögen schon die Architektur von OpenRefine gelobt, da diese so gestaltet ist, dass OpenRefine auch mit anderen APIs kommunizieren kann. Besonders unterstützt ist dabei das Reconciliation Service API Protokoll. Damit können Daten in einem OpenRefine-Projekt nicht nur gegen Wikidata oder die GND abgeglichen werden, sondern mit Werkzeugen wie csv-reconcile auch mit lokalen CSV-Dateien.

--- title: OpenRefine Setup config: look: handDrawn theme: neutral --- flowchart LR subgraph server[fas:fa-server Server] server_or[fas:fa-gem OpenRefine] server_api[fas:fa-code Reconciliation Service API] end subgraph laptop[fas:fa-laptop Laptop] browser[far:fa-window-maximize Browser] laptop_or[fas:fa-gem OpenRefine] laptop_api[fas:fa-code Reconciliation Service API] end browser -.-> laptop_or & server_or laptop_or -.-> laptop_api & server_api server_or -.-> server_api

Für die Verwendung von csv-reconcile benötigt man Python auf seinem System. Ist Python vorhanden, dann kann csv-reconcile einfach via Shell (PowerShell, Git Bash, …) installiert werden. Wir erstellen dafür erst eine virtuelle Umgebung in unserem Arbeitsordner, um csv-reconcile ausschließlich dort zu installieren.

Der Arbeitsordner ist der Ordner, in dem wir unsere CSV-Dateien liegen haben, mit denen wir hier arbeiten.

Die virtuelle Umgebung für Python ermöglicht es uns, Python Bibliotheken nur für dieses Projekt zu installieren, so dass sie nicht mit Bibliotheken oder Python Versionen in anderen Projekten in Konflikt kommen.

> python -m venv venv # virtuelle Umgebung erstellen
> .\venv\Scripts\activate # virtuelle Umgebung aktivieren (Windows!)
(venv) > pip install csv-reconcile # csv-reconcile in virtuelle Umgebung installieren

Da csv-reconcile in Version 0.3.0 den Vorschaudienst optional anbietet und keine automatische Erkennung von Encoding und Trennzeichen in CSV-Dateien hat, erstellen wir in unserem Arbeitsordner zusätzlich eine Datei config.py mit dem folgenden Inhalt.

CSVKWARGS={'delimiter': ',', 'quotechar': '"'}
CSVENCODING='UTF-8'
MANIFEST = {
 "preview": {
 "url": "http://localhost:5000/preview/{{id}}",
 "width": 400,
 "height": 300
 }
}

Anschließend können wir mit aktivierter virtueller Umgebung in unserem Arbeitsordner den lokalen Reconciling Service für die “Bundesländer Motto” CSV-Datei initiieren und starten.

(venv) > csv-reconcile init --config config.py bundeslaender-motto.csv ID Bundesland
(venv) > csv-reconcile serve

Wenn wir mit dieser Datei fertig sind, können wir den lokalen Reconciling Service für die “Bundesländer Hauptstadt” CSV-Datei initiieren und starten.

Ob die virtuelle Umgebung aktiv ist, sieht man an der Ergänzung (venv) in der Shell. Ansonnsten lässt sie sich mit .\venv\Scripts\activate wieder aktivieren.

(venv) > csv-reconcile init --config config.py bundeslaender-hauptstadt.csv ID Bundesland
(venv) > csv-reconcile serve

Wir könnten die beiden lokalen Reconciling Services auch parallel laufen lassen, indem wir sie in unterschiedliche Ordner schieben und wie unter csv-reconcile: Common configuration beschrieben über die Variable SERVER_NAME in der config.py jeweils einen anderen Port setzen.

In OpenRefine fügen wir den lokalen Reconciliation Service hinzu, indem wir in einem Projekt über ein beliebiges “Spaltenmenü" "Reconcile" "Start reconciling” aufrufen und dort via “Add Standard Service…” die Adresse http://localhost:5000/reconcile eingeben. Der Port 5000 muss entsprechend angepasst werden, wenn er in der config.py geändert wurde.

Siehe auch die OpenRefine-Dokumentation zu Reconciling: Getting started.

Zusammenführen via ID

Idealerweise haben wir eine eindeutige ID-Spalte, um die Projekte miteinander abzugleichen. Dann ist der lokale Reconciliation Service fast schon etwas zu mächtig, und wird von uns eher eingesetzt, wenn wir es vermeiden wollen, zu viele OpenRefine-Projekte zu jonglieren.

Nachladen des Mottos

Wir haben den lokalen Reconciling Service für das “Bundesländer Motto”-Projekt, wie im oberen Abschnitt beschrieben, am laufen.

Zum Nachladen des Mottos der Bundesländer gehen wir im “Bundesländer”-Projekt über das Spaltenmenü “ID" "Reconcile" "Use values as identifiers” und wählen unseren CSV Reconciliation Service aus.

Die IDs werden nun alle zu Links. Wie im Maus-Hover in Abbildung 12 sehen wir, dass nicht alle IDs aufgelöst werden, sondern manchmal eine “Nicht gefunden” Meldung angezeigt wird. Zur Erinnerung: es gibt nicht für alle Bundesländer ein Motto in unseren Daten!

Bildschirmfoto des Maus-Hover ‘Not Found’ in OpenRefine.

Den Mottotext können wir über “ID" "Edit column" "Add columns from reconciled values…” nachladen. Wie in Abbildung 13 zu sehen ist, kann der Dienst auch mit nicht auflösbaren IDs umgehen und ignoriert diese einfach.

Bildschirmfoto des Reconciliation Dialogs mit dem Mottotext in OpenRefine.

Nachladen der Hauptstadt

Wir haben den lokalen Reconciling Service für das “Bundesländer Hauptstadt”-Projekt, wie im oberen Abschnitt beschrieben, am laufen.

Zum Nachladen der Hauptstädte der Bundesländer gehen wir wieder im “Bundesländer”-Projekt über das Spaltenmenü “ID" "Reconcile" "Use values as identifiers” und wählen unseren CSV Reconciliation Service aus.

Die IDs werden nun alle wieder zu Links. Bei diesem Abgleich können alle IDs aufgelöst werden und wir sehen wie in Abbildung 14 überall Maus-Hover mit den entsprechenden Werten des gematchten Eintrags in der CSV-Datei.

Bildschirmfoto des Maus-Hover mit CSV Werten in OpenRefine.

Zusammenführen via Werte

Es ist nicht immer eine eindeutige ID-Spalte vorhanden. In so einem Fall spielt der lokale Reconciliation Service seine Stärke aus, da wir mit ihm auch “ungenaue” Werte finden und matchen können.

Nachladen des Mottos

Wir haben den lokalen Reconciling Service für das “Bundesländer Motto”-Projekt, wie im oberen Abschnitt beschrieben, am laufen.

Zum Nachladen der Mottos der Bundesländer über die Wertespalte gehen wir zu “Bundesland" "Reconcile" "Start reconciling” und wählen den “CSV Reconciling Service” aus.

Wie in Abbildung 15 markiert, ist das automatische Matching etwas zu großzügig, so dass Bundesländer gematcht werden, weil sie zum Beispiel beide den Begriff “Freistaat” im Namen haben. Das kann manuell und bei größeren Datenmengen mit der Unterstützung von Facets auf den Konfidenzwerten (Wert wie gut das Matching passt) nachgearbeitet werden.

Bildschirmfoto des Ergebnis des automatischen Reconciling in OpenRefine.

Den Mottotext können wir dann wieder über “Bundesland" "Edit column" "Add columns from reconciled values…” nachladen. Wie in Abbildung 16 zu sehen ist, kann der Dienst auch in diesem Fall mit nicht auflösbaren IDs umgehen und ignoriert diese einfach.

Bildschirmfoto des Reconciliation Dialogs mit dem Mottotext in OpenRefine.

Nachladen der Hauptstadt

Wir haben den lokalen Reconciling Service für das “Bundesländer Hauptstadt”-Projekt, wie im oberen Abschnitt beschrieben, am laufen.

Zum Nachladen der Hauptstädte der Bundesländer über die Wertespalte gehen wir zu “Bundesland" "Reconcile" "Start reconciling” und wählen den “CSV Reconciliation Service” aus.

Da wir in diesem Datensatz passende Einträge für alle Bundesländer haben, funktioniert das Matching, wie in Abbildung 17 zu sehen ist, recht gut, obwohl die Bundesländer teilweise anders geschrieben sind.

Bildschirmfoto der Oberfläche von OpenRefine mit den Reconciliation Ergebnissen für die Bundesländer.

Ergebnis

Der Abgleich mit dem lokalen Reconciling Service hat initial einen höherne Aufwand, da sowohl Python auf dem System als auch der CSV Reconciling Service in OpenRefine eingerichtet werden müssen. Dann ist das Verfahren jedoch deutlich flexibler als das Zusammenführen mit cross(), da darüber sowohl ein exaktes ID Matching und Nachladen von Spalten durchgeführt werden kann, als auch ein so genanntes Fuzzy-Matching, bei dem die Werte in den Spalten nicht exakt übereinstimmen.

In Abbildung 18 sind nochmal alle nachgeladenen Spalten abgebildet, wobei

via cross() auf der ID-Spalte
via cross() auf der Werte-Spalte (Namen Bundesland)
via lokalem Reconciling Service auf der ID-Spalte
via lokalem Reconciling Service auf der Werte-Spalte (Namen Bundesland)

nachgeladen wurde.

Bildschirmfoto von OpenRefine mit den Bundesländern und den zusätzlichen Spalten aus anderen Projekten.

Ausblick auf weitere Methoden

Für das Zusammenführen von Datensätzen mit OpenRefine gibt es noch weitere Möglichkeiten, die sich aktuell in der Planung und Entwicklung befinden.

Zum einen gibt es Überlegungen für Projekte in OpenRefine automatisch einen Reconciliation Service zu erstellen, so dass analog zu cross() direkt innerhalb von OpenRefine ein Reconciling gegen andere Projekte durchgeführt werden kann. Also Reconciling innerhalb von OpenRefine ohne separaten lokalen Reconciling Service.

Zum anderen gibt es mit Datasette ein komplettes Ökosystem um Daten in SQLite einzulesen und anschließend via unterschiedlicher APIs zur Verfügung zu stellen. Es wird gerade auch ein Reconciliation Plugin für Datasette entwickelt.

Gibt es in Arbeitsgruppen Datensätze, die intern oder extern veröffentlicht und auch für Reconciliation genutzt werden sollen, dann lohnt sich ein Blick auf dieses Werkzeug.

Fazit

OpenRefine bietet mit seiner Architektur das Potential zukünftig kollaboratives Arbeiten zu ermöglichen. Bis dahin können wir uns selbst helfen und mit wenig Extraaufwand Aufgaben aufteilen und die Ergebnisse wieder zusammenführen. Mit der cross() Funktion können wir direkt Daten aus anderen OpenRefine-Projekten über ID-Spalten übernehmen. Mit einem lokalem Reconciling Service können wir auch Daten aus unterschiedlichen Projekten verbinden.

Bisher klappt das beschriebene Vorgehen im FDMLab ganz gut und wir beobachten weiterhin gespannt die Entwicklung sowohl von OpenRefine, als auch von anderen Werkzeugen wie csv-reconcile und Datasette, die es hervorragend ergänzen.

Die Mottotexte wurden aus Wikidata geladen und sind daher genauso (un)vollständig, wie die Daten dort. ↩︎