diff --git a/Bachelorarbeit.lyx b/Bachelorarbeit.lyx new file mode 100644 index 0000000..6294533 --- /dev/null +++ b/Bachelorarbeit.lyx @@ -0,0 +1,5382 @@ +#LyX file created by tex2lyx 2.2 +\lyxformat 508 +\begin_document +\begin_header +\save_transient_properties true +\origin /home/jpt/Bachelorarbeit/ +\textclass scrreprt +\begin_preamble +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Setup des Dokuments +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Grundgröße 12pt, zweiseitig +% Packages from template +\usepackage[headsepline,automark]{scrpage2}% Seitenköpfe automatisch +\KOMAoptions{headinclude} % Fix +\usepackage[german]{babel} +% Sprachpaket für Deutsch (Umlaute, Trennung,deutsche Überschriften) +% Not needed anymore +% \usepackage{blindtext} +% Graphikeinbindung, Hyperref (alles klickbar, Bookmarks) +% Math. Symbole aus AmsTeX +% Umlaute +% Custom packages +\usepackage[autostyle=true,german=quotes]{csquotes}% Anführungszeichen mit \enquote{} +\usepackage{textcomp}% Zusätzliches Package für °C +\usepackage{listings}% Codesnippets +\usepackage{scrhack}% Hack for lstlisting i suspect :-/ +\usepackage{xcolor} +\usepackage{verbatim}% für comment-environment +% Setup für Codeblocks +\lstset{ + % Optionen + breaklines=true, + breakatwhitespace=true, + breakautoindent=true, + frame=single, + %framexleftmargin=19pt, + inputencoding=utf8, + %language=awk, + %numbers=left, + %numbersep=8pt, + showspaces=false, + showstringspaces=false, + tabsize=1, + %xleftmargin=19pt, + captionpos=b, + % Styling + basicstyle=\footnotesize\ttfamily, + commentstyle=\footnotesize, + keywordstyle=\footnotesize\ttfamily, + numberstyle=\footnotesize, + stringstyle=\footnotesize\ttfamily, +} +% Hack für Sonderzeichen in Codeblocks +\lstset{literate=% + {Ö}{{\"O}}1 + {Ä}{{\"A}}1 + {Ü}{{\"U}}1 + {ß}{{\ss}}1 + {ü}{{\"u}}1 + {ä}{{\"a}}1 + {ö}{{\"o}}1 + {°}{{${^\circ}$}}1 +} + +% Befehl für TODO-Markierungen +\newcommand{\todo}[1]{\textcolor{blue}{\emph{TODO: #1}}} + +% Befehl für Entwürfe und grobe Pläne +\newenvironment{draft}{\par\color{orange}\begin{center}Entwurf / Konzept\end{center}\hrule}{\hrule\par} + +% Broken citation needs broken command +\newcommand{\mathplus}{+} + +% Festlegung Kopf- und Fußzeile +\defpagestyle{meinstil}{% + {\headmark \hfill} + {\hfill \headmark} + {\hfill \headmark\hfill} + (\textwidth,.4pt) +}{% + (\textwidth,.4pt) + {\pagemark\hfill Jan Philipp Timme} + {Version 0.1 vom \today \hfill \pagemark} + {Version 0.1 vom \today \hfill \pagemark} +} + + +\raggedbottom + +\renewcommand{\topfraction}{1} +\renewcommand{\bottomfraction}{1} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Beginn des Dokuments (Titelseite und der ganze Krempel) +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\end_preamble +\options DIV14,BCOR10mm,parskip=half-,headsepline,headinclude +\use_default_options false +\maintain_unincluded_children false +\language german +\language_package default +\inputencoding utf8 +\fontencoding default +\font_roman "default" "default" +\font_sans "default" "default" +\font_typewriter "default" "default" +\font_math "auto" "auto" +\font_default_family default +\use_non_tex_fonts false +\font_sc false +\font_osf false +\font_sf_scale 100 100 +\font_tt_scale 100 100 +\graphics default +\default_output_format default +\output_sync 0 +\bibtex_command default +\index_command default +\paperfontsize 12 +\spacing single +\use_hyperref true +\pdf_bookmarks 0 +\pdf_bookmarksnumbered 0 +\pdf_bookmarksopen 0 +\pdf_bookmarksopenlevel 1 +\pdf_breaklinks 0 +\pdf_pdfborder 0 +\pdf_colorlinks 0 +\pdf_backref section +\pdf_pdfusetitle 0 +\papersize a4paper +\use_geometry false +\use_package amsmath 1 +\use_package amssymb 2 +\use_package cancel 0 +\use_package esint 1 +\use_package mathdots 0 +\use_package mathtools 0 +\use_package mhchem 0 +\use_package stackrel 0 +\use_package stmaryrd 0 +\use_package undertilde 0 +\cite_engine basic +\cite_engine_type default +\biblio_style plain +\use_bibtopic false +\use_indices false +\paperorientation portrait +\suppress_date false +\justification true +\use_refstyle 0 +\index Index +\shortcut idx +\color #008000 +\end_index +\secnumdepth 3 +\tocdepth 3 +\paragraph_separation indent +\paragraph_indentation default +\quotes_language german +\papercolumns 1 +\papersides 2 +\paperpagestyle meinstil +\tracking_changes false +\output_changes false +\html_math_output 0 +\html_css_as_file 0 +\html_be_strict false +\end_header + +\begin_body + +\begin_layout Standard + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% Titelseite +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +thispagestyle{empty} +\end_layout + +\end_inset + + +\begin_inset Graphics + filename res/Wortmarke_WI_schwarz.pdf + width 20text% + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + + +\begin_inset space ~ + +\end_inset + + +\family sans + +\begin_inset VSpace vfill +\end_inset + + +\size giant + +\series bold +Verarbeitung von Daten\SpecialChar softhyphen +strömen im RDF-Format in Kombination mit Hin\SpecialChar softhyphen +ter\SpecialChar softhyphen +grund\SpecialChar softhyphen +wis\SpecialChar softhyphen +sen in der C-SPARQL-Engine +\size default + +\begin_inset VSpace bigskip +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\lang german + +\size larger +Jan Philipp Timme +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash + +\backslash +[2ex] +\end_layout + +\end_inset + + Bachelor-Arbeit im Studiengang "`Angewandte Informatik"' +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash + +\backslash +[5ex] +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +today +\end_layout + +\end_inset + + +\size default + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\begin_inset VSpace vfill +\end_inset + + +\begin_inset space ~ + +\end_inset + + +\begin_inset space \hfill{} + +\end_inset + + +\begin_inset Graphics + filename res/H_WI_Pantone1665.pdf + height 30pheight% + +\end_inset + + +\begin_inset VSpace -3cm* +\end_inset + + +\end_layout + +\begin_layout Standard + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% Seite mit Personen und Selbstständigkeitserklärung +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset Newpage newpage +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +thispagestyle{empty} +\end_layout + +\end_inset + + +\begin_inset Tabular + + + + + + +\begin_inset Text + +\begin_layout Standard + +\lang german + +\series bold + +\family sans +Autor +\series default + +\end_layout + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +Jan Philipp Timme +\end_layout + +\end_inset + + + + +\begin_inset Text + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +1271449 +\end_layout + +\end_inset + + + + +\begin_inset Text + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +jan-philipp.timme@stud.hs-hannover.de +\end_layout + +\end_inset + + + + +\begin_inset Text + +\begin_layout Standard + +\lang german +[5ex] +\series bold + +\family sans +Erstprüfer +\series default + +\end_layout + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +Prof. Dr. Jürgen Dunkel +\end_layout + +\end_inset + + + + +\begin_inset Text + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +Abteilung Informatik, Fakultät IV +\end_layout + +\end_inset + + + + +\begin_inset Text + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +Hochschule Hannover +\end_layout + +\end_inset + + + + +\begin_inset Text + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +juergen.dunkel@hs-hannover.de +\end_layout + +\end_inset + + + + +\begin_inset Text + +\begin_layout Standard + +\lang german +[5ex] +\series bold + +\family sans +Zweitprüfer +\series default + +\end_layout + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +Jeremias Dötterl, M. Sc. +\end_layout + +\end_inset + + + + +\begin_inset Text + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +Abteilung Informatik, Fakultät IV +\end_layout + +\end_inset + + + + +\begin_inset Text + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +Hochschule Hannover +\end_layout + +\end_inset + + + + +\begin_inset Text + +\end_inset + + +\begin_inset Text + +\begin_layout Standard + +\lang german +jeremias.doetterl@hs-hannover.de +\end_layout + +\end_inset + + + + +\end_inset + + +\end_layout + +\begin_layout Standard + +\lang german + +\begin_inset VSpace vfill +\end_inset + + +\end_layout + +\begin_layout Standard + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% fett und zentriert in der Minipage +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard +\align center + +\lang german + +\family sans + +\series bold +Selbständigkeitserklärung +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Hiermit erkläre ich, dass ich die eingereichte Bachelor-Arbeit selbständig und ohne fremde Hilfe verfasst, andere als die von mir angegebenen Quellen und Hilfsmittel nicht benutzt und die den benutzten Werken wörtlich oder inhaltlich entnommenen Stellen als solche kenntlich gemacht habe. +\begin_inset VSpace 7ex* +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Hannover, den +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +today +\end_layout + +\end_inset + + +\begin_inset space \hfill{} + +\end_inset + +Unterschrift +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +pdfbookmark[0]{Inhalt}{contents} +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% Inhaltsverzeichnis +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset CommandInset toc +LatexCommand tableofcontents + +\end_inset + + +\begin_inset FloatList figure + +\end_inset + + +\begin_inset CommandInset toc +LatexCommand lstlistoflistings + +\end_inset + + +\begin_inset FloatList table + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset Newpage newpage +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +%%% Hier geht es richtig los mit dem Text! +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Chapter + +\family sans + +\series bold + +\lang german +Einleitung +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset label +LatexCommand label +name "cpt:introduction" + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Diese Arbeit beschäftigt sich mit +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Complex Event Processing +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + (CEP), also der Verarbeitung komplexer Ereignisse auf Ereignisdatenströmen in Kombination mit Do\SpecialChar softhyphen +män\SpecialChar softhyphen +en\SpecialChar softhyphen +wis\SpecialChar softhyphen +sen, und der praktischen Umsetzung dieses Vorhabens auf Basis von RDF-Datenströmen mit der CEP-Engine +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +C-SPARQL +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + +. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +todo{ +\end_layout + +\end_inset + +Dem Dokument anpassen; Soll groben Ausblick auf Inhalte geben. +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Nach einem kurzen Einstieg in das Thema CEP soll der Leser einen Einblick in die Features von aktuellen CEP-Engines erhalten und am Beispiel der Engine C-SPARQL +\begin_inset Foot +status collapsed + + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Mehr Informationen zu C-SPARQL und Download unter +\begin_inset Flex Flex:URL +status collapsed + +\begin_layout Plain Layout +http://streamreasoning.org/resources/c-sparql +\end_layout + +\end_inset + + +\end_layout + +\end_inset + + die Verarbeitung von Ereignisströmen im RDF-Format in Kombination mit Domänenwissen im Detail kennenlernen. An einem Beispielszenario soll dann der Praxiseinsatz von C-SPARQL erklärt werden, in dem einige der vorgestellten Funktionen Anwendung finden. Im Abschluss wird ein kurzer Ausblick auf die technischen Möglichkeiten des +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Reasoning +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + gegeben — eine Technik, die es erlaubt auf den vorhandenen und eingehenden Daten logische Operationen und Schlussfolgerungen durchzuführen um daraus neues Wissen abzuleiten. +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +Motivation +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset label +LatexCommand label +name "cpt:motivation" + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Mit der fortschreitenden Digitalisierung von Alltagsgegenständen und ihrer Verbindung mit dem Internet sind immer mehr offene Systeme online verfügbar, die ihre Sensordaten und Zustandsinformationen als RDF +\begin_inset Foot +status collapsed + + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Ressource Description Framework - Mehr dazu in Kapitel +\begin_inset CommandInset ref +LatexCommand ref +reference "cpt:basics" + +\end_inset + + +\end_layout + +\end_inset + +-Datenstrom anbieten. Ziel dieser Arbeit ist die Verarbeitung dieser Ereignisdatenströme mit der CEP-Engine C-SPARQL im Kontext einer Autoverleihgesellschaft zur Überwachung von Fahrzeugen. Dabei sollen komplexe Ereignisse aus Ereignismustern in den Datenströmen extrahiert werden und unter Integration von lokalem Domänenwissen zur weiteren Interpretation in einen eindeutigen Kontext gesetzt werden. Ein weiteres Ziel ist die Extraktion von Erkenntnissen aus den Ereignisströmen durch das Anstellen von Schlussfolgerungen auf den erhaltenen Daten (Reasoning). Diesbezüglich soll ergründet werden, welche CEP-Engines Reasoning implementieren und wie weitreichend ihre technischen Möglichkeiten in diesem Bereich reichen. +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +Szenario +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset label +LatexCommand label +name "cpt:scenario" + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Beispielszenario im Kontext dieser Arbeit ist eine Autoverleihgesellschaft, die ihren Fuhrpark überwachen möchte um ihren Kunden vergünstigte Tarife für verschleißarmes Fahrverhalten anbieten zu können. Weiterhin soll auf plötzlich auftretende Probleme an den Leihwagen möglichst schnell reagiert werden können um Schäden zu begrenzen, gefährliche Situationen zu vermeiden und bei Bedarf dem Kunden unverzüglich einen Ersatzwagen oder andere Hilfeleistungen anbieten zu können. Um all dies zu erreichen, werden zwei RDF-Datenströme zur späteren Verarbeitung mit der CEP-Engine C-SPARQL eingerichtet. +\end_layout + +\begin_layout Paragraph + +\family sans + +\series bold + +\lang german +Statusdatenstrom der Autos +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Über diesen Datenstrom melden die einzelnen Autos kontinuierlich ihre Statuswerte: +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Auto verschlossen (ja/nein) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Status des Motor (an/aus) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Status der Handbremse (angezogen/gelöst) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Momentangeschwindigkeit in km/h +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Drehzahl des Motors +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Reifendrücke der Reifen in bar +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Besonders wichtige Ereignisse, wie das Aufleuchten der Motorkontrollleuchte oder das Auslösen des Airbags, werden separat gemeldet. +\end_layout + +\begin_layout Paragraph + +\family sans + +\series bold + +\lang german +Interaktionsstrom der Kunden +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Wird einem Kunden ein Auto zugewiesen oder gibt ein Kunde ein geliehenes Auto wieder zurück, so wird hierfür ein Ereignis in diesen Datenstrom eingespeist. Diese Ereignisse enthalten immer eine eindeutige Kundennummer und die Nummer des geliehenen Fahrzeugs. +\end_layout + +\begin_layout Paragraph + +\family sans + +\series bold + +\lang german +Domänenwissen +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Um die Ereignisdaten aus den beiden beschriebenen Datenströmen bei der Verarbeitung in einen eindeutigen Kontext setzen zu können, wird lokal verfügbares Hintergrundwissen benötigt. Dieses enthält für dieses Szenario folgende Informationen: +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Eindeutige Zuordnung von Kundennummer zu einem Kunden +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Kundendaten wie Name und Telefonnummer +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Eindeutige Zuordnung von Fahrzeugnummer zu Automodell +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Wissen über die verschiedenen Automodelle: +\end_layout + +\begin_deeper +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Empfohlene Motordrehzahlbereiche für verschleißarmes Fahren +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Vorgeschriebener Reifendruck +\end_layout + +\end_deeper +\begin_layout Chapter + +\family sans + +\series bold + +\lang german +Grundlagen +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset label +LatexCommand label +name "cpt:basics" + +\end_inset + + +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +Einführung in das semantische Web +\end_layout + +\begin_layout Subsection + +\family sans + +\series bold + +\lang german +RDF im semantischen Web +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset label +LatexCommand label +name "cpt:rdf-semantic-web" + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Das Ressource Description Framework (RDF) wird bereits im semantischen Web zur Erfassung und Verknüpfung von Wissen verwendet. RDF-Daten bestehen aus einer Menge von Tripeln, welche sich aus den drei Komponenten Subjekt, Prädikat und Objekt in genau dieser Abfolge zusammensetzen. Jeder dieser drei Bestandteile eines Tripels wird durch eine eindeutige URI (Uniform Resource Identifier) identifiziert. +\begin_inset listings +lstparams "caption={Ein einzelnes Beispieltripel},label={lst:sample_rdf_triple}" +inline false +status collapsed + +\begin_layout Plain Layout + . +\end_layout + +\end_inset + +Das in Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_rdf_triple" + +\end_inset + + enthaltene Tripel ordnet das Auto-Subjekt #23 über das Prädikat +\family typewriter +isCarModel +\family sans + dem Objekt Automodell #42 zu. Wie anhand des Beispiels erkennbar ist, ist die explizite Notation für Tripel aufgrund der häufigen Nennung von vollständigen URIs wenig platzsparend und für große Datenmengen somit nicht empfehlenswert. Hierfür bietet sich die Nutzung von Prefixen an, die nach einmaliger Definition innerhalb eines Kontextes (zum Beispiel einer Datei) verwendet werden können. Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_rdf_triple_with_prefix" + +\end_inset + + zeigt die Notation von Tripeln im Turtle +\begin_inset Foot +status collapsed + + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Siehe auch +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "w3c:turtle" + +\end_inset + + +\end_layout + +\end_inset + +-Format unter Verwendung von Prefixen. +\begin_inset listings +lstparams "caption={Das Beispieltripel aus Listing~\ref{lst:sample_rdf_triple} mit Prefixen},label={lst:sample_rdf_triple_with_prefix}" +inline false +status collapsed + +\begin_layout Plain Layout +@prefix car: . +\end_layout + +\begin_layout Plain Layout +@prefix carModel: . +\end_layout + +\begin_layout Plain Layout +@prefix carSim: . +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\begin_layout Plain Layout +car:23 car:isCarModel carModel:42 . +\end_layout + +\end_inset + +Über Prädikate können diesem Subjekt mit Spezifikation im Objekt-Teil des Tripels bestimmte Attribute mit Werten zugesprochen werden oder Verknüpfungen mit anderen Subjekten hergestellt werden. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Aufgrund der Flexibilität dieser Struktur ist es möglich, nahezu jede Art von Informationen auf Tripel abzubilden, wie Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_rdf_data" + +\end_inset + + an einem Beispiel zeigt. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset listings +lstparams "caption={RDF-Daten beschreiben zwei Geschwister},label={lst:sample_rdf_data}" +inline false +status collapsed + +\begin_layout Plain Layout +:personA rdf:type :person +\end_layout + +\begin_layout Plain Layout +:personA :isGender :female +\end_layout + +\begin_layout Plain Layout +:personA :hasName "Marie" +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\begin_layout Plain Layout +:personB rdf:type :person +\end_layout + +\begin_layout Plain Layout +:personB :isGender :male +\end_layout + +\begin_layout Plain Layout +:personB :hasName "Max" +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\begin_layout Plain Layout +:personB :hasSibling :personA +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Da innerhalb des semantischen Web angestrebt wird, in RDF vorliegende Informationen gemeinsam zu nutzen, miteinander zu kombinieren und vernetzen zu können, werden RDF-Tripel meist als Quadrupel gehandhabt, in denen als zusätzliche Information der sogenannte Graph genannt wird, in dem die Tripel enthalten sind. Ein Graph wird durch eine URI identifiziert und dient somit als Namensraum für die Tripel, die er enthält. Dies vereinfacht die gleichzeitige Nutzung von mehreren Datenquellen, da jedes Tripel eindeutig einem Graphen zugeordnet werden kann und innerhalb von Abfragen spezifisch Tripel aus verschiedenen Graphen kombiniert werden können. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Zusätzlich werden im semantischen Web in OWL (Web Ontology Language) formulierte Ontologien als +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Strukturgerüst +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + verwendet. Eine Ontologie definiert ein Vokabular mit logischen Domänenobjektklassen und bestimmt für diese Objektklassen Prädikate und Attribute, um bestimmte Sachverhalte eindeutig abbilden zu können. Eine Ontologie für Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_rdf_data" + +\end_inset + + würde beispielsweise eine Objektklasse +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +person +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + definieren, auf welches die eigenen Prädikate +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +isGender +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + +, +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +hasName +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + und +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +hasSibling +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + angewandt werden können. Mit eigenen Attributen für das Prädikat +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +isGender +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + und spezifischen Regeln dafür, welche Attribute ein Prädikat wie +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +hasSibling +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + in Frage kommen können, werden Daten aus der Welt einer Ontologie — ähnlich wie bei einem relationalen Datenbankschema — eindeutig strukturiert. Hierbei ist jedoch wichtig hervorzuheben, dass für in RDF abgebildete Daten nahezu immer die Annahme gilt, dass diese Daten nicht vollständig sind (die sogenannte +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Open World Assumption +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + +). Die meisten Ontologien respektieren diese Annahme und verzichten auf die Definition von expliziten Regeln, die über die konkrete Bedeutung der Abwesenheit von bestimmten Fakten entscheiden würden. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Weiterhin ist es möglich, beliebig viele verschiedene Ontologien gleichzeitig zu verwenden. Diese Flexibilität ermöglicht beispielsweise, dass eine bereits in RDF abgebildete Person durch beliebige Informationen mit weiteren Ontologien ergänzt werden kann, oder dass die Informationen einer abgebildeten Person in verschiedenen, für andere Parteien geläufigen Strukturen verfügbar gemacht werden können. Auch kann innerhalb einer Ontologie auf Objektklassen und Attribute zurückgegriffen werden, die in anderen Ontologien definiert werden. Dies ermöglicht neben Erweiterungen für spezifische Zwecke auch das Übersetzen von Wissen zwischen verschiedenen Ontologien. +\end_layout + +\begin_layout Subsection + +\family sans + +\series bold + +\lang german +Abfrage von RDF-Daten via SPARQL +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset label +LatexCommand label +name "cpt:rdf-sparql" + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Die Abfrage von RDF-Daten erfolgt über die Sprache SPARQL ( +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +SPARQL Protocol And RDF Query Language +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + +), welche in diesem Abschnitt grob erläutert wird. Eine detaillierte Beschreibung von SPARQL ist unter +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "w3c:sparql" + +\end_inset + + nachzulesen. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Im Gegensatz zu Abfragesprachen von relationalen Datenbanksystemen wie SQL ist es mit SPARQL möglich, Daten über verschiedene Datenquellen wie Tripel- oder Quadstores hinweg miteinander zu verknüpfen. Auch ist im Gegensatz zu SQL keine spezielle Anpassung der Abfragen an ein Datenbankschema notwendig; lediglich die Art und Weise, wie die angeforderten Daten miteinander in Verbindung stehen, ist für SPARQL-Abfragen wichtig. Im Folgenden zeigt Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_sparql_query" + +\end_inset + + eine einfache Abfrage auf den Daten aus Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_rdf_data" + +\end_inset + +. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset listings +lstparams "caption={Abfrage des Namens des Bruders von Marie aus Daten von Listing~\ref{lst:sample_rdf_data}},label={lst:sample_sparql_query}" +inline false +status collapsed + +\begin_layout Plain Layout +SELECT ?nameOfBrother +\end_layout + +\begin_layout Plain Layout +WHERE { +\end_layout + +\begin_layout Plain Layout + ?marie rdf:type :person . +\end_layout + +\begin_layout Plain Layout + ?marie :hasName "Marie" . +\end_layout + +\begin_layout Plain Layout + ?marie :hasSibling ?brother . +\end_layout + +\begin_layout Plain Layout + ?brother :hasName ?nameOfBrother . +\end_layout + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_sparql_query" + +\end_inset + + zeigt, dass SPARQL in der groben Grundstruktur eine Ähnlichkeit zu SQL aufweist; allerdings sind bedingt durch die Struktur der Daten (Relationen bei SQL gegenüber Tripel und Quadrupel bei SPARQL) große Unterschiede in der Gestaltung der Abfragen — speziell in der +\family typewriter +WHERE +\family sans +-Klausel — zu finden: Hier werden Tripel mit Platzhaltern verwendet, um aus dem vorhandenen Datenbestand die Tripel zu isolieren, die auf das angegebene Muster passen. So wird in diesem Beispiel ein beliebiges Subjekt (gekennzeichnet durch +\family typewriter +?marie +\family sans +) gesucht, welches gleichzeitig vom Typ Person ist, den Namen +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Marie +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + trägt und einen bisher unbekannten Bruder ( +\family typewriter +?brother +\family sans +) hat, der einen noch unbekannten Namen ( +\family typewriter +?nameOfBrother +\family sans +) trägt. Für jedes Subjekt, auf welches diese Beschreibung passt, ergibt sich nun ein Ergebnis, welches die in der +\family typewriter +SELECT +\family sans +-Klausel angegebenen Felder zurückgibt — in diesem Fall also lediglich ein Ergebnis mit dem Wert +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Max +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + +. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Neben +\family typewriter +SELECT +\family sans + unterstützt SPARQL auch das Schlüsselwort +\family typewriter +CONSTRUCT +\family sans +. Dieses ermöglicht die direkte Konstruktion von neuen Tripeln aus vorgegebenen Tripeln mit Platzhaltern, welche mit den Ergebnissen der Abfrage gefüllt werden. Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_sparql_construct" + +\end_inset + + zeigt die Erzeugung von Tripeln für Geschwister, die auf ihren jeweilige Schwester ( +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +isSisterOf +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + +) beziehungsweise ihren jeweiligen Bruder ( +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +isBrotherOf +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + +) zeigen. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset listings +lstparams "caption={Konstruktion von Tripeln über das Bruder/Schwester-Verhältnis von Personen},label={lst:sample_sparql_construct}" +inline false +status collapsed + +\begin_layout Plain Layout +CONSTRUCT { +\end_layout + +\begin_layout Plain Layout + ?sister :isSisterOf ?brother . +\end_layout + +\begin_layout Plain Layout + ?brother :isBrotherOf ?sister . +\end_layout + +\begin_layout Plain Layout +} WHERE { +\end_layout + +\begin_layout Plain Layout + ?sister rdf:type :person . +\end_layout + +\begin_layout Plain Layout + ?sister :isGender :female . +\end_layout + +\begin_layout Plain Layout + ?sister :hasSibling ?brother . +\end_layout + +\begin_layout Plain Layout + ?brother :isGender :male . +\end_layout + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Subsection + +\family sans + +\series bold + +\lang german +Schlussfolgerungen auf RDF-Daten +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset label +LatexCommand label +name "cpt:reasoning" + +\end_inset + + +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Was ist Reasoning? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Welche Ebenen gibt es? ((OWL, RDFS?) - Unterschied erst bei Verwendung wichtig) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Warum ist es von Vorteil? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Mögliche Schwierigkeiten dabei? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Ontologien beschreiben Zusammenhänge zwischen Objektklassen und Klassen, die auf bestimmte Sachverhalte zutreffen. +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Naja, jedenfalls kann man da schonmal autocomplete-mäßig rechnen (RDFS) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Und dann kann man noch reguläre Schlussfolgerungen fahren in der Richtung OWL +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Warum ist Reasoning überhaupt wichtig und sinnvoll? +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Durch den Einsatz von Ontologien ergibt sich die Möglichkeit, auf RDF-Daten Ontologie-gestützt Schlussfolgerungen anstellen zu können ( +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Reasoning +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + +). In diesem Prozess werden aus den in RDF-Daten vorhandenen Fakten (Terminology Box, kurz: TBox) und den in den verwendeten Ontologien definierten Objektklassen, Regeln und Zusammenhängen (Assertion Box, kurz: ABox) neues Wissen abgeleitet +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "hsh:integrating" + +\end_inset + + und die lokale Datenbasis damit angereichert. So können beispielsweise implizite Klassentypen errechnet werden (Ein Kind ist eine Person), oder regelbasierte Attribute ermittelt werden: Max fährt ein Fahrzeug + das Fahrzeug ist ein Kran +\begin_inset Formula $\Longrightarrow$ +\end_inset + + Max ist ein Kranführer. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Enthält eine Ontologie Informationen über verschiedene Verwandtschaftsgrade in Familien, so ist es beispielsweise möglich auf Basis der Daten aus Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_rdf_data" + +\end_inset + + zusätzliche Verbindungen wie +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +isBrotherOf +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + und +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +isSisterOf +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + zu errechnen. Limitiert werden diese Möglichkeiten lediglich durch die OWA (Open World Assumption), also die Annahme einer offenen Welt, über die unvollständiges Wissen vorliegt. Deshalb dürfen für Reasoning nur explizit bekannte Fakten genutzt werden: Nur weil in Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_rdf_data" + +\end_inset + + keine Informationen über Eltern vorhanden sind, heißt das erst einmal nicht, dass Max und Marie wirklich Waisenkinder sind. Weiterführende Beispiele zu den Möglichkeiten von OWL Reasoning finden sich unter +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "man:owl" + +\end_inset + +. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Da Ontologien auch genutzt werden können, um Wissen aus den Strukturen einer Ontologie in die Struktur einer anderen Ontologie zu übersetzen, kann ein Reasoner die daraus resultierende Übersetzung direkt errechnen und der lokalen Datenbasis hinzufügen. Dadurch steht Abfragen, die schon auf die Ziel-Ontologie zugeschnitten sind, ein viel größerer Informationspool zur Verfügung, aus dem das Abfrageergebnis berechnet werden soll. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Diesen Vorteil erkauft man sich durch einen nicht unerheblichen Einsatz von Rechenleistung, da im Prozess des Reasoning eine Menge von zusätzlichen Daten entsteht, für die zusätzlich zu den bereits vorhandenen Daten die Regeln aller genutzten Ontologien berücksichtigt werden müssen. Behandelt man lediglich statische Daten, die sich kaum bis garnicht ändern, so ist der nötige Aufwand für Reasoning übersichtlich und liegt auch für große Mengen von Daten und Ontologien in einem akzeptablem Rahmen. Ändern sich jedoch häufig Daten, so muss für das Subset der sich geänderten Daten der Reasoning-Prozess erneut durchgeführt werden um eine vollständig aktuelle Datenbasis zu erhalten. +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +Einführung in Complex Event Processing +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Definition von CEP +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Ereignisse und Hintergrundwissen/Domänenwissen +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Beispielhafter, fiktiver Ereignisstrom mit Hinweis auf Zeitachse +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Kurzer Exkurs in Richtung Mustererkennung +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Im folgenden Abschnitt wird ein kurzer Einstieg in das Konzept von Complex Event Processing (CEP) gegeben. Eine detailreiche Erläuterung von CEP und die beispielhafte Anwendung der CEP-Engine +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Esper +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + wird in +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "hsh:cep" + +\end_inset + + beschrieben. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Wie der Begriff +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Complex Event Processing +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + schon andeutet, geht es bei CEP um die Verarbeitung von komplexen Ereignissen — konkret: Die Erkennung und Erfassung von komplexen Ereignissen aus Datenströmen von primitiven Ereignissen. Von Messereignissen aus mit Sensoren ausgestatteten Geräten über Transaktionen im Handel bis hin zu Benutzerinteraktionen auf Webseiten entstehen täglich unzählig viele, primitive Ereignisse, die abhängig von ihrem Kontext für einen bestimmten Zeitraum ein Stück der echten Welt korrekt abbilden. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Die in diesen primitiven Ereignissen enthaltenen Informationen stellen nur einen momentanen Zustand dar; sie haben für sich alleine betrachtet keinen Kontext und somit vorerst bedeutungslos. Betrachtet man beispielsweise ein Ereignis +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Die gemessene Temperatur beträgt 42°C. +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + +, so ist zunächst nicht zu erkennen, was es mit dieser Temperatur auf sich hat. Hier kommt das für die Verarbeitung bereits bekannte +\emph on +Hintergrundwissen +\emph default + (auch Domänenwissen) ins Spiel, welches das Ereignis in einen bekannten Kontext stellen kann. Es kann uns beispielsweise verraten, dass die Ereignisquelle ein Temperatursensor ist, der sich in einem PKW auf dem Motorblock befindet. Das Hintergrundwissen kann zu der bekannten Umgebung des Sensors viele weitere Angaben enthalten: Das konkrete Fabrikat des PKW, dessen Höchstgeschwindigkeit und die maximal zulässige Betriebstemperatur des Motors. Dieses Wissen ermöglicht schon eine genaue Einordnung der Informationen des Ereignisses; allerdings werden doch noch weitere Informationen benötigt, um ein eindeutiges Bild der Gesamtsituation zu erhalten. Kombiniert man das Temperaturereignis mit den Meldungen des im PKW installierten Geschwindigkeitssensors, so ergibt sich die Möglichkeit herauszufinden, ob für den aktuellen Betriebszustand des PKW die gemessene Motortemperatur. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Ein weiterer, wichtiger Faktor ist der Zeitraum in dem bestimmte Ereignisse auftreten. Um dies näher zu erläutern, betrachten wir den gegebenen Ereignisstrom aus Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_eventstream" + +\end_inset + +. +\begin_inset listings +lstparams "caption={Exemplarischer Ereignisstrom: Motortemperatur eines PKW},label={lst:sample_eventstream}" +inline false +status collapsed + +\begin_layout Plain Layout +[Event #1] Temperatur: 40°C +\end_layout + +\begin_layout Plain Layout +[Event #2] Temperatur: 48°C +\end_layout + +\begin_layout Plain Layout +[Event #3] Temperatur: 61°C +\end_layout + +\begin_layout Plain Layout +[Event #4] Temperatur: 84°C +\end_layout + +\end_inset + +Auf den ersten Blick ist ersichtlich, dass die Messwerte einen sehr starken Temperaturanstieg abbilden, jedoch fehlt eine Angabe darüber, wie viel Zeit zwischen diesen Ereignissen vergangen ist. Dadurch ist die Interpretation dieser Ereignisse nicht mehr eindeutig möglich: Liegen zwischen den Messereignissen beispielsweise etwa 30-60 Minuten, so könnte es sich um einen normalen Betrieb bei hoher Geschwindigkeit handeln. Sollten jedoch nur wenige Minuten zwischen den Messereignissen vergangen sein, so lassen die Messwerte auf einen Defekt schließen und ein Motorschaden wäre eine mögliche Folge. Die Zeitachse darf somit bei der Ereignisverarbeitung nicht vernachlässigt werden. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Ein weiterer Kernaspekt von CEP ist die Mustererkennung in Ereignissen. Aus bestimmten primitiven Ereignissen, die in einer bestimmten Abfolge auftreten, soll ein konkreter Sachverhalt abgeleitet werden. Treten bei einem PKW beispielsweise in kurzer Zeit nacheinander die Ereignisse +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Motor abgeschaltet +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + +, +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Fahrzeug verriegelt +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + und +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +PKW beschleunigt +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + auf, so könnte der Fall eingetreten sein, dass ein gerade abgestelltes Fahrzeug losgerollt ist und es sollte unverzüglich eine Reaktion darauf gestartet werden. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Insgesamt liegt die Herausforderung von CEP darin, in kürzester Zeit große Datenströme von Ereignissen mit Hintergrundwissen anzureichern, diese zu höherwertigen Ereignissen zu kombinieren und bestimmte Muster zu finden, sowie die Ergebnisse mit möglichst geringer Verzögerung in Echtzeit ausgeben zu können oder Reaktionen einzuleiten. +\end_layout + +\begin_layout Chapter + +\family sans + +\series bold + +\lang german +Gegenüberstellung existierender CEP-Engines +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Es gibt bereits einige Technologien um Ereignisströme zu verarbeiten. Im Folgenden stelle ich nun ein paar bekannte CEP-Systeme kurz vor. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Grobe Eckpunkte zur Orientierung: +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Woher kommt sie, wie sieht die Entwicklung zur Zeit aus? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Eckdaten über Implementierung +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Fähigkeiten und Funktionen? +\end_layout + +\begin_layout Section* + +\family sans + +\series bold + +\lang german +Anforderungen an CEP-Engines +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +todo{ +\end_layout + +\end_inset + +Eventuell fliegt die Section raus; Es sind mehr Kriterien/Features als Anforderungen, mal sehen was damit geschehen wird +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Verarbeitung von mehreren Ereignisströmen +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Kombination von Ereignissen +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Join +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Konstruktion neuer Ereignisse +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Sliding/Tumbling Windows +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Mustererkennung (Abfolge, Präsenz/Absenz von Ereignissen [zeitlicher Abstand]) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +COMPUTE EVERY +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + (Neuberechnung in festen Intervallen) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Ausführen von benutzerdefiniertem Code +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Integration von Hintergrundwissen [aus weiteren Quellen] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Aggregationsfunktionen über mehrere Ereignisse (Sum, Avg, ...) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Vergleichsoperatoren für Selektionskriterien +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Bonuspunkte: Reasoning (Logikoperationen und Schlussfolgerungen) +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +EP-SPARQL +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +FZI Research Center for Information Technology (Karlsruhe, Deutschland) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Karlsruhe Institute of Technology (Karlsruhe, Deutschland) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Stony Brook University (New York, USA) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +2011? +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "ep:unified" + +\end_inset + +[Da kam zumindest diese Quelle raus] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Event Processing SPARQL +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "ep:unified" + +\end_inset + + +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +In Prolog implementierter Prototyp +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "ep:unified" + +\end_inset + + +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Kann scheinbar Reasoning (nur RDFS, kein OWL?) +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "ep:etalis" + +\end_inset + + +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +CQELS +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Institut für Telekommunikationssysteme an der TU-Berlin (Berlin, Deutschland) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Insight Centre for Data Analytics an der National University of Ireland (Galway, Irland) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Institute of Information Systems an der Vienna University of Technology (Wien, Österreich) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +2015? +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "cqels:stream" + +\end_inset + +[Da kam zumindest diese Quelle raus] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Continuous Query Evaluation over Linked Stream +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Soll sehr schnell sein +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Zugriff auf lokales RDF-Wissen via IRI möglich (also ganz klassisch) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +CSPARQL auf RDF-Strömen +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Feeder können CSV lesen und zu RDF-Strömen machen, die der Engine zugeführt werden +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Listener können aus SPARQL-Query-Ergebnissen CSV produzieren +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +In Java implementiert +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Kein Reasoning? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +CQELS +\begin_inset Foot +status collapsed + + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Unter +\begin_inset Flex Flex:URL +status collapsed + +\begin_layout Plain Layout +http://graphofthings.org/debs2015/cqels.zip +\end_layout + +\end_inset + + ist ein VirtualBox-Image zum Ausprobieren von CQELS erhältlich. +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +C-SPARQL +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Woher kommt sie, wie sieht die Entwicklung zur Zeit aus? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Eckdaten über Implementierung +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Fähigkeiten und Funktionen? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Verarbeitet Ströme im RDF-Format. Kann Hintergrundwissen im RDF-Format einbeziehen. In Java implementiert und entsprechend auch recht einfach in Java-Projekte zu integrieren. +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Timestamp-Funktionalität zur Zeit mit einem Bug versehen, aber generell immernoch nutzbar. +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Integration von Hintergrundwissen und Abfragen über mehrere Streams kombiniert möglich. +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Reasoning zur Zeit auf RDFS-Niveau enthalten, es gibt Papers zu den Themen +\end_layout + +\begin_layout Chapter + +\family sans + +\series bold + +\lang german +CEP auf RDF-Datenströmen (Konzept) +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Hier kommt der Part hin mit der abstrakten CQL für die Situation + C-SPARQL-Queries +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +Ereignisse als RDF-Datenstrom +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Um Ereignisse aus verschiedenen Quellen gemeinsam zu verarbeiten ist RDF als kleinster gemeinsamer Nenner für Informationen das Mittel der Wahl. Hierbei werden die Ereignisse gegebenenfalls vorher in das RDF-Format transformiert und als Datenstrom aus RDF-Quadrupeln der CEP-Engine zugeführt. Die Quadrupel führen neben den ereignisrelevanten Informationen zusätzlich noch den Zeitstempel mit, zu dem das Ereignis ausgelöst wurde. Als Abfragesprache für die RDF-Datenströme kommt eine erweiterte Form von SPARQL — im Folgenden +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +CSPARQL +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + — zum Einsatz, welche Erweiterungen und Funktionen speziell für die Verarbeitung von RDF-Datenströmen mitbringt. CSPARQL kann die eingehenden RDF-Datenströme in sogenannten +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +Sliding Windows +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + erfassen und ermöglicht die Berücksichtigung der Zeitstempel der Ereignisse innerhalb der Abfrage durch die Bereitstellung von zusätzlichen Sprachkonstrukten und Funktionen. Dabei besteht weiterhin die Möglichkeit, lokal in Form von RDF-Daten vorhandenes Domänenwissen in die Abfrage einzubeziehen und mit den Ereignisdaten zu verknüpfen. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +In Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_rdf_event" + +\end_inset + + aufgeführt sind RDF-Tripel, die ein beispielhaftes Zustands-Ereignis aus einem PKW zeigen. Das Prefix +\family typewriter +http://example.org/cars +\family sans + wurde zu Zwecken der Übersichtlichkeit durch +\family typewriter +cars: +\family sans + abgekürzt. +\begin_inset listings +lstparams "caption={Ereignis im RDF-Format},label={lst:sample_rdf_event}" +inline false +status collapsed + +\begin_layout Plain Layout +http://example.org/cars/event#1468064960110 http://example.org/cars#carID http://example.org/cars#8 +\end_layout + +\begin_layout Plain Layout +http://example.org/cars/event#1468064960110 http://example.org/cars#currentTemperature "27"^^http://www.w3.org/2001/XMLSchema#integer +\end_layout + +\begin_layout Plain Layout +http://example.org/cars/event#1468064960110 http://example.org/cars#currentSpeed "13"^^http://www.w3.org/2001/XMLSchema#integer +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +todo{ +\end_layout + +\end_inset + +Noch ein wenig auf das Listing eingehen, URIs und die fiktiven Prädikate etwas erläutern +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +SPARQL-Erweiterung zur Verarbeitung von RDF-Datenströmen +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Der große Vorteil bei der Ereignisverarbeitung mit SPARQL auf RDF-Daten liegt in der Mächtigkeit dieser Abfragesprache: Innerhalb einer einzigen SPARQL-Abfrage ist es möglich Ereignisse aus verschiedenen Quellen miteinander zu kombinieren, direkt mit Hintergrundwissen zu kombinieren, nach eigenen Kriterien zu filtern, einfache Berechnungen anzustellen und aus dem Ergebnis neue Ereignisse beliebiger Struktur zu erzeugen. Somit muss der Anwender neben SPARQL keine weiteren Sprachen lernen oder sich anderweitig mit der Implementierung der Engine auseinandersetzen, sondern kann sich komplett auf die zu analysierenden Ereignisse konzentrieren. Listing +\begin_inset space ~ + +\end_inset + + +\begin_inset CommandInset ref +LatexCommand ref +reference "lst:sample_combine_events_sparql" + +\end_inset + + zeigt einen SPARQL-Query, in dem zwei aufeinanderfolgende Ereignisse mit Angaben zur Momentangeschwindigkeit eines Autos zu einem komplexeren Beschleunigungsereignis kombiniert werden. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset listings +lstparams "caption={Kombination von Ereignissen mit SPARQL},label={lst:sample_combine_events_sparql}" +inline false +status collapsed + +\begin_layout Plain Layout +REGISTER QUERY ConstructAcceleratingCars AS +\end_layout + +\begin_layout Plain Layout +PREFIX f: +\end_layout + +\begin_layout Plain Layout +PREFIX cars: +\end_layout + +\begin_layout Plain Layout +CONSTRUCT { +\end_layout + +\begin_layout Plain Layout + [] cars:carID ?car; +\end_layout + +\begin_layout Plain Layout + cars:acceleratedBy ?deltaSpeed . +\end_layout + +\begin_layout Plain Layout +} +\end_layout + +\begin_layout Plain Layout +FROM STREAM [RANGE 5s STEP 1s] +\end_layout + +\begin_layout Plain Layout +WHERE { +\end_layout + +\begin_layout Plain Layout + ?e1 cars:carID ?car ; +\end_layout + +\begin_layout Plain Layout + cars:currentSpeed ?speed1 . +\end_layout + +\begin_layout Plain Layout + ?e2 cars:carID ?car ; +\end_layout + +\begin_layout Plain Layout + cars:currentSpeed ?speed2 . +\end_layout + +\begin_layout Plain Layout + BIND (?speed2 - ?speed1 AS ?deltaSpeed) +\end_layout + +\begin_layout Plain Layout + FILTER(f:timestamp(?e1,cars:carID,?car) < f:timestamp(?e2,cars:carID,?car)) +\end_layout + +\begin_layout Plain Layout + FILTER(?speed1 < ?speed2) +\end_layout + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +todo{ +\end_layout + +\end_inset + +Streaming-Erweiterungen aus dem Listiung ein wenig hervorheben +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +Resoning auf RDF-Datenströmen? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Immer noch ein Forschungsgebiet +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +sehr hoher Datendurchsatz (viele kleine Ereignisse in geringem Zeitraum) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Ereignisinformationen ändern sich sehr häufig, sind nie sehr lange gültig und nicht immer relevant zur einer Abfrage +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Aber: Ergebnisse sollen möglichst schnell vorliegen +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset Formula $\Longrightarrow$ +\end_inset + + große Menge Rechenaufwand +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Einer der möglichen Ansätze: Reasoner errechnet für die Ereignisse Tripel mit begrenzter Lebensdauer +\end_layout + +\begin_layout Chapter + +\family sans + +\series bold + +\lang german +Nutzung der Engine C-SPARQL (Implementation) +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +In diesem Kapitel wird die C-SPARQL-Engine konkret vorgestellt und verwendet. +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +RDF-Datenströme +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Beispielszenario +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Umsetzung mit C-SPARQL +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Nötiger Code für das Grundsetup der Engine, Generatoren und co +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Konkreter Blick auf die CSPARQL-Queries +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Ergebnisse der Abfragen +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +Nutzung der C-SPARQL Engine in Java +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Im Folgenden wird auf die praktische Anwendung der C-SPARQL-Engine in einem Java-Projekt eingegangen. +\end_layout + +\begin_layout Subsection + +\family sans + +\series bold + +\lang german +Initialisieren der Engine +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Erst einmal die Instanz der Engine erzeugen und initialisieren (mit true, damit f:timestamp zur Verfügung steht). +\begin_inset listings +inline false +status collapsed + +\begin_layout Plain Layout +CsparqlEngine engine = new CsparqlEngineImpl(); +\end_layout + +\begin_layout Plain Layout +engine.initialize(true); +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Subsection + +\family sans + +\series bold + +\lang german +Stream-Generatoren +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Über den StreamGenerator muss ich etwas mehr erzählen, hier mal der grobe Code: +\begin_inset listings +inline false +status collapsed + +\begin_layout Plain Layout +public class StreamGenerator extends RdfStream implements Runnable { +\end_layout + +\begin_layout Plain Layout + private volatile boolean keepRunning = false; +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\begin_layout Plain Layout + public StreamGenerator(String iri) { +\end_layout + +\begin_layout Plain Layout + super(iri); +\end_layout + +\begin_layout Plain Layout + } +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\begin_layout Plain Layout + public void pleaseStop() { +\end_layout + +\begin_layout Plain Layout + keepRunning = false; +\end_layout + +\begin_layout Plain Layout + } +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\begin_layout Plain Layout + @Override +\end_layout + +\begin_layout Plain Layout + public void run() { +\end_layout + +\begin_layout Plain Layout + this.keepRunning = true; +\end_layout + +\begin_layout Plain Layout + while (this.keepRunning) { +\end_layout + +\begin_layout Plain Layout + long currentTime = System.currentTimeMillis(); +\end_layout + +\begin_layout Plain Layout + // Generate RdfQuadruple from data and hand it over to the engine +\end_layout + +\begin_layout Plain Layout + this.put(new RdfQuadruple( +\end_layout + +\begin_layout Plain Layout + someSubject, +\end_layout + +\begin_layout Plain Layout + somePredicate, +\end_layout + +\begin_layout Plain Layout + someObject, +\end_layout + +\begin_layout Plain Layout + currentTime +\end_layout + +\begin_layout Plain Layout + ) +\end_layout + +\begin_layout Plain Layout + ); +\end_layout + +\begin_layout Plain Layout + // Maybe sleep or do a simulation step +\end_layout + +\begin_layout Plain Layout + } +\end_layout + +\begin_layout Plain Layout + } +\end_layout + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +eigener Thread, also diesbezüglich wachsam bleiben +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Aufgabe: Konstruktion von Quadrupeln + deren Übergabe an die Engine via +\family typewriter +this.put() +\family sans + +\end_layout + +\begin_layout Subsection + +\family sans + +\series bold + +\lang german +StreamGenerator an der Engine registrieren und starten +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Einen StreamGenerator erzeugen (im Konstruktor die IRI für alle generierten Quadrupel), an der Engine registrieren und starten +\begin_inset listings +inline false +status collapsed + +\begin_layout Plain Layout +RdfStream streamGenerator = new StreamGenerator("http://example.org/cars"); +\end_layout + +\begin_layout Plain Layout +engine.registerStream(streamGenerator); +\end_layout + +\begin_layout Plain Layout +final Thread t = new Thread((Runnable) streamGenerator); +\end_layout + +\begin_layout Plain Layout +t.start(); +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Subsection + +\family sans + +\series bold + +\lang german +Query an der Engine registrieren +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Jetzt einen Query an der Engine registrieren; Ergebnis ist ein ResultProxy, an den Observer angeklemmt werden können um die Query-Ergebnisse weiter zu verarbeiten. +\begin_inset listings +inline false +status collapsed + +\begin_layout Plain Layout +String query = "%%% SPARQL QUERY %%%"; +\end_layout + +\begin_layout Plain Layout +CsparqlQueryResultProxy resultProxy = null; +\end_layout + +\begin_layout Plain Layout +try { +\end_layout + +\begin_layout Plain Layout + resultProxy = engine.registerQuery(query, true); +\end_layout + +\begin_layout Plain Layout +} catch (ParseException e1) { +\end_layout + +\begin_layout Plain Layout + // handle exception +\end_layout + +\begin_layout Plain Layout +} +\end_layout + +\begin_layout Plain Layout +// Print results to console +\end_layout + +\begin_layout Plain Layout +resultProxy.addObserver(new ConsoleFormatter()); +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Subsection + +\family sans + +\series bold + +\lang german +Laufen lassen und abwarten +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Der Part ist einfach ;-) Im Main-Thread einfach etwas Thread.sleep() callen und in den am ResultProxy angehangenen Observern die Ergebnisse entsprechend auswerten und weiter verarbeiten. +\end_layout + +\begin_layout Subsection + +\family sans + +\series bold + +\lang german +Engine herunterfahren +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Ab hier läuft das ganze ab, bis es gestoppt wird. Um es abzubauen, wird zunächst der Query deregistriert. +\begin_inset listings +inline false +status collapsed + +\begin_layout Plain Layout +engine.unregisterQuery(resultProxy.getId()); +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +// Jetzt noch den StreamGenerator stoppen und von der Engine abkoppeln, fertig. +\begin_inset listings +inline false +status collapsed + +\begin_layout Plain Layout +((StreamGenerator) streamGenerator).pleaseStop(); +\end_layout + +\begin_layout Plain Layout +engine.unregisterStream(streamGenerator.getIRI()); +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +Einspeisung von Ereignissen +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Ereignisse werden über StreamGenerators eingespeist +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Diese laufen in einem eigenen Thread und schieben Quadrupel (Tripel + Systemzeit) in die Engine rein +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Vor dem Start müssen sie an der Engine registriert werden +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Spezielle Betrachtung der StreamGenerators und wie sie funktionieren, Anmerkungen darüber, dass hier Daten von außen gezogen und ggf. konvertiert werden können. +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +Einspeisung von statischem Hintergrundwissen aus Dateien +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Wie und wo werden Dateien in welchen Formaten abgelegt, müssen sie zuvor in der Engine registriert werden und wie wird im Query darauf zugegriffen? +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +CSPARQL-Queries +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +simpler Zugriff auf Eventdatenstrom +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Zugriff auf mehrere Ereignisströme +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Für jeden Datenstrom ein eigenes Sliding/Tumbling Window +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Aggregation von Ereignissen zu neuen Ereignisströmen +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Kombination von Ereignissen mit lokalem Hintergrundwissen +\end_layout + +\begin_layout Section + +\family sans + +\series bold + +\lang german +Bewertung/Ergebnis +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +(Konnten die gestellten Anforderungen erfüllt werden?) +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Was konnte erreicht werden? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Was konnte nicht erreicht werden? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Gab es Schwierigkeiten? [Guter Zeitpunkt, um hier f:timestamp() vs Tripel mit Literals zu erwähnen] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Wie hoch war der Aufwand? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Wie steht es um die Qualität der Ergebnisse? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Eventuell ein Blick auf die Performance? +\end_layout + +\begin_layout Chapter + +\family sans + +\series bold + +\lang german +Fazit +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Bewertung der Ergebnisse im Abgleich mit den Anforderungen und dem Aufwand? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Ist es für die Anforderungen (und mehr) praxistauglich? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Oder gibt es zur Zeit bessere Alternativen? +\end_layout + +\begin_layout Chapter + +\family sans + +\series bold + +\lang german +Ausblick +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Kann man mit der Engine in Zukunft noch mehr schaffen? +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german +Wie steht es um Reasoning? Geht das? Wenn ja, nur RDFS oder auch OWL? +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +todo{ +\end_layout + +\end_inset + +Ist der Unterschied zwischen den Beiden fürs erste sehr wichtig oder führt das zu weit? +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Vielleicht geht das mit dem Reasoning später ja noch besser — aktueller Stand ist noch limitiert, aber es wird fleißig daran geforscht … +\end_layout + +\begin_layout Chapter* + +\family sans + +\series bold + +\lang german +Dummy-Kapitel für Tests +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\color red +Dieses Kapitel fliegt am Ende natürlich raus. +\color inherit + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Sil-ben ge-trenn-t mit ei-nem Strich +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +C–SPARQL (Zwei Striche ergeben einen Bindestrich) +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Und dann — neben vielen anderen Zeichen — gibt es mit drei Strichen den Gedankenstrich. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Mit +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout + +\backslash +enquote +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +{ +\end_layout + +\end_inset + +enquote +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +} +\end_layout + +\end_inset + + wird Text in Anführungszeichen gesetzt, aber manchmal ist vielleicht der Einsatz von +\family typewriter +texttt +\family sans + sinnvoll. Im +\series bold +Notfall +\series bold + kann auch +\series bold +textbf +\series bold + genutzt werden. Dann gibt es noch +\shape italic +textit +\shape default +, +\shape smallcaps +textsc +\shape default +, +\family sans +textsf +\family sans + und +\shape slanted +textsl +\shape default +. +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german +Quellenreferenzen +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "hsh:cep" + +\end_inset + +[Einstieg in CEP mit Beispielen aus Esper-Welt] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "hsh:integrating" + +\end_inset + +[Esper vs C-SPARQL CEP ohne Reasoning] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "barbieri:reasoning" + +\end_inset + +[Ansatz für Reasoning auf RDF-Strömen mit C-SPARQL] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "barbieri:querying" + +\end_inset + +[Grundlagen C-SPARQL für CEP] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "cqels:stream" + +\end_inset + +[CQELS-Paper] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "ep:etalis" + +\end_inset + +[ETALIS-Paper] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "ep:unified" + +\end_inset + +[EP-SPARQL-Paper] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "man:owl" + +\end_inset + +[Owl Reasoning Examples] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "w3c:sparql" + +\end_inset + +[W3C zu SPARQL] +\end_layout + +\begin_layout Itemize + +\family sans + +\series bold + +\lang german + +\begin_inset CommandInset citation +LatexCommand cite +after "" +key "iao:esper" + +\end_inset + +[Marktübersicht Real-Time Monitoring Software] +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% Referenz auf Bibtex mit Kommentar +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% +\backslash +cite{robbins:gawk}[Siehe ab S.95] +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% Einbinden von Tex-Files +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% +\backslash +input{abkuerz.tex} +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% +\backslash +input{einfuehrung.tex} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% Einbinden von größeren Tex-Files, z.B. Kapiteln +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% +\backslash +include{normen} +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% +\backslash +include{aufbau} +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% +\backslash +include{zitieren} +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% +\backslash +include{form} +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% +\backslash +include{allgtips} +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +%%% Ende inhaltlicher Inhalt! %%% +\end_layout + +\end_inset + + +\end_layout + +\begin_layout Standard + +\family sans + +\series bold + +\lang german + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% Literaturverzeichnis +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset ERT +status collapsed + +\begin_layout Plain Layout +% Schlüssel als Buchstaben +\end_layout + +\begin_layout Plain Layout + +\end_layout + +\end_inset + + +\begin_inset CommandInset bibtex +LatexCommand bibtex +bibfiles "Literaturverweise" +options "alpha" + +\end_inset + + +\end_layout + +\end_body +\end_document diff --git a/Bachelorarbeit.tex b/Bachelorarbeit.tex index 97fdc94..41efc76 100644 --- a/Bachelorarbeit.tex +++ b/Bachelorarbeit.tex @@ -92,7 +92,7 @@ \includegraphics[width=0.2\textwidth]{res/Wortmarke_WI_schwarz.pdf} { ~ \sffamily \vfill - {\Huge\bfseries Verarbeitung von Daten\-strömen im RDF-Format in Kombination mit Hin\-ter\-grund\-wis\-sen in der C-SPARQL-Engine} + {\Huge\bfseries CEP auf RDF-Dateströmen unter Integration von Hin\-ter\-grund\-wis\-sen in der C-SPARQL-Engine} \bigskip {\Large Jan Philipp Timme @@ -117,7 +117,7 @@ & Abteilung Informatik, Fakultät IV \\ & Hochschule Hannover \\ & juergen.dunkel@hs-hannover.de \\[5ex] -{\bfseries\sffamily Zweitprüfer} & Jeremias Dötterl \\ +{\bfseries\sffamily Zweitprüfer} & Jeremias Dötterl, M. Sc. \\ & Abteilung Informatik, Fakultät IV \\ & Hochschule Hannover \\ & jeremias.doetterl@hs-hannover.de @@ -664,6 +664,7 @@ Quellenreferenzen \item \cite{man:owl}[Owl Reasoning Examples] \item \cite{w3c:sparql}[W3C zu SPARQL] \item \cite{iao:esper}[Marktübersicht Real-Time Monitoring Software] +\item \cite{hitzler:semanticweb}[Grundlagen Semantic Web] \end{itemize} % Referenz auf Bibtex mit Kommentar diff --git a/Literaturverweise.bib b/Literaturverweise.bib index 9884198..9fc1587 100644 --- a/Literaturverweise.bib +++ b/Literaturverweise.bib @@ -123,4 +123,13 @@ note = {\url{https://www.w3.org/TR/2014/REC-turtle-20140225/}}, } +@Book{hitzler:semanticweb, + author = {Pascal Hitzler and Markus Krötzsch and Sebastian Rudolph and York Sure}, + title = {Semantic Web}, + year = {2008}, + publisher = {Springer Berlin Heidelberg}, + doi = {10.1007/978-3-540-33994-6}, + url = {http://dx.doi.org/10.1007/978-3-540-33994-6}, +} + @Comment{jabref-meta: databaseType:biblatex;}