[TASK] Generic commit
This commit is contained in:
parent
553991b001
commit
e0f0abd478
|
|
@ -311,6 +311,8 @@ Bei der Modellierung von Wissen mit Hilfe von Beschreibungslogiken, zu denen auc
|
|||
|
||||
\subsection{Abfrage von RDF-Daten via SPARQL}\label{cpt:rdf-sparql}
|
||||
|
||||
\todo{An Beispielszenario annähern und erweitern}
|
||||
|
||||
Die Abfrage von Wissen aus RDF-Daten erfolgt über die Abfragesprache SPARQL (\enquote{SPARQL Protocol And RDF Query Language}), welche in diesem Abschnitt grob erläutert wird. Eine detaillierte Beschreibung von SPARQL ist unter \cite{w3c:sparql} nachzulesen.
|
||||
|
||||
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~\ref{lst:sample_sparql_query} eine einfache Abfrage auf den Daten aus Listing~\ref{lst:sample_rdf_data}.
|
||||
|
|
@ -318,7 +320,7 @@ Im Gegensatz zu Abfragesprachen von relationalen Datenbanksystemen wie SQL ist e
|
|||
\begin{lstlisting}[caption={Abfrage von \dots aus Daten von Listing~\ref{lst:sample_rdf_data}},label={lst:sample_sparql_query}]
|
||||
SELECT ...
|
||||
WHERE {
|
||||
...
|
||||
... TODO ...
|
||||
}
|
||||
\end{lstlisting}
|
||||
|
||||
|
|
@ -330,14 +332,14 @@ Neben \texttt{SELECT} unterstützt SPARQL auch das Schlüsselwort \texttt{CONSTR
|
|||
CONSTRUCT {
|
||||
...
|
||||
} WHERE {
|
||||
...
|
||||
... TODO ...
|
||||
}
|
||||
\end{lstlisting}
|
||||
|
||||
|
||||
\subsection{Schlussfolgerungen auf RDF-Daten}\label{cpt:reasoning}
|
||||
|
||||
\todo{Etwas mehr }
|
||||
\todo{Etwas mehr Inhalt, an Beispielszenario annähern}
|
||||
|
||||
\begin{itemize}
|
||||
\item Was ist Reasoning?
|
||||
|
|
@ -361,7 +363,10 @@ Diesen Vorteil erkauft man sich durch einen nicht unerheblichen Einsatz von Rech
|
|||
|
||||
\section{Einführung in Complex Event Processing}
|
||||
|
||||
\todo{Direkt mit RDF-Datenströmen anfangen, nächste Section mit dieser zusammenführen!}
|
||||
|
||||
\todo{Nun wollen wir auf Datenströmen im RDF-Format CEP fahren. Was genau bedeutet das eigentlich und wie sieht das in der Theorie aus?}
|
||||
\todo{An Beispielszenario deutlich annähern, Konzept von CEP soll hier rein, allerdings noch nicht die Details}
|
||||
|
||||
\begin{itemize}
|
||||
\item Definition von CEP
|
||||
|
|
@ -392,6 +397,8 @@ Insgesamt liegt die Herausforderung von CEP darin, in kürzester Zeit große Dat
|
|||
|
||||
\subsection{Ereignisse als RDF-Datenstrom}
|
||||
|
||||
\todo{Generelles dazu, wie RDF-Ereignisdatenströme aussehen und w}
|
||||
|
||||
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 \enquote{CSPARQL} --- 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 \enquote{Sliding Windows} 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.
|
||||
|
||||
|
|
@ -407,6 +414,8 @@ http://example.org/cars/event#1468064960110 http://example.org/cars#currentSpeed
|
|||
|
||||
\subsection{SPARQL-Erweiterung zur Verarbeitung von RDF-Datenströmen}
|
||||
|
||||
\todo{Grobes Konzept: CSPARQL als erweiterte Form von SPARQL für die Verwendung mit RDF-Datenströmen.}
|
||||
|
||||
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~\ref{lst:sample_combine_events_sparql} zeigt einen SPARQL-Query, in dem zwei aufeinanderfolgende Ereignisse mit Angaben zur Momentangeschwindigkeit eines Autos zu einem komplexeren Beschleunigungsereignis kombiniert werden.
|
||||
|
||||
|
|
@ -430,7 +439,7 @@ WHERE {
|
|||
}
|
||||
\end{lstlisting}
|
||||
|
||||
\todo{Streaming-Erweiterungen aus dem Listiung ein wenig hervorheben}
|
||||
\todo{Streaming-Erweiterungen aus dem Listing ein wenig hervorheben, damit verbundene Schlüsselwörter hervorheben und Begriffe klären (Sliding Window, Timestamps, Range und Step, \dots}
|
||||
|
||||
|
||||
\chapter{Vergleich von CEP-Engines für RDF-Datenströme}
|
||||
|
|
@ -449,25 +458,6 @@ Grobe Eckpunkte zur Orientierung:
|
|||
\end{itemize}
|
||||
|
||||
|
||||
\section*{Anforderungen an CEP-Engines}
|
||||
|
||||
\todo{Die Section raus; Es sind mehr Kriterien/Features als Anforderungen, mal sehen was damit geschehen wird.}
|
||||
|
||||
\begin{itemize}
|
||||
\item Verarbeitung von mehreren Ereignisströmen
|
||||
\item Verknüpfung von Ereignissen
|
||||
\item Konstruktion neuer Ereignisse
|
||||
\item Sliding/Tumbling Windows
|
||||
\item Mustererkennung (Abfolge, Präsenz/Absenz von Ereignissen [zeitlicher Abstand])
|
||||
\item \enquote{COMPUTE EVERY} (Neuberechnung in festen Intervallen)
|
||||
\item Ausführen von benutzerdefiniertem Code
|
||||
\item Integration von Hintergrundwissen [aus weiteren Quellen]
|
||||
\item Aggregationsfunktionen über mehrere Ereignisse (Sum, Avg, ...)
|
||||
\item Vergleichsoperatoren für Selektionskriterien
|
||||
\item Bonuspunkte: Reasoning (Logikoperationen und Schlussfolgerungen)
|
||||
\end{itemize}
|
||||
|
||||
|
||||
\section{EP-SPARQL}
|
||||
|
||||
\begin{itemize}
|
||||
|
|
@ -528,6 +518,8 @@ In diesem Kapitel werden abstrakte Condition-Action-Regeln für das Beispielszen
|
|||
|
||||
\section{Resoning auf RDF-Datenströmen?}
|
||||
|
||||
\todo{FALLS ich Reasoning rechtzeitig unterbringe, werde ich hier erläutern, welche Fähigkeiten (RDFS-Reasoning) ich nutzen will, um bestimmte Dinge in meinem Szenario zu optimieren/zu vereinfachen oder einfach um es mal zu demonstrieren. Die Erläuterung von Reasoning selbst wurde in dem Grundlagen-Kapitel bereits erledigt.}
|
||||
|
||||
\begin{itemize}
|
||||
\item Immer noch ein Forschungsgebiet
|
||||
\item sehr hoher Datendurchsatz (viele kleine Ereignisse in geringem Zeitraum)
|
||||
|
|
@ -542,7 +534,7 @@ In diesem Kapitel werden abstrakte Condition-Action-Regeln für das Beispielszen
|
|||
|
||||
\todo{Zusammenfassungsüberleitung über das Kapitel}
|
||||
|
||||
\todo{In diesem Kapitel wird die Engine konkret ausgepackt und mit Java-Code benutzt. Es werden Datenstromgeneratoren gezeigt, Queries registriert und und und und dann vielleicht etwas Reasoning eingeschaltet.}
|
||||
\todo{In diesem Kapitel wird die Engine konkret ausgepackt und mit Java-Code benutzt. Es werden Datenstromgeneratoren gezeigt, Queries registriert und vielleicht etwas Reasoning eingeschaltet und dessen Ergebnisse begutachtet.}
|
||||
|
||||
In diesem Kapitel wird die C-SPARQL-Engine konkret vorgestellt und verwendet.
|
||||
\begin{itemize}
|
||||
|
|
@ -557,130 +549,20 @@ In diesem Kapitel wird die C-SPARQL-Engine konkret vorgestellt und verwendet.
|
|||
|
||||
\section{Nutzung der C-SPARQL Engine in Java}
|
||||
|
||||
Im Folgenden wird auf die praktische Anwendung der C-SPARQL-Engine in einem Java-Projekt eingegangen.
|
||||
|
||||
|
||||
\subsection{Initialisieren der Engine}
|
||||
|
||||
Erst einmal die Instanz der Engine erzeugen und initialisieren (mit true, damit f:timestamp zur Verfügung steht).
|
||||
\begin{lstlisting}
|
||||
CsparqlEngine engine = new CsparqlEngineImpl();
|
||||
engine.initialize(true);
|
||||
\end{lstlisting}
|
||||
|
||||
|
||||
\subsection{Stream-Generatoren}
|
||||
|
||||
Über den StreamGenerator muss ich etwas mehr erzählen, hier mal der grobe Code:
|
||||
\begin{lstlisting}
|
||||
public class StreamGenerator extends RdfStream implements Runnable {
|
||||
private volatile boolean keepRunning = false;
|
||||
|
||||
public StreamGenerator(String iri) {
|
||||
super(iri);
|
||||
}
|
||||
|
||||
public void pleaseStop() {
|
||||
keepRunning = false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
this.keepRunning = true;
|
||||
while (this.keepRunning) {
|
||||
long currentTime = System.currentTimeMillis();
|
||||
// Generate RdfQuadruple from data and hand it over to the engine
|
||||
this.put(new RdfQuadruple(
|
||||
someSubject,
|
||||
somePredicate,
|
||||
someObject,
|
||||
currentTime
|
||||
)
|
||||
);
|
||||
// Maybe sleep or do a simulation step
|
||||
}
|
||||
}
|
||||
}
|
||||
\end{lstlisting}
|
||||
\todo{TBD}
|
||||
Im Folgenden wird auf die praktische Anwendung der C-SPARQL-Engine in einem Java-Projekt eingegangen.
|
||||
|
||||
\begin{itemize}
|
||||
\item eigener Thread, also diesbezüglich wachsam bleiben
|
||||
\item Aufgabe: Konstruktion von Quadrupeln + deren Übergabe an die Engine via \texttt{this.put()}
|
||||
\item Welche technischen Strukturen sieht die Engine vor,
|
||||
\item wie werden Datenströme zugeführt,
|
||||
\item wie werden Queries erzeugt, registriert und beobachtet,
|
||||
\item was muss dabei beachtet werden, welche Fallstricke gibt es (zur Zeit)
|
||||
\item wie wird Hintergrundwissen eingespeist und zur Laufzeit aktualisiert,
|
||||
\item welche Schritte sind nötig um RDFS-Reasoning zu nutzen?
|
||||
\item Und natürlich immer wieder mittendrin: Wie sehen die Ergebnisse aus, die dabei entstehen?
|
||||
\end{itemize}
|
||||
|
||||
|
||||
\subsection{StreamGenerator an der Engine registrieren und starten}
|
||||
|
||||
Einen StreamGenerator erzeugen (im Konstruktor die IRI für alle generierten Quadrupel), an der Engine registrieren und starten
|
||||
\begin{lstlisting}
|
||||
RdfStream streamGenerator = new StreamGenerator("http://example.org/cars");
|
||||
engine.registerStream(streamGenerator);
|
||||
final Thread t = new Thread((Runnable) streamGenerator);
|
||||
t.start();
|
||||
\end{lstlisting}
|
||||
|
||||
|
||||
\subsection{Query an der Engine registrieren}
|
||||
|
||||
|
||||
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{lstlisting}
|
||||
String query = "%%% SPARQL QUERY %%%";
|
||||
CsparqlQueryResultProxy resultProxy = null;
|
||||
try {
|
||||
resultProxy = engine.registerQuery(query, true);
|
||||
} catch (ParseException e1) {
|
||||
// handle exception
|
||||
}
|
||||
// Print results to console
|
||||
resultProxy.addObserver(new ConsoleFormatter());
|
||||
\end{lstlisting}
|
||||
|
||||
|
||||
\subsection{Laufen lassen und abwarten}
|
||||
|
||||
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.
|
||||
|
||||
|
||||
\subsection{Engine herunterfahren}
|
||||
|
||||
Ab hier läuft das ganze ab, bis es gestoppt wird. Um es abzubauen, wird zunächst der Query deregistriert.
|
||||
\begin{lstlisting}
|
||||
engine.unregisterQuery(resultProxy.getId());
|
||||
\end{lstlisting}
|
||||
|
||||
// Jetzt noch den StreamGenerator stoppen und von der Engine abkoppeln, fertig.
|
||||
\begin{lstlisting}
|
||||
((StreamGenerator) streamGenerator).pleaseStop();
|
||||
engine.unregisterStream(streamGenerator.getIRI());
|
||||
\end{lstlisting}
|
||||
|
||||
|
||||
\section{Einspeisung von Ereignissen}
|
||||
|
||||
\begin{itemize}
|
||||
\item Ereignisse werden über StreamGenerators eingespeist
|
||||
\item Diese laufen in einem eigenen Thread und schieben Quadrupel (Tripel + Systemzeit) in die Engine rein
|
||||
\item Vor dem Start müssen sie an der Engine registriert werden
|
||||
\end{itemize}
|
||||
|
||||
Spezielle Betrachtung der StreamGenerators und wie sie funktionieren, Anmerkungen darüber, dass hier Daten von außen gezogen und ggf. konvertiert werden können.
|
||||
|
||||
|
||||
\section{Einspeisung von statischem Hintergrundwissen aus Dateien}
|
||||
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?
|
||||
|
||||
|
||||
\section{CSPARQL-Queries}
|
||||
|
||||
\begin{itemize}
|
||||
\item simpler Zugriff auf Eventdatenstrom
|
||||
\item Zugriff auf mehrere Ereignisströme
|
||||
\item Für jeden Datenstrom ein eigenes Sliding/Tumbling Window
|
||||
\item Aggregation von Ereignissen zu neuen Ereignisströmen
|
||||
\item Integration von lokalem Hintergrundwissen in Ereignisdaten
|
||||
\end{itemize}
|
||||
\todo{Die einzelnen Sections entstehen beim Schreiben der Texte.}
|
||||
|
||||
|
||||
\section{Bewertung/Ergebnis}
|
||||
|
|
@ -709,8 +591,7 @@ Wie und wo werden Dateien in welchen Formaten abgelegt, müssen sie zuvor in der
|
|||
|
||||
\chapter{Ausblick}
|
||||
|
||||
\todo{Eventuell mit Ausblick mergen}
|
||||
|
||||
\todo{Eventuell mit Fazit zusammenführen, wenn es nicht zu groß wird.}
|
||||
|
||||
\begin{itemize}
|
||||
\item Kann man mit der Engine in Zukunft noch mehr schaffen?
|
||||
|
|
@ -719,7 +600,26 @@ Wie und wo werden Dateien in welchen Formaten abgelegt, müssen sie zuvor in der
|
|||
|
||||
Vielleicht geht das mit dem Reasoning später ja noch besser --- aktueller Stand ist noch limitiert, aber es wird fleißig daran geforscht \dots
|
||||
|
||||
\chapter*{Dummy-Kapitel für Tests}
|
||||
|
||||
|
||||
\chapter*{Dummy-Kapitel für Tests und Notizen}
|
||||
|
||||
\todo{Spätestens vor dem Druck muss dieses Kapitel raus aus dem Dokument.}
|
||||
|
||||
Fähigkeitenliste, die auf C-SPARQL-Engine zutrifft. Eventuell für den Vergleich von CEP-Engines hier mal gucken, was davon relevant und interessant ist.
|
||||
\begin{itemize}
|
||||
\item Verarbeitung von mehreren Ereignisströmen
|
||||
\item Verknüpfung von Ereignissen
|
||||
\item Konstruktion neuer Ereignisse
|
||||
\item Sliding/Tumbling Windows
|
||||
\item Mustererkennung (Abfolge, Präsenz/Absenz von Ereignissen [zeitlicher Abstand])
|
||||
\item \enquote{COMPUTE EVERY} (Neuberechnung in festen Intervallen)
|
||||
\item Ausführen von benutzerdefiniertem Code
|
||||
\item Integration von Hintergrundwissen [aus weiteren Quellen]
|
||||
\item Aggregationsfunktionen über mehrere Ereignisse (Sum, Avg, ...)
|
||||
\item Vergleichsoperatoren für Selektionskriterien
|
||||
\item Bonuspunkte: Reasoning (Logikoperationen und Schlussfolgerungen)
|
||||
\end{itemize}
|
||||
|
||||
\textcolor{red}{Dieses Kapitel fliegt am Ende natürlich raus.}
|
||||
|
||||
|
|
@ -731,7 +631,6 @@ Und dann --- neben vielen anderen Zeichen --- gibt es mit drei Strichen den Geda
|
|||
|
||||
Mit \enquote{enquote} wird Text in Anführungszeichen gesetzt, aber manchmal ist vielleicht der Einsatz von \texttt{texttt} sinnvoll. Im \textbf{Notfall} kann auch \textbf{textbf} genutzt werden. Dann gibt es noch \textit{textit}, \textsc{textsc}, \textsf{textsf} und \textsl{textsl}.
|
||||
|
||||
|
||||
Quellenreferenzen
|
||||
\begin{itemize}
|
||||
\item \cite{hsh:cep}[Einstieg in CEP mit Beispielen aus Esper-Welt]
|
||||
|
|
@ -748,6 +647,18 @@ Quellenreferenzen
|
|||
\item \cite{hitzler:semanticweb}[Grundlagen Semantic Web]
|
||||
\end{itemize}
|
||||
|
||||
|
||||
%%% Ende inhaltlicher Inhalt! %%%
|
||||
|
||||
% Literaturverzeichnis
|
||||
% Schlüssel als Buchstaben
|
||||
\bibliographystyle{alpha}
|
||||
\bibliography{Literaturverweise}
|
||||
|
||||
\end{document}
|
||||
% Nothing beyond this line!
|
||||
|
||||
|
||||
% Referenz auf Bibtex mit Kommentar
|
||||
% \cite{robbins:gawk}[Siehe ab S.95]
|
||||
|
||||
|
|
@ -761,13 +672,3 @@ Quellenreferenzen
|
|||
%\include{zitieren}
|
||||
%\include{form}
|
||||
%\include{allgtips}
|
||||
|
||||
%%% Ende inhaltlicher Inhalt! %%%
|
||||
|
||||
% Literaturverzeichnis
|
||||
% Schlüssel als Buchstaben
|
||||
\bibliographystyle{alpha}
|
||||
\bibliography{Literaturverweise}
|
||||
|
||||
\end{document}
|
||||
% Nothing beyond this line!
|
||||
|
|
|
|||
Loading…
Reference in New Issue