diff --git a/documents/DYCOS/Abgrenzung.tex b/documents/DYCOS/Abgrenzung.tex index 79b10d5..16aaf7b 100644 --- a/documents/DYCOS/Abgrenzung.tex +++ b/documents/DYCOS/Abgrenzung.tex @@ -4,5 +4,8 @@ Es gibt jedoch viele Klassifizierungsalgorithmen, die ähnliche Ideen nutzen. Einige dieser Algorithmen werden im Folgenden kurz vorgestellt und Probleme, die der DYCOS-Algorithmus behebt, erläutert. +\cite{DBLP:conf/kdd/BhagatCR07} nutzt nur die Struktur des Graphen +zur Klassifizierung. + Der MUCCA-Algorithmus aus \cite{zappella} sei der erste. Dieser arbeitet auf gewichteten Graphen, im Gegensatz zu DYCOS. diff --git a/documents/DYCOS/Ausblick.tex b/documents/DYCOS/Ausblick.tex index a5ee46a..cd3b14a 100644 --- a/documents/DYCOS/Ausblick.tex +++ b/documents/DYCOS/Ausblick.tex @@ -15,3 +15,6 @@ in dem politische Parteiaffinität von einigen Mitgliedern angegeben wird um die Parteiaffinität der restlichen Mitglieder zu bestimmen. In diesem Fall macht es jedoch einen wichtigen Unterschied, ob jemand über eine Partei gutes oder schlechtes schreibt. + +Eine einfache Erweiterung des DYCOS-Algorithmus wäre der Umgang mit +mehreren Labels. diff --git a/documents/DYCOS/DYCOS-Algorithmus.tex b/documents/DYCOS/DYCOS-Algorithmus.tex index c93eb27..e3fb0de 100644 --- a/documents/DYCOS/DYCOS-Algorithmus.tex +++ b/documents/DYCOS/DYCOS-Algorithmus.tex @@ -1,29 +1,75 @@ +\subsection{Überblick} DYCOS (\underline{DY}namic \underline{C}lassification algorithm with c\underline{O}ntent and \underline{S}tructure) ist ein Knotenklassifizierungsalgorithmus, der Ursprünglich in \cite{aggarwal2011} vorgestellt -wurde. +wurde. Er klassifiziert Knoten, indem mehrfach Random Walks startend +bei dem zu klassifizierenden Knoten gemacht werden und die Labels +der besuchten Knoten gezählt werden. Der DYCOS-Algorithmus nimmt +jedoch nicht einfach den Graphen für dieses Verfahren, sondern +eine Erweiterung. -Sie im Folgenden die Notation wie in Definition~\ref{def:Knotenklassifizierungsproblem}. +Für diese Erweiterung wird zuerst wird Vokabular $W_t$ bestimmt, das +charakteristisch für eine Knotengruppe ist. Wie das gemacht werden kann, wird in +Abschnitt~\ref{sec:vokabularbestimmung} erläutert. Dann wird für +jedes Wort im Vokabular ein Wortknoten zum Graphen hinzugefügt. +Ein Strukturknoten $v$ wird genau dann mit einem Wortknoten $w \in W_t$ +verbunden, wenn $w$ in einem Text von $v$ vorkommt. -Der DYCOS-Algorithmus betrachtet Texte als eine Menge von Wörter, -die Reihenfolge der Wörter im Text spielt also keine Rolle. Außerdem -werden nicht alle Wörter benutzt, sondern nur solche die auch in -einem festgelegtem Vokabular vorkommen. Wie dieses Vokabular bestimmt -werden kann, wird in Abschnitt~\ref{sec:vokabularbestimmung} erklärt. +\begin{figure}[htp] + \centering + \input{figures/graph-content-and-structure.tex} + \caption{Erweiterter Graph} + \label{fig:erweiterter-graph} +\end{figure} -Zusätzlich zu dem Netzwerk verwalltet der DYCOS-Algorithmus für jeden -Knoten eine Liste von Wörtern. Diese Wörter stammen aus den Texten, -die dem Knoten zugeordnet sind. +Der DYCOS-Algorithmus betrachtet die Texte, die zu einem Knoten +zugeornet sind, als eine +Multimenge von Wörtern. Das heißt, zum einen wird nicht auf die +Reihenfolge der Wörter geachtet, zum anderen wird bei Texten +eines Knotens nicht zwischen verschiedenen Texten unterschieden. +Jedoch wird die Anzahl der vorkommen jedes Wortes berücksichtigt. -Für jedes Wort des Vokabulars wird eine Liste von Knoten verwaltet, -in deren Texten das Wort vorkommt. +\subsection{Datenstrukturen} +Zusätzlich zu dem gerichteten Graphen $G_t = (V_t, E_t, V_{L,t})$ +verwaltet der DYCOS-Algorithmus zwei weitere Datenstrukturen: +\begin{itemize} + \item Für jeden Knoten $v \in V_t$ werden die vorkommenden Wörter + und deren Anzahl gespeichert. Das könnte z.~B. über ein + assoziatives Array geschehen. Wörter, die nicht in + Texten von $v$ vorkommen, sind nicht im Array. Für + alle vorkommenden Wörter ist der gespeicherte Wert zum + Schlüssel \enquote{Wort} die Anzahl der Vorkommen von + \enquote{Wort} in den Texten von $v$. + \item Für jedes Wort des Vokabulars $W_t$ wird eine Liste von + Knoten verwaltet, in deren Texten das Wort vorkommt. +\end{itemize} -Ein $l$-Sprung ist ein ein Random Walk, bei dem $l$ -Knoten besucht werden, die nicht verschieden sein müssen. Ein -$l$-Sprung heißt strukturell, wenn er ausschließlich die Kanten -des Netzwerks für jeden der $l$ Schritte benutzt. +\subsection{Algorithmen} +Bevor der Algorithmus formal beschrieben wird, wird eine Definition +des strukturellen $l$-Sprungs benötigt: +\begin{definition} + Sei $G_{E,t} = (V_t, E_{S,t} \cup E_{W,t}, V_{L,t}, W_{t})$ der + um die Wortknoten $W_{t}$ erweiterte Graph. -Ein $l$-Sprung heißt inhaltlich, wenn er die Wörter benutzt. + Dann heißt ein Random Walk der Länge $l$ in diesem Graphen + ein \textbf{struktureller $l$-Sprung}, wenn für den Random Walk + nur Kanten aus $E_{S,t}$ benutzt werden. +\end{definition} + +Der strukturelle $l$-Sprung ist also ein Random Walk der Länge $l$ +im Graph $G_t$. Im Gegensatz dazu benötigt der inhaltliche $l$-Multisprung +tatsächlich die Grapherweiterung: + +\begin{definition} + Sei $G_t = (V_t, E_{S,t} \cup E_{W,t}, V_{L,t}, W_{t})$ der + um die Wortknoten $W_{t}$ erweiterte Graph. + + Dann heißt ein Random Walk der Länge $l$ in diesem Graphen + ein \textbf{inhaltlicher $l$-Multisprung}, wenn für den Random Walk + in jedem der $l$ Schritte, startend von einem Knoten $v \in V_t$ + eine Kante zu einem Wortknoten und von dem Wortknoten wieder + zu einem Strukturknoten genommen wird. +\end{definition} \begin{algorithm}[H] \begin{algorithmic} diff --git a/documents/DYCOS/DYCOS.tex b/documents/DYCOS/DYCOS.tex index 7fd9268..0e86613 100644 --- a/documents/DYCOS/DYCOS.tex +++ b/documents/DYCOS/DYCOS.tex @@ -54,12 +54,15 @@ \section{Einleitung} \input{Einleitung} -\section{Abgrenzung} -\input{Abgrenzung} - \section{DYCOS} \input{DYCOS-Algorithmus} +\section{Experimentelle Analyse}\label{sec:experimentelle-analyse} +\input{Experimentelle-Analyse} + +\section{Abgrenzung} +\input{Abgrenzung} + \section{Ausblick} \input{Ausblick} diff --git a/documents/DYCOS/Einleitung.tex b/documents/DYCOS/Einleitung.tex index 6847f48..e2c9fe9 100644 --- a/documents/DYCOS/Einleitung.tex +++ b/documents/DYCOS/Einleitung.tex @@ -4,43 +4,35 @@ mit Publikationen als Knoten, Literaturverweisen und Zitaten als Kanten sowie Tags oder Kategorien als Labels; Wikipedia mit Artikeln als Knoten, Links als Kanten und Kategorien als Labels sowie soziale Netzwerke mit Eigenschaften der Benutzer -sind drei Beispiele dafür. -Da Labels nur teilweise vorhanden sind, ist es wünschenswert die +als Labels sind drei Beispiele dafür. +Häufig sind Labels nur teilweise vorhanden und es ist wünschenswert die fehlenden Labels zu ergänzen. \subsection{Problemstellung} -Das Knotenklassifierungsproblem sei wie folgt definiert:\\ +Wir haben einen Graphen, der teilweise gelabelt ist. Zustäzlich haben +wir zu einer Teilmenge der Knoten Texte. Gesucht sind nun Labels +für alle Knoten, die bisher noch nicht gelabelt sind.\\ \begin{definition}[Knotenklassifierungsproblem]\label{def:Knotenklassifizierungsproblem} - Sei $\G_t = (\N_t, \A_t, \T_t)$ ein Netzwerk, - wobei $\N_t$ die Menge aller Knoten, - $\A_t$ die Kantenmenge und $\T_t \subseteq \N_t$ die Menge der + Sei $G_t = (V_t, E_t, V_{L,t})$ ein gerichteter Graph, + wobei $V_t$ die Menge aller Knoten, + $E_t$ die Kantenmenge und $V_{L,t} \subseteq V_t$ die Menge der gelabelten Knoten jeweils zum Zeitpunkt $t$ bezeichne. - Außerdem sei $\L_t$ die Menge aller zum Zeitpunkt $t$ vergebenen - Labels und $f:\T_t \rightarrow \L_t$ die Funktion, die einen + Außerdem sei $L_t$ die Menge aller zum Zeitpunkt $t$ vergebenen + Labels und $f:V_{L,t} \rightarrow L_t$ die Funktion, die einen Knoten auf sein Label abbildet. - Gesucht sind nun Labels für $\N_t \setminus \T_t$, also - $\tilde{f}:\N_t \rightarrow \L_t$ mit - $\tilde{f}|_{\T_t} = f$. + Weiter sei für jeden Knoten $v \in V$ eine (eventuell leere) + Textmenge gegeben. + + Gesucht sind nun Labels für $V_t \setminus V_{L,t}$, also + $\tilde{f}: V_t \rightarrow L_t$ mit + $\tilde{f}|_{V_{L,t}} = f$. \end{definition} -Wir haben häufig zusätzlich zu dem Graphen $\G_t$ und der Label-Funktion -$f$ aus Definition~\ref{def:Knotenklassifizierungsproblem} noch -textuelle Inhalte, die Knoten zugeornet werden. - - \subsection{Herausforderungen} -Die beispielhaft aufgeführen Netzwerke sind viele -$\num{10000}$~Knoten groß und dynamisch. Das bedeutet, es kommen -neue Knoten und eventuell auch neue Kanten hinzu bzw. Kanten oder -Knoten werden entfernt. Außerdem stehen textuelle Inhalte zu den +Die in Kapitel~\ref{sec:experimentelle-analyse} aufgeführen Netzwerke +sind viele $\num{10000}$~Knoten groß und dynamisch. Das bedeutet, es +kommen neue Knoten und eventuell auch neue Kanten hinzu bzw. Kanten +oder Knoten werden entfernt. Außerdem stehen textuelle Inhalte zu den Knoten bereit, die bei der Klassifikation genutzt werden können. - -Der DYCOS-Algorithmus nutzt diese und kann auf große, dynamische -Netzwerken angewandt werden. - -Der DYCOS-Algorithmus nutzt Random Walks im Graphen, startend -von dem zu klassifizierenden Knoten $n$. Dabei wird pro Random Walk -gezählt, welche Klasse $K$ am häufigsten gesehen wird. Der Knoten $n$ -wird dann als zu $K$ zugehörig klassifiziert. diff --git a/documents/DYCOS/Experimentelle-Analyse.tex b/documents/DYCOS/Experimentelle-Analyse.tex new file mode 100644 index 0000000..16c392d --- /dev/null +++ b/documents/DYCOS/Experimentelle-Analyse.tex @@ -0,0 +1 @@ +Wikipedia diff --git a/documents/DYCOS/abstract.tex b/documents/DYCOS/abstract.tex index d438e70..8bc7715 100644 --- a/documents/DYCOS/abstract.tex +++ b/documents/DYCOS/abstract.tex @@ -1,8 +1,8 @@ In dieser Arbeit wird der DYCOS-Algorithmus vorgestellt. Er klassifiziert automatisch Knoten in Netzwerken, die bereits teilweise gelabelt sind. Zur Klassifizierung kann er textuelle -Informationen, die den Knoten zugeordnet sind, nutzen. Auch ist -er für für viele $\num{10000}$ Knoten große, dynamische Netzwerke +Informationen, die den Knoten zugeordnet sind, nutzen. Er ist +auch für für viele $\num{10000}$ Knoten große, dynamische Netzwerke geeignet.\\ \textbf{Keywords:} DYCOS, Label Propagation, Knotenklassifizierung diff --git a/documents/DYCOS/figures/graph-content-and-structure.tex b/documents/DYCOS/figures/graph-content-and-structure.tex new file mode 100644 index 0000000..c8e806b --- /dev/null +++ b/documents/DYCOS/figures/graph-content-and-structure.tex @@ -0,0 +1,37 @@ +\tikzstyle{vertex}=[draw,black,circle,minimum size=10pt,inner sep=0pt] +\tikzstyle{edge}=[very thick] +\begin{tikzpicture}[scale=1.3] + \node (a)[vertex] at (0,0) {}; + \node (b)[vertex] at (0,1) {}; + \node (c)[vertex] at (0,2) {}; + \node (d)[vertex] at (1,0) {}; + \node (e)[vertex] at (1,1) {}; + \node (f)[vertex] at (1,2) {}; + \node (g)[vertex] at (2,0) {}; + \node (h)[vertex] at (2,1) {}; + \node (i)[vertex] at (2,2) {}; + + \node (x)[vertex] at (4,0) {}; + \node (y)[vertex] at (4,1) {}; + \node (z)[vertex] at (4,2) {}; + + \draw[edge] (a) -- (d); + \draw[edge] (b) -- (d); + \draw[edge] (b) -- (c); + \draw[edge] (c) -- (d); + \draw[edge] (d) -- (e); + \draw[edge] (d) edge[bend left] (f); + \draw[edge] (d) edge[bend right] (x); + \draw[edge] (g) edge (x); + \draw[edge] (h) edge (x); + \draw[edge] (h) edge (y); + \draw[edge] (h) edge (e); + \draw[edge] (e) edge (z); + \draw[edge] (i) edge (y); + + \draw [dashed] (-0.3,-0.3) rectangle (2.3,2.3); + \draw [dashed] (2.5,2.3) rectangle (5, -0.3); + + \node (struktur)[label={[label distance=0cm]0:Sturkturknoten $V_t$}] at (-0.1,2.5) {}; + \node (struktur)[label={[label distance=0cm]0:Wortknoten $W_t$}] at (2.7,2.5) {}; +\end{tikzpicture} diff --git a/documents/DYCOS/literatur.bib b/documents/DYCOS/literatur.bib index cace903..9c90bf9 100644 --- a/documents/DYCOS/literatur.bib +++ b/documents/DYCOS/literatur.bib @@ -36,3 +36,39 @@ ee = {http://dx.doi.org/10.1007/978-1-4419-6045-0}, bibsource = {DBLP, http://dblp.uni-trier.de} } + +@inproceedings{DBLP:conf/kdd/BhagatCR07, + author = {Smriti Bhagat and + Graham Cormode and + Irina Rozenbaum}, + title = {Applying Link-Based Classification to Label Blogs}, + booktitle = {WebKDD/SNA-KDD}, + year = {2007}, + pages = {97-117}, + ee = {http://dx.doi.org/10.1007/978-3-642-00528-2_6}, + crossref = {DBLP:conf/kdd/2007web}, + bibsource = {DBLP, http://dblp.uni-trier.de} +} +@proceedings{DBLP:conf/kdd/2007web, + editor = {Haizheng Zhang and + Myra Spiliopoulou and + Bamshad Mobasher and + C. Lee Giles and + Andrew McCallum and + Olfa Nasraoui and + Jaideep Srivastava and + John Yen}, + title = {Advances in Web Mining and Web Usage Analysis, 9th International + Workshop on Knowledge Discovery on the Web, WebKDD 2007, + and 1st International Workshop on Social Networks Analysis, + SNA-KDD 2007, San Jose, CA, USA, August 12-15, 2007. Revised + Papers}, + booktitle = {WebKDD/SNA-KDD}, + publisher = {Springer}, + series = {Lecture Notes in Computer Science}, + volume = {5439}, + year = {2009}, + isbn = {978-3-642-00527-5}, + ee = {http://dx.doi.org/10.1007/978-3-642-00528-2}, + bibsource = {DBLP, http://dblp.uni-trier.de} +} diff --git a/documents/DYCOS/mystyle.sty b/documents/DYCOS/mystyle.sty index b4c7c67..360addc 100644 --- a/documents/DYCOS/mystyle.sty +++ b/documents/DYCOS/mystyle.sty @@ -10,6 +10,8 @@ \DeclareUnicodeCharacter{00A0}{~} \theoremstyle{definition} +\theoremindent20pt +\theoremheaderfont{\normalfont\bfseries\hspace{-\theoremindent}} \renewtheorem{definition}{Definition} \def\A{\ensuremath{\mathcal{A}}}