Graph Analytics – Data Science Blog

Posts

Matrix search: Finding the blocks of neighboring fields in a matrix with Python

March 17, 2020/0 Comments/in Mathematics, Python, Tutorial /by Emilia Cheladze

Task

In this article we will look at a solution in python to the following grid search task:

Find the biggest block of adjoining elements of the same kind and into how many blocks the matrix is divided. As adjoining blocks, we will consider field touching by the sides and not the corners.

Input data

For the ease of the explanation, we will be looking at a simple 3×4 matrix with elements of three different kinds, 0, 1 and 2 (see above). To test the code, we will simulate data to achieve different matrix sizes and a varied number of element types. It will also allow testing edge cases like, where all elements are the same or all elements are different.

To simulate some test data for later, we can use the numpy randint() method:

import numpy as np

matrix = [[0,0,1,1], [0,1,2,2], [0,1,1,2]]

matrix_test1 = np.random.randint(3, size = (5,5))

matrix_test2 = np.random.randint(5, size = (10,15))

The code

def find_blocks(matrix):

visited = []

block_list = []

for x in range(len(matrix)):

for y in range(len(matrix[0])):

if (x, y) not in visited:

field_count, visited = explore_block(x, y, visited)

block_list.append(field_count)

return print('biggest block: {0}, number of blocks: {1}'

.format(max(block_list), len(block_list)))

def explore_block(x, y, visited):

queue = {(x,y)}

field_count = 1

while queue:

x,y = queue.pop()

visited.append((x,y))

if x+1<len(matrix) and (x+1,y) not in visited and (x+1,y) not in queue:

if matrix[x+1][y] == matrix[x][y]:

field_count += 1

queue.add((x+1,y))

if x-1>=0 and (x-1,y) not in visited and (x-1,y) not in queue:

if matrix[x-1][y] == matrix[x][y]:

field_count += 1

queue.add((x-1,y))

if y-1>=0 and (x,y-1) not in visited and (x,y-1) not in queue:

if matrix[x][y-1] == matrix[x][y]:

field_count += 1

queue.add((x,y-1))

if y+1<len(matrix[0]) and (x,y+1) not in visited and (x,y+1) not in queue:

if matrix[x][y+1] == matrix[x][y]:

field_count += 1

queue.add((x,y+1))

return field_count, visited

How the code works

In summary, the algorithm loops through all fields of the matrix looking for unseen fields that will serve as a starting point for a local exploration of each block of color – the find_blocks() function. The local exploration is done by looking at the neighboring fields and if they are within the same kind, moving to them to explore further fields – the explore_block() function. The fields that have already been seen and counted are stored in the visited list.

find_blocks() function:

Finds a starting point of a new block
Runs a the explore_block() function for local exploration of the block
Appends the size of the explored block
Updates the list of visited points
Returns the result, once all fields of the matrix have been visited.

explore_block() function:

Takes the coordinates of the starting field for a new block and the list of visited points
Creates the queue set with the starting point
Sets the size of the current block (field_count) to 1
Starts a while loop that is executed for as long as the queue is not empty
1. Takes an element of the queue and uses its coordinates as the current location for further exploration
2. Adds the current field to the visited list
3. Explores the neighboring fields and if they belong to the same block, they are added to the queue
4. The fields are taken off the queue for further exploration one by one until the queue is empty
Returns the field_count of the explored block and the updated list of visited fields

Execute the function

1 2	find_blocks(matrix)

The returned result is biggest block: 4, number of blocks: 4.

Run the test matrices:

find_blocks(matrix_test1)

find_blocks(matrix_test2)

Visualization

The matrices for the article were visualized with the seaborn heatmap() method.

import seaborn as sns

import matplotlib.pyplot as plt

# use annot=False for a matrix without the number labels

sns.heatmap(matrix, annot=True, center = 0, linewidths=.5, cmap = "viridis",

xticklabels=False, yticklabels=False, cbar=False, square=True)

plt.show()

Interview – Knowledge Graphs and Semantic Technologies

May 22, 2019/0 Comments/in Events, Insights, Interviews /by Editorial Staff

“It’s incredibly empowering when data that is clear and understood – what we call ‘beautiful data’ – is available to the data workforce.”

Juan F. Sequeda is co-founder of Capsenta, a spin-off from his research, and Senior Director of Capsenta Labs. He is an expert on knowledge graphs, semantic web, semantic & graph data management and (ontology-based) data integration. In this interview Juan lets us know how SMEs can create value from data, what makes the Knowledge Graph so important and why CDOs and CIOs should use semantic technologies.

Data Science Blog: If you had to name five things that apply to SMEs as well as enterprises as they are on their journey through digital transformation: What are the most important steps to take in order to create value from data?

I would state four things:

Focus on the business problem that needs to be solved instead of the technology.
Getting value out of your data is a social-technical problem. Not everything can be solved by technology and automation. It is crucial to understand the social/human aspect of the problems.
Avoid boiling the ocean. Be agile and iterate.
Recall that it’s a marathon, not a sprint. Hence why you shouldn’t focus on boiling the ocean.

Data Science Blog: You help companies to make their company data meaningfully and thus increase their value. The magic word is the knowledge graph. What exactly is a Knowledge Graph?

Let’s recall that the term “knowledge graph”, that is being actively used today, was coined by Google in a 2012 blogpost. From an industry point of view, it’s a term that represents data integration, where not just entities but also relationships are first class citizens. In other words, it’s data integration based on graphs. That is why you see graph database companies use the term knowledge graph instead of data integration.

In the academic circle, there is a “debate” on what the term “knowledge graph” means. As academics, it’s clear that we should always strive to have well defined terms. Nevertheless, I find it ironic that academics are spending time debating on the definition of a term that appeared in a (marketing) blog post 7 years ago! I agree with Simeon Warner on this: “I care about putting more knowledge in my graph, instead of defining what is a knowledge graph”.

Whatever definition prevails, it should be open and inclusive.

On a final note, it is paramount that we remember our history in order to avoid reinventing the wheel. There is over half a century of research results that has led us to what we are calling Knowledge Graphs today. If you are interested, please check out our upcoming ISWC 2019 tutorial “Knowledge Graphs: How did we get here? A Half Day Tutorial on the History of Knowledge Graph’s Main Ideas“.

Data Science Blog: Speaking of Knowledge Graphs: According to SEMANTiCS 2019 Research and Innovation Chair Philippe Cudre-Mauroux the next generation of knowledge graphs will capture more detailed information. Towards which directions are you steering with gra.fo?

Gra.fo is a knowledge graph schema (i.e ontology) collaborative modeling tool combined with google doc style features such as real-time collaboration, comments, history and search.

Designing a knowledge graph schema is just the first step. You have to do something with it! The next step is to map the knowledge graph schema to underlying data sources in order to integrate data.

We are driving Gra.fo to also be a mapping management system. We recently released our first mapping features. You now have the ability to import existing R2RML mapping. The next step will be to create the mappings between relational databases and the schema all within Gra.fo. Furthermore, we will extend to support mappings from different types of sources.

Finally, there are so many features that our users are requesting. We are working on those and will also offer an API in order to empower users to develop their own apps and features.

Data Science Blog: At Capsenta, you are changing the way enterprises model, govern and integrate data. Put in brief, how can you explain the benefits of using semantic technologies and knowledge technologies to a CDO or CIO? Which clients could you serve and how did you help them?

Business users need to answer critical business questions quickly and accurately. However, the frequent bottleneck is the lack of understanding of the large and complex enterprise databases. Additionally, the IT experts who do understand are not always available. The ultimate goal is to empower business users to access the data in the way they think of their domain.

This is where Knowledge Graphs come into play.

At Capsenta, we use our Knowledge Graph technology to bridge this conceptualization gap between the complex and inscrutable data sources and the business intelligence and data analytic tools that domain experts use to answer critical business questions. Our goal is to deliver beautiful data so the business users and data scientist can run with the data.

We are helping large scale enterprises in e-commerce, oil & gas and life science industries to generate beautiful data.

Data Science Blog: What are reasons for which Knowledge Graphs should be part of any corporate strategy?

Graphs are very easy for people to understand and express the complex relationships between concepts. Bubbles and lines between them (i.e. a graph!) is what domain experts draw on the whiteboard all the time. We have even had C-level executives look at a Knowledge Graph and immediately see how it expresses a portion of their business and even offer suggestions for additional richness. Imagine that, C-level executives participating in an ontology engineering session because they understand the graph.

This is in sharp contrast to the data itself, which is almost always very difficult to understand and overwhelming in scope. Critical business value is available in a subset of this data. A Knowledge Graph bridges the conceptual gap between a critical portion of the inscrutable data itself and the business user’s view of their world.

It’s incredibly empowering when data that is clear and understood – what we call “beautiful data” – is available to the data workforce.

Data Science Blog: Data-driven process analyzes require interdisciplinary knowledge. What advice would you give to a process manager who wants to familiarize her-/himself with the topic?

Domain experts/business users frequently use multiple words/phrases to mean the same thing and also a specific phrase can mean different things to different people. Also, the domain experts/business users speak a very different language than the IT database owners.

How can the business have clear, accurate answers when there’s inconsistency in what people mean and are thinking?

This is the social problem of getting everyone on the same page. We’ve seen Knowledge Graphs dramatically help with this problem. The exercise of getting people to agree upon what they mean and encoding it in an intuitive Knowledge Graph is very powerful.

The Knowledge Graph also brings the IT stakeholders into the process by clarifying exactly what data or, typically, complex calculations of data is the actual, accurate value for each and every business concept and relationship expressed in the Knowledge Graph.

It is crucial to avoid boiling the ocean. That is why we have designed a pay-as-you-go methodology to start small and provide value as quickly and accurately as possible. Ideally, the team has available what we call a “Knowledge Engineer”. This is someone who can effectively speak with the business users/domain experts and also nerd out with the database folks.

About SEMANTiCS Conference

SEMANTiCS is an established knowledge hub where technology professionals, industry experts, researchers and decision makers can learn about new technologies, innovations and enterprise implementations in the fields of Linked Data and Semantic AI. Founded in 2005 the SEMANTiCS is the only European conference at the intersection of research and industry.

This year’s event is hosted by the Semantic Web Company, FIZ Karlsruhe – Leibniz Institute for Information Infrastructure GmbH, Fachhochschule St. Pölten Forschungs GmbH, KILT Competence Center am Institut für Angewandte Informatik e.V. and Vrije Universiteit Amsterdam.

Analyse der Netzwerktopologie des Internets auf Basis des IPv4-Protokolls

June 14, 2018/0 Comments/in Data Mining, Data Science, Data Science at the Command Line, Data Science Hack, Hacking, Python, Python, Tool Introduction, Tools, Tutorial, Use Case, Use Cases, Visualization /by Christopher Kipp

Wie kommen Daten die man via Internet quer durch die Welt sendet eigentlich an ihr Ziel? Welchen Weg nehmen beispielsweise die Datenpakete, wenn ich von mir zu Hause eine Datei an meinen Nachbarn ein Haus weiter sende? Wie groß ist der “Umweg”, den die Daten nehmen? Und macht es eigentlich einen Unterschied, ob ich www.google.de, www.google.com oder www.google.nl aufrufe, oder gehen alle Suchanfragen sowieso an dasselbe Ziel?

Fragen wie diese lassen sich durch eine Kombination von Tools wie traceroute oder tracepath und geoiplookup beantworten und unter Verwendung des Python-Paketes geoplotlib sogar graphisch auf einer Weltkarte darstellen. Die so gewonnenen Ergebnisse zeigen Teile der Netzwerktopologie des Internets auf und führen zu interessanten, teils unerwarteten Erkenntnissen.

Ziel dieses Artikels soll sein, ein möglichst einfaches Tutorial zum selber mitbasteln bereit zu stellen. Die einzelnen Schritte die hierfür notwendig sind, werden möglichst einfach verständlich dargestellt und erklärt, trotzdem sind zum vollständigen Verständnis grundlegende Kenntnisse in Python sowie der Kommandozeile hilfreich. Er richtet sich aber auch an alle, die sich einfach einmal etwas in ihrer virtuellen Umgebung „umschauen“ möchten oder einfach nur an den Ergebnissen interessiert sind, ohne sich mit den Details und wie diese umgesetzt werden, auseinander setzen zu wollen. Am Ende des Artikels werden die einzelnen Skripte des Projekts als zip-Datei bereitgestellt.

Hinweis: Diese Anleitung bezieht sich auf ein Linux-System und wurde unter Ubuntu getestet. Windows-User können beispielsweise mit dem Befehl tracert (als Ersatz für traceroute) ähnliche Ergebnisse erziehlen, jedoch muss dann das Parsing der IP-Adressen abgeändert werden.

1. Grundsätzliches Erkunden der Route, die ein Datenpaket nimmt

Hierfür wird ein Programm wie traceroute, tracepath oder nmap benötigt, welches durch Versenden von „abgelaufenen Datenpaketen“ die Hosts „auf dem Weg“ zum Ziel dazu bringt, ihre IPv4-Adresse zurück zu geben. In diesem Artikel wird beispielhaft traceroute verwendet, da dieses unter den meisten Linux-Versionen bereits zur „Grundausstattung“ gehört und somit für diesen Schritt keine weitere Software installiert werden muss. Die Verwendung von traceroute folgt der Syntax:

1	sudo traceroute ${ZIEL}

Als Ziel muss hier die IP-Adresse bzw. der Domainname des Zielrechners angegeben werden. Ein Beispiel soll dies vereinfachen:

$ sudo traceroute www.google.de

traceroute to www.google.de (172.217.22.99), 64 hops max

1 192.168.0.1 167,148ms 3,200ms 11,636ms

2 83.169.183.11 21,389ms 19,380ms 88.134.203.107 16,746ms

3 88.134.203.107 27,431ms 24,063ms *

4 88.134.237.6 1679,865ms * 130,818ms

5 88.134.235.207 58,815ms 84,150ms *

6 72.14.198.218 144,998ms 107,364ms 108.170.253.68 121,851ms

7 108.170.253.84 58,323ms 101,127ms 216.239.57.218 44,461ms

8 216.239.57.218 43,722ms 91,544ms 172.253.50.100 67,971ms

9 172.253.50.214 106,689ms 96,100ms 216.239.56.130 110,334ms

10 209.85.241.145 63,720ms 61,387ms 209.85.252.76 73,724ms

11 209.85.252.28 71,214ms 61,828ms 108.170.251.129 81,470ms

12 108.170.251.129 64,262ms 52,056ms 72.14.234.115 71,661ms

13 72.14.234.113 262,988ms 55,005ms 172.217.22.99 66,043ms

Im Beispiel wird die Route zum Hostrechner mit der Domain www.google.de ermittelt. In der ersten Spalte der Ausgabe ist die Nummer des jeweiligen „Hops“ zu sehen. Wichtig ist insbesondere die zweite Spalte, welche die IPv4-Adresse des jeweiligen Rechners auf dem Weg zum Ziel darstellt. Die folgenden Spalten enthalten weitere Informationen wie Antwortzeiten der jeweiligen Server und die IP-Adressen der Folge-Server.

Um die Ausgabe in eine Form umzuwandeln, welche später einfacher von Python gelesen werden kann, muss diese noch ausgelesen werden (Parsing). zuerst soll die erste Zeile der Ausgabe herausgeschnitten werden, da diese zwar informativ, jedoch kein Teil der eigentlichen Route ist. Dies kann sehr einfach durchgeführt werden, indem die Ausgabe des traceroute-Befehls an einen Befehl wie beispielsweise sed „gepiped“ (also weitergeleitet) wird. Die dabei entstehende Pipe sieht dann wie folgt aus:

1	sudo traceroute ${ZIEL} \| sed '1d'

Um bei unserem Beispiel mit der Route zu www.google.de zu bleiben, sieht der Befehl und die Entsprechende Ausgabe wie folgt aus:

$ sudo traceroute | sed '1d'

1 192.168.0.1 167,148ms 3,200ms 11,636ms

2 83.169.183.11 21,389ms 19,380ms 88.134.203.107 16,746ms

3 88.134.203.107 27,431ms 24,063ms *

4 88.134.237.6 1679,865ms * 130,818ms

5 88.134.235.207 58,815ms 84,150ms *

6 72.14.198.218 144,998ms 107,364ms 108.170.253.68 121,851ms

7 108.170.253.84 58,323ms 101,127ms 216.239.57.218 44,461ms

8 216.239.57.218 43,722ms 91,544ms 172.253.50.100 67,971ms

9 172.253.50.214 106,689ms 96,100ms 216.239.56.130 110,334ms

10 209.85.241.145 63,720ms 61,387ms 209.85.252.76 73,724ms

11 209.85.252.28 71,214ms 61,828ms 108.170.251.129 81,470ms

12 108.170.251.129 64,262ms 52,056ms 72.14.234.115 71,661ms

13 72.14.234.113 262,988ms 55,005ms 172.217.22.99 66,043ms

Anschließend soll die zweite Spalte der Ausgabe herausgeschnitten werden. Dies ist am einfachsten mit dem Befehl awk zu bewerkstelligen. Das Prinzip dahinter ist das gleiche wie im obigen Schritt: die Ausgabe des vorherigen Befehls wird dem Befehl awk als Eingabe weitergeleitet, womit der gesamte Befehl nun wie folgt aussieht:

1	sudo traceroute ${ZIEL} \| sed '1d' \| awk '{ print $2 }'

Bezogen auf das google-Beispiel sehen Ein- und Ausgabe nun so aus:

$ sudo traceroute | sed '1d' | awk '{ print $2 }'

192.168.0.1

83.169.183.11

88.134.203.107

88.134.237.6

88.134.235.207

72.14.198.218

108.170.253.84

216.239.57.218

172.253.50.214

209.85.241.145

209.85.252.28

108.170.251.129

72.14.234.113

Im letzten Schritt sollen die einzelnen IP-Adressen durch Leerzeichen getrennt in eine einzelne Zeile geschrieben werden. Sinn dieses Schrittes ist, dass später viele Zielrechner nacheinander aus einer Datei eingelesen werden können und jede Route zu einem Zielrechner als eine einzelne Zeile in eine Zieldatei geschrieben wird.
Auch dieser Schritt funktioniert ähnlich wie die obigen Schritte, indem die Ausgabe des letzten Schrittes an einen weiteren Befehl weitergeleitet wird, der diese Funktion erfüllt. Dieser Schritt könnte wieder mit dem Befehl sed durchgeführt werden, da aber nur ein einzelnes Zeichen (nämlich das Zeilenumbruch-Zeichen bzw. Newline) durch ein Leerzeichen ersetzt werden soll, wird hier aufgrund der einfacheren Syntax der Befehl tr verwendet.
Der fertige Befehl sieht nun wie folgt aus:

1 2	sudo traceroute ${ZIEL} \| sed '1d' \| awk '{ print $2 }' \| tr '\n' ' '

Oder im fertigen Beispiel mit www.google.de:

$ sudo traceroute | sed '1d' | awk '{ print $2 }' | tr '\n' ' '

192.168.0.1 83.169.183.11 88.134.203.107 88.134.237.6 88.134.235.207 72.14.198.218 108.170.253.84 216.239.57.218 172.253.50.214 209.85.241.145 209.85.252.28 108.170.251.129 72.14.234.113

Hiermit ist das Parsen abgeschlossen und die fertige Ausgabe kann nun in eine Ergebnisdatei geschrieben werden. Um automatisch viele Zielrechner aus einer Datei einzulesen und alle gefundenen Routen in eine Zieldatei zu schreiben, wird der obige Befehl in eine Schleife „verpackt“ welche die Zielrechner Zeile für Zeile aus der Datei zieladressen.txt ausliest und die gefundenen Routen ebenso Zeile für Zeile in die Datei routen.csv schreibt. Die Datei routen.csv kann später zur Ermittlung verschiedener Informationen zu den gefunden IP-Adressen einfach mit einem Python-Skript eingelesen und geparst werden.

In diesem Artikel wird das fertige Skript ohne weitere Erklärung in der beiliegenden zip-Datei bereitgestellt. Wen die genaue Funktionsweise der Schleife interessiert, sei angehalten sich generell über die Funktionsweise von Shellskripten einzulesen, da dies den Rahmen des Artikels sprengen würde.

#/bin/sh

cat zieladressen.txt | while read ZIEL; do

printf 'Ermittle Route nach: %s\n' "${ZIEL}"

traceroute ${ZIEL} | sed '1d' | awk '{ print $2 }' | tr '\n' ' ' >> routes.csv

printf '\n' >> routes.csv

done

cat routes.csv | tr -d \* | tr -s ' ' > routes_corrected.csv

mv routes_corrected.csv routes.csv

Dieses Skript benötigt die Datei zieladressen.txt welche wie folgt aussehen muss (anstatt Domainnamen können auch direkt IPv4-Adressen verwendet werden):

www.google.de

www.github.com

www.google.nl

...

2. Sammeln von (Geo-)Informationen zu bestimmten IPv4-Adressen

Die gefundenen IPv4-Adressen können anschließend mit dem Befehl geoiplookup oder über die Internetseite http://geoiplookup.net/ relativ genau (meißtens auf Städteniveau) lokalisiert werden. Dies funktioniert, da einzelne Subnets in der Regel bestimmten Regionen und Internetprovidern zugeordnet sind.

Der Befehl geoiplookup greift hierbei auf eine vorher installierte und lokal gespeicherte Datenbank zu, welche je nach installierter Version als Country- oder City-Edition vorliegt. Da geoiplookup nicht zu den Standartbordmitteln unter Linux gehört und um die weiteren Schritte auch Benutzern anderer Betriebssysteme zu ermöglichen, wird hier nur ein kurzes Beispiel der Benutzung dieses Befehls und dessen Ausgabe gegeben und im weiteren die Online-Abfrage mittels eines Python-Skriptes beschrieben.

$ geoiplookup 172.217.22.99

GeoIP Country Edition: US, United States

GeoIP City Edition, Rev 1: US, CA, California, Mountain View, 94043, 37.419201, -122.057404, 807, 650

GeoIP ASNum Edition: AS15169 Google Inc.

Die Internetseite http://geoiplookup.net bietet einen Onlineservice welcher Geo- und weitere Informationen zu gegebenen IPv4-Adressen bereitstellt. Öffnet man die Seite ohne Angabe einer IP-Adresse in einem Browser, so erhält man die entsprechenden Informationen über die eigene IP-Adresse. (Achtung: die Verwendung eines Proxies oder gar Tor führt zwangsläufig zu falschen Ergebnissen.)

Da die Seite auch über eine API (also eine automatisierte Abfrageschnittstelle) unter der Adresse “http://api.geoiplookup.net/?query=${IPADRESSE}” verfügt, kann man die entsprechenden Informationen zu den IP-Adressen mittels eines Pythonskriptes abfragen und auswerten. Als Antwort erhält man eine XML‑Datei welche beispielsweise folgendermaßen aussieht:

77.20.253.87

Vodafone Kabel Deutschland

Hamburg

Germany

53.61530

10.1162

Diese kann im Browser z. B. unter der Adresse http://api.geoiplookup.net/?query=77.20.253.87 aufgerufen werden (oder unter: http://api.geoiplookup.net/ für die eigene Adresse).

Um die hierin enthaltenen Informationen mit Hilfe von Python auszulesen lässt sich ElementTree aus aus dem Modul xml.etree, das in der Python-Standartbibliothek vorhanden ist, verwenden. Dies wird im beiliegenden Skript mit der Funktion get_hostinfo() bewerkstelligt:

def get_hostinfo(ipv4):

''' Returns geoiplookup information of agiven host adress as a dictionary.

The adress can be given as a string representation 0f a DNS or IPv4 adress.

get_hostinfo(str) -> dict

Examples: get_hostinfo("www.github.com")

get_hostinfo("151.101.12.133")

'''

apiurl = 'http://api.geoiplookup.net/?query='

hostinfo = defaultdict(str, {})

try:

xml = urllib.request.urlopen(apiurl + dns2ipv4(ipv4)).read().decode()

xml = xml.replace('&', '')

tree = ETree.fromstring(xml)

for element in tree.getiterator():

hostinfo[element.tag] = element.text

except:

return hostinfo

finally:

return hostinfo

Diese parst die XML-Datei automatisch zu einem Python-DefaultDict das dann die entsprechenden Informationen enthält (das DefaultDict wird verwendet da normale Python Dictionaries zu Fehlern führen, wenn nicht gesetzte Werte abgefragt werden). Die Ausgabe der Funktion sieht dann wie folgt aus:

In [3]: get_hostinfo('www.google.com')

Out[3]:

defaultdict(str,

{'city': 'Mountain View',

'countrycode': 'US',

'countryname': 'United States',

'host': '172.217.22.99',

'ip': '172.217.22.99',

'isp': 'Google',

'latitude': '37.4192',

'longitude': '-122.0574',

'result': None,

'results': None})

3. Plotten der gefundenen Routen mit geoplotlib auf einer Weltkarte

Wichtig für das anschließende Plotten ist hierbei die Geolocation also ‘latitude’ und ‘longitude’. Mit den Werten kann man anschließend die mit traceroute gefundenen Pfade als Basemap plotten. Dies funktioniert mit der Funktion drawroutes2map():

def drawroutes2map(routesfile='routes.csv'):

drawroutes = list()

for route in open(routesfile).readlines():

ips = [ip2location(ip) for ip in route.strip().split(',')]

print(ips)

locs = [loc for loc in ips if not loc == None]

longs = [loc[0] for loc in locs]

lats = [loc[1] for loc in locs]

m = minimalmap()

drawroutes.append(tuple(m(lats, longs)))

for drawroute in drawroutes:

m.plot(drawroute[0], drawroute[1], '-', markersize=0, linewidth=1, color=rand_color())

pickleto(drawroutes, 'tracedlocs.plk')

plt.savefig('world.svg', format='svg')

plt.savefig('world.png', format='png')

plt.show()

Der Plot einer Verbindungsanfrage an www.google.de aus Berlin sieht beispielsweise folgendermaßen aus:

Hier wird deutlich, dass Datenpakete durchaus nicht immer den kürzesten Weg nehmen, sondern teilweise rund um die Welt gesendet werden (Deutschland – USA – Sydney(!) – USA), bevor sie an ihrem Ziel ankommen und dass das Ziel einer Verbindung zu einer Domain mit der Endung „de“ nicht unbedingt in Deutschland liegen muss.

Mit Default-Einstellungen werden von der Funktion drawroutes2map() alle Routen in zufälligen Farben geplottet, welche in der Datei routen.csv gefunden werden.

Lässt man viele Routen plotten wird hierbei die Netzwerkstruktur deutlich, über die die Daten im Internet verteilt werden. Auf dem obigen Plot kann man recht gut erkennen, dass die meisten Internetseiten in Europa oder den USA gehostet werden, einige noch in China und Japan, dagegen beispielsweise Afrika praktisch unbedeutend ist.

Auf dem nächsten Plot wiederum ist zu erkennen, dass es tatsächlich eine Art “Hotspots” gibt über die fast alle Daten laufen, wie z. B. Frankfurt am Main, Zürich und Madrid.

4. Schematische Darstellung der Routen als directed Graph mit graphviz

Mit graphviz lassen sich schematische Graphen darstellen. Mit dem Paket pygraphviz existiert hiefür auch eine Python-Anbindung. Die schematische Darstellung als Graph ist in vielen Fällen deutlich übersichtlicher als die Darstellung auf einer Weltkarte und die Topologie des Netzwerkes wird besser sichtbar.

Die entsprechende Python-Funktion, die alle Routen aus der Datei routes.csv als geplotteten Graph ausgibt ist drawroutes2graph():

def drawroutes2graph(routesfile='routes.csv'):

'''Draws all routes found in the routesfile with graphviz to a Graph

drawroutes2graph(file)

'''

routes = open(routesfile).readlines()

for i in range(len(routes)):

routes[i] = routes[i].replace('*', '').split()

G = pgv.AGraph(strict=False, directed=True)

for l in routes:

for i in range(len(l)-1):

if not (l[i], l[i+1]) in set(G.edges()):

G.add_edge(l[i], l[i+1])

for n in G.nodes():

if get_hostinfo(n)['countrycode'] == 'DE':

n.attr['color'] = 'green'

elif get_hostinfo(n)['countrycode'] == 'US':

n.attr['color'] = 'red'

elif get_hostinfo(n)['countrycode'] == 'ES':

n.attr['color'] = 'yellow'

elif get_hostinfo(n)['countrycode'] == 'CH':

n.attr['color'] = 'blue'

elif get_hostinfo(n)['countrycode'] == 'CN':

n.attr['color'] = 'magenta'

G.write('routes.dot')

G.layout('dot')

G.draw('dot.png')

G.layout()

G.draw('neato.png')

Die Funktion schreibt den erstellten Graph in der Dot-Language in die Datei routes.dot und erstellt zwei verschiedene visuelle Darstellungen als png-Dateien.

Da mit der Funktion get_hostinfo() auch weitere Informationen zu den jeweiligen IP-Adressen verfügbar sind können diese auch visuell im Graph dargestellt werden. So sind in der folgenden Darstellung Hosts in verschiedenen Ländern in unterschiedlichen Farben dargestellt. (Deutschland in grün, USA in rot, Spanien in gelb, Schweiz in blau, China in magenta und alle übrigen Länder und Hosts ohne Länderinformation in schwarz).

Diese Art der Darstellung vereint damit die Vorteile der schematischen Darstellung mit der Geoinformation zu den jeweiligen Hosts. Aus der Grafik lässt sich beispielsweise sehr gut erkennen, dass, trotz oft vieler Zwischenstationen innerhalb eines Landes, Landesgrenzen überschreitende Verbindungen relativ selten sind.

Auch interessant ist, dass das Netzwerk durchaus Maschen aufweist – mit anderen Worten: Dass ein und dieselbe Station bei verschiedenen Verbindungsanfragen über verschiedene Zwischenstationen angesprochen wird und Daten, die von Punkt A nach Punkt B gesendet werden, nicht immer denselben Weg nehmen.

5. Schlussfolgerung

Was kann man hieraus denn nun letztendlich an Erkenntnissen ziehen? Zum einen natürlich, wie Daten via Internet über viele Zwischenstationen rund um die Welt gesendet und hierbei mit jeder Station neu sortiert werden. Vor allem aber auch, dass mit dem entsprechenden Know-How und etwas Kreativität mit bemerkenswert wenig Code bereits Unmengen an Daten gesammelt, geordnet und ausgewertet werden können. Alle möglichen Daten werden in unserer heutigen Welt gespeichert und sind zu einem nicht unbeträchtlichen Teil auch für jeden, der weiß, wer diese Daten hat oder wie man sie selber ermitteln kann, verfügbar und oft lassen sich hier interessante Einblicke in die Funktionsweise unserer Welt gewinnen.