TODOs entfernt; Abschnitt 'Schwächen' hinzugefügt; Nun wird nur noch der DYCOS-Algorithmus aus dem Paper beschrieben; Struktur verändert; Abschnitt über Analyse entfernt

documents/DYCOS/Abgrenzung.tex

@@ -1,4 +1,4 @@
-Der in diesem Artikel vorgestellte DYCOS-Algorithmus wurde 2011 von
+Der in dieser Ausarbeitung vorgestellte DYCOS-Algorithmus wurde 2011 von
 Charu~C. Aggarwal und Nan~Li in \cite{aggarwal2011} vorgestellt.
 Es gibt jedoch viele Klassifizierungsalgorithmen, die ähnliche Ideen
 nutzen. Einige dieser Algorithmen werden im Folgenden kurz vorgestellt

documents/DYCOS/Ausblick.tex

@@ -1,13 +1,13 @@
 Den sehr einfach aufgebauten DYCOS-Algorithmus kann man noch an
 vielen Punkten verbessern. So könnte man vor der Auswahl des
 Vokabulars jedes Wort auf den Wortstamm zurückführen.
-Dafür könnte zum Beispiel der \todo{Wo steht was über den?}{Porter-Stemming-Algorithmus} verwendet 
+Dafür könnte zum Beispiel der Porter-Stemming-Algorithmus verwendet 
-werden. Durch diese Maßnahme wird das
+werden \cite{porter}. Durch diese Maßnahme wird das
 Vokabular kleiner gehalten, mehr Artikel können mit einander
 durch Vokabular verbunden werden und der Gini-Koeffizient wird ein
 besseres Maß für die Gleichheit von Texten.
 
-Eine weitere Verbesserungsmöglichkeit besteht in der textanalyse.
+Eine weitere Verbesserungsmöglichkeit besteht in der Textanalyse.
 Momentan ist diese noch sehr einfach gestrickt und ignoriert die
 Reihenfolge von Wortern beziehungsweise Wertungen davon. So könnte
 man den DYCOS-Algorithmus in einem sozialem Netzwerk verwenden wollen,

documents/DYCOS/DYCOS-Algorithmus.tex

@@ -5,7 +5,11 @@ Knotenklassifizierungsalgorithmus, der Ursprünglich in \cite{aggarwal2011} vorg
 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. Das Label, das am häufigsten
-vorgekommen ist, wird zur Klassifizierung verwendet.
+vorgekommen ist, wird als Label gewählt.
+DYCOS nutzt also die sog. Homophilie, d.~h. die Eigenschaft, dass
+Knoten, die nur wenige Hops von einander entfernt sind, häufig auch
+ähnlich sind \cite{bhagat}.
+
 Der DYCOS-Algorithmus nimmt jedoch nicht einfach den Graphen für 
 dieses Verfahren, sondern erweitert ihn mit Hilfe der zur Verfügung
 stehenden Texte.
@@ -28,6 +32,32 @@ verbunden, wenn $w$ in einem Text von $v$ vorkommt.
     \label{fig:erweiterter-graph}
 \end{figure}
 
+Entsprechend werden zwei unterschiedliche Sprungtypen unterschieden,
+die strukturellen Sprünge und inhaltliche Mehrfachsprünge:
+
+\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.
+
+    Dann heißt das zufällige wechseln des aktuell betrachteten
+    Knoten $v \in V_t$ zu einem benachbartem Knoten $w \in V_t$
+    ein \textbf{struktureller Sprung}.
+\end{definition}
+
+Im Gegensatz dazu benutzten inhaltliche Mehrfachsprünge
+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 das zufällige wechseln des aktuell betrachteten
+    Knoten $v \in V_t$ zu einem benachbartem Knoten $w \in W_t$
+    und weiter zu Nachbar von $v' \in V_t$ von $w$
+    ein \textbf{inhaltlicher Mehrfachsprung}. $v'$ ist also genau
+    einen Sprung über einen Wortknoten $w$ von $v$ entfernt.
+\end{definition}
+
 Der DYCOS-Algorithmus betrachtet die Texte, die einem Knoten 
 zugeornet sind, als eine
 Multimenge von Wörtern. Das heißt, zum einen wird nicht auf die
@@ -49,111 +79,69 @@ verwaltet der DYCOS-Algorithmus zwei weitere Datenstrukturen:
           \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.
+    \item An einigen Stellen macht ein assoziatives Array, auch 
+          \enquote{dictionary} oder \enquote{map} genannt, sinn.
+          Zustätzlich ist es nützlich, wenn diese Datenstruktur für 
+          unbekannte Schlüssel keinen Fehler ausgibt, sondern für diese
+          Schlüssel den Wert 0 annimmt. Eine solche Datenstruktur
+          wird in Python \texttt{defaultdict} genannt und ich werde
+          im Folgenden diese Benennung beibehalten.
 \end{itemize}
 
-\subsection{Algorithmen}
+\input{Sprungtypen}
-Bevor der Algorithmus formal beschrieben wird, wird eine Definition
+\input{Vokabularbestimmung}
-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.
 
-    Dann heißt ein Random Walk der Länge $l$ in diesem Graphen
+\subsection{Der Algorithmus}
-    ein \textbf{struktureller $l$-Sprung}, wenn für den Random Walk
+Der DYCOS-Algorithmus verwendet nun für jeden Knoten der gelabelt wird
-    nur Kanten aus $E_{S,t}$ benutzt werden.
+$r$ Random Walks der Länge $l$, wobei mit einer Wahrscheinlichkeit 
-\end{definition}
+$p_S$ ein struktureller $l$-Sprung und mit einer Wahrscheinlichkeit
+von $(1-p_S)$ ein inhaltlicher $l$-Mehrfachsprung gemacht wird.
 
-Der strukturelle $l$-Sprung ist also ein Random Walk der Länge $l$
+Die Vokabularbestimmung kann zu jedem Zeitpunkt $t$ durchgeführt 
-im Graph $G_t$. Im Gegensatz dazu benötigt der inhaltliche $l$-Mehrfachsprung
+werden, muss es aber nicht.
-tatsächlich die Grapherweiterung:
 
-\begin{definition}
+Im Folgenden werde ich den DYCOS-Algorithmus als Pseudocode vorstellen.
-    Sei $G_t = (V_t, E_{S,t} \cup E_{W,t}, V_{L,t}, W_{t})$ der
+Dafür benötigt man die beiden Hilfsfunktionen für den strukturellen
-    um die Wortknoten $W_{t}$ erweiterte Graph.
+Sprung sowie den inhaltlichen Mehrfachsprung:
-
-    Dann heißt ein Random Walk der Länge $l$ in diesem Graphen
-    ein \textbf{inhaltlicher $l$-Mehrfachsprung}, 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}
+    \begin{algorithmic}[1]
         \Require \\$\G_t = (\N_t, \A_t, \T_t)$ (Netzwerk),\\
                  $r$ (Anzahl der Random Walks),\\
                  $l$ (Länge eines Random Walks),\\
-                 $p_s$ (Wahrscheinlichkeit eines strukturellen Sprungs)
+                 $p_s$ (Wahrscheinlichkeit eines strukturellen Sprungs),\\
+                 $q$ (Anzahl der betrachteten Knoten nach der Aggregatanalyse)
         \Ensure  Klassifikation von $\N_t \setminus \T_t$\\
-
-        \Procedure{SturkturellerSprung}{Dictionary $d$, Startknoten $v$, Länge $l$}
-            \For{$i$ von $1$ bis $l$}
-                \State $v \gets v.\Call{Next}{}$
-                \ForAll{Label $w$ in v.\Call{GetLabels}{}}
-                    \State $d[w] = d[w] + 1$
-                \EndFor
-            \EndFor
-        \EndProcedure
-        \\
-        \Procedure{InhaltlicherMehrfachsprung}{Dictionary $d$, Startknoten $v$, Länge $l$}
-            \For{$i$ von $1$ bis $l$}
-                \State $v \gets v.\Call{Next}{}$ \Comment{TODO: Hier muss ein mehrfachsprung beschrieben werden!}
-                \ForAll{Label $w$ in v.\Call{GetLabels}{}}
-                    \State $d[w] = d[w] + 1$
-                \EndFor
-            \EndFor
-        \EndProcedure
         \\
 
         \ForAll{Knoten $v$ in $\N_t \setminus \T_t$}
-            \State $d \gets $ Dictionary, das für neue Einträge 0 annimmt
+            \State $d \gets $ defaultdict
             \For{$i$ von $1$ bis $r$}
-                \State $sprungTyp \gets \Call{random}{0, 1}$
+                \State $w \gets v$
-                \If{$sprungTyp \leq p_S$}
+                \For{$j$ von $1$ bis $l$}
-                    \State \Call{SturkturellerSprung}{$v$, $l$}
+                    \State $sprungTyp \gets \Call{random}{0, 1}$
-                \Else
+                    \If{$sprungTyp \leq p_S$}
-                    \State \Call{InhaltlicherMehrfachsprung}{$v$, $l$}
+                        \State $w \gets$ \Call{SturkturellerSprung}{$w$}
-                \EndIf
+                    \Else
+                        \State $w \gets$ \Call{InhaltlicherMehrfachsprung}{$w$}
+                    \EndIf
+                    \State $w \gets v.\Call{GetLabel}{ }$ \Comment{Zähle das Label}
+                    \State $d[w] \gets d[w] + 1$
+                \EndFor
             \EndFor
 
-            \If{$d$ ist leer}
+            \If{$d$ ist leer} \Comment{Es wurde kein gelabelter Knoten gesehen}
-                \State $M_H \gets \Call{HäufigsteLabelImGraph}{}$
+                \State $M_H \gets \Call{HäufigsteLabelImGraph}{ }$
-                \ForAll{$label$ in $M_H$}
-                    \State $v.\Call{AddLabel}{label}$
-                \EndFor
             \Else
                 \State $M_H \gets \Call{max}{d}$
-                \ForAll{$label$ in $M_H$}
-                    \State $v.\Call{AddLabel}{label}$
-                \EndFor
             \EndIf
+            \\
+            \State \Comment{Wähle aus der Menge der häufigsten Label $M_H$ zufällig eines aus}
+            \State $label \gets \Call{Random}{M_H}$ 
+            \State $v.\Call{AddLabel}{label}$ \Comment{und weise dieses $v$ zu}
         \EndFor
         \State \Return Labels für $\N_t \setminus \T_t$
     \end{algorithmic}
 \caption{DYCOS-Algorithmus}
 \label{alg:DYCOS}
 \end{algorithm}
-
-\subsection{Inhaltliche Mehrfachsprünge}
-Es ist nicht sinnvoll, direkt von einem strukturellem Knoten 
-$v \in \N_t$ zu einem mit $v$ verbundenen Wortknoten $w$ zu springen
-und von diesem wieder zu einem verbundenem strutkurellem Knoten 
-$v' \in \N_t$. Würde man dies machen, wäre zu befürchten, dass
-aufgrund von Homonymen die Qualität der Klassifizierung verringert
-wird. So hat \enquote{Brücke} im Deutschen viele Bedeutungen.
-Gemeint sein können z.~B. das Bauwerk, das Entwurfsmuster der
-objektorientierten Programmierung oder ein Teil des Gehirns.
-
-Deshalb wird für jeden Knoten $v$, von dem aus man einen inhaltlichen
-Mehrfachsprung machen will folgendes vorgehen gewählt:
-\begin{enumerate}
-    \item Gehe alle in $v$ startenden Random Walks der Länge 2 durch
-          und erstelle eine Liste $L$, der erreichbaren Knoten $v'$. Speichere
-          außerdem, durch wie viele Pfade diese Knoten $v'$ jeweils erreichbar sind.
-    \item Betrachte im folgenden nur die Top-$q$ Knoten, wobei $q \in \mathbb{N}$
-          eine zu wählende Konstante des Algorithmus ist.
-    \item Wähle mit Wahrscheinlichkeit $\frac{\Call{Anzahl}{v'}}{\sum_{w \in L} \Call{Anzahl}{v'}}$
-          den Knoten $v'$ als Ziel des Mehrfachsprungs.
-\end{enumerate}
-
-\input{Vokabularbestimmung}

documents/DYCOS/DYCOS.tex

@@ -30,7 +30,7 @@
 \setcounter{secnumdepth}{3}
 
 \hypersetup{ 
-  pdftitle    = {\"Uber die Klassifizierung von Knoten in dynamischen Netzwerken mit Inhalt},
+  pdftitle    = {Über die Klassifizierung von Knoten in dynamischen Netzwerken mit Inhalt},
   pdfauthor   = {Martin Thoma}, 
   pdfkeywords = {DYCOS}
 }
@@ -38,11 +38,11 @@
 \begin{document}
 
 \mainmatter
-\title{\"Uber die Klassifizierung von Knoten in dynamischen Netzwerken mit Inhalt}
+\title{Über die Klassifizierung von Knoten in dynamischen Netzwerken mit Inhalt}
-\titlerunning{\"Uber die Klassifizierung von Knoten in dynamischen Netzwerken mit Inhalt}
+\titlerunning{Über die Klassifizierung von Knoten in dynamischen Netzwerken mit Inhalt}
 \author{Martin Thoma}
 \authorrunning{Proseminar Netzwerkanalyse}
-\institute{Betreuer: Christopher O\ss{}ner}
+\institute{Betreuer: Christopher Oßner}
 \date{17.01.2014}
 \maketitle
 
@@ -57,11 +57,8 @@
 \section{DYCOS}
 \input{DYCOS-Algorithmus}
 
-\section{Experimentelle Analyse}\label{sec:experimentelle-analyse}
+\section{Schwächen und Verbesserungsvorschläge}
-\input{Experimentelle-Analyse}
+\input{SchwaechenVerbesserungen}
-
-\section{Abgrenzung}
-\input{Abgrenzung}
 
 \section{Ausblick}
 \input{Ausblick}
@@ -69,7 +66,7 @@
 % Normaler LNCS Zitierstil
 %\bibliographystyle{splncs}
 \bibliographystyle{itmalpha}
-% TODO: Ändern der folgenden Zeile, damit die .bib-Datei gefunden wird
+% TODO: Ändern der folgenden Zeile, damit die .bib-Datei gefunden wird
 \bibliography{literatur}
 
 \end{document}

documents/DYCOS/Einleitung.tex

@@ -19,8 +19,8 @@ für alle Knoten, die bisher noch nicht gelabelt sind.\\
     $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:V_{L,t} \rightarrow \powerset(L_t)$ die Funktion, die einen
+    Labels und $f:V_{L,t} \rightarrow L_t$ die Funktion, die einen
-    Knoten auf seine Labels abbildet.
+    Knoten auf sein Label abbildet.
 
     Weiter sei für jeden Knoten $v \in V$ eine (eventuell leere)
     Textmenge $T(v)$ gegeben.
@@ -36,6 +36,6 @@ 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.
-Das bedeutet, es ist wünschenswert bei kleinen Modifikationen nicht
+Bei kleinen Modifikationen sollte nicht alles nochmals berechnen 
-nochmals alles neu berechnen zu müssen, sondern basierend auf zuvor
+werden müssen, sondern basierend auf zuvor
-berechneten Labels die Klassifizierung modifizieren zu können.
+berechneten Labels sollte die Klassifizierung modifiziert werden.

documents/DYCOS/README.md

@@ -0,0 +1,4 @@
+Ausarbeitung zum Proseminar "Netzwerkanalyse" am KIT.
+
+Die Ausarbeitung soll 10-12 Seiten haben und die Präsentation
+25-30 Minuten dauern + 10-15 Minuten Diskussion.

documents/DYCOS/SchwaechenVerbesserungen.tex

@@ -0,0 +1,89 @@
+Der in \cite{aggarwal2011} vorgestellte Algorithmus hat einige Probleme,
+die im Folgenden erläutert werden. Außerdem werden Verbesserungen
+vorgeschlagen, die es allerdings noch zu untersuchen gilt.
+
+\subsection{Schwächen von DYCOS}
+\subsubsection{Anzahl der Labels}
+So, wie er vorgestellt wurde, können nur Graphen bearbeitet werden, 
+deren Knoten höchstens ein Label haben. In vielen Fällen, wie z.~B. 
+Wikipedia mit Kategorien als Labels haben Knoten jedoch viele Labels.
+
+Auf einen ersten Blick ist diese Schwäche einfach zu beheben, indem 
+man beim zählen der Labels für jeden Knoten jedes Label zählt. Dann
+wäre noch die Frage zu klären, mit wie vielen Labels der betrachtete
+Knoten gelabelt werden soll.
+
+Jedoch ist z.~B. bei Wikipedia-Artikeln auf den Knoten eine 
+Hirarchie definiert. So ist die Kategorie \enquote{Klassifikationsverfahren}
+eine Unterkategorie von \enquote{Klassifikation}. Bei dem Kategorisieren
+von Artikeln sind möglichst spezifische Kategorien vorzuziehen, also
+kann man nicht einfach bei dem Auftreten der Kategorie \enquote{Klassifikationsverfahren}
+sowohl für diese Kategorie als auch für die Kategorie \enquote{Klassifikation}
+zählen.
+
+
+\subsubsection{Überanpassung und Reklassifizierung}
+Aggarwal und Li beschreiben in \cite{aggarwal2011} nicht, auf welche
+Knoten der Klassifizierungsalgorithmus angewand werden soll. Jedoch
+ist die Reihenfolge der Klassifizierung relevant. Dazu folgendes 
+minimale Beispiel:
+
+Gegeben sei ein dynamischer Graph ohne textuelle Inhalte. Zum Zeitpunkt
+$t=1$ habe dieser Graph genau einen Knoten $v_1$ und $v_1$  sei
+mit dem Label $A$ beschriftet. Zum Zeitpunkt $t=2$ komme ein nicht-gelabelter
+Knoten $v_2$ sowie die Kante $(v_1, v_2)$ hinzu.\\
+Nun wird der DYCOS-Algorithmus auf diesen Knoten angewendet und
+$v_2$ mit $A$ gelabelt.\\
+Zum Zeitpunkt $t=3$ komme ein Knoten $v_3$, der mit $B$ gelabelt ist,
+und die Kante $(v_3, v_2)$ hinzu.
+
+Würde man nun den DYCOS-Algorithmus erst jetzt, also anstelle von
+Zeitpunkt $t=2$ zum Zeitpunkt $t=3$ auf den Knoten $v_2$ anwenden, so
+würde eine $50\%$-Wahrscheinlichkeit bestehen, dass dieser mit $B$ 
+gelabelt wird. Aber in diesem Beispiel wurde der Knoten schon
+zum Zeitpunkt $t=2$ gelabelt. Obwohl es in diesem kleinem Beispiel
+noch keine Rolle spielt, wird das Problem klar, wennn man weitere
+Knoten einfügt:
+
+Wird zum Zeitpunkt $t=4$ ein ungelabelter Knoten $v_4$ und die Kanten
+$(v_1, v_4)$, $(v_2, v_4)$, $(v_3, v_4)$ hinzugefügt, so ist die 
+Wahrscheinlichkeit, dass $v_4$ mit $A$ gelabelt wird bei $75\%$.
+Werden die als ungelabelten Knoten jedoch erst jetzt und alle gemeinsam
+gelabelt, so ist die Wahrscheinlichkeit für $A$ als Label bei nur $50\%$.
+Bei dem DYCOS-Algorithmus findet also eine Überanpassung and vergangene
+Labels statt.
+
+Das Reklassifizieren von Knoten könnte eine mögliche Lösung für dieses
+Problem sein. Knoten, die durch den DYCOS-Algorithmus gelabelt wurden
+könnten eine Lebenszeit bekommen (TTL, Time to Live). Ist diese 
+abgelaufen, wird der DYCOS-Algorithmus erneut auf den Knoten angewendet.
+
+\subsection{Schwächen des Papers}
+Die Ergebnise der experimentelle Analyse können aus folgenden Gründen
+nicht überprüft werden:
+\begin{itemize}
+    \item DYCOS verwendet als Vokabular die Top-$m$-Wörter mit dem
+          höchsten Gini-Index aus einer Sample-Menge von Texten, die
+          wie in \cite{Vitter} beschrieben
+          erzeugt wird. Allerdings wird niemals erklärt, wie $m \in \mathbb{N}$
+          bestimmt wird. Es ist nicht einmal klar, ob $m$ für den
+          Algorithmus als konstant anzusehen ist oder ob $m$ sich
+          bei der Vokabularbestimmung ändern könnte.
+    \item DYCOS beschränkt sich bei inhaltlichen Mehrfachsprüngen
+          auf die Top-$q$-Wortknoten, also die $q$ ähnlichsten Knoten
+          gemessen mit der Aggregatanalyse. Auch hier wird nicht erklärt wie
+          $q \in \mathbb{N}$ bestimmt oder nach welchen Überlegungen $q$ gesetzt 
+          wurde. Allerings ist hier wenigstens klar, dass $q$ für
+          den DYCOS-Algorithmus konstant ist. Für die Experimentelle
+          Analyse wurde zwar erwähnt, dass $q$ ein Parameter des
+          Algorithmus ist\cite[S. 362]{aggarwal2011}, aber nicht welcher
+          Wert in der Analyse des DBLP-Datensatzes genutzt wurde.
+          Für den CORA-Datensatz wurde $q=10$ gewählt\cite[S. 364]{aggarwal2011}.
+    \item Für die Analyse der CORA-Datensatzes\footnote{inzwischen unter \href{http://people.cs.umass.edu/~mccallum/data/cora-classify.tar.gz}{http://people.cs.umass.edu/~mccallum/data/cora-classify.tar.gz}} analysiert.
+          Dieser beinhaltet Forschungsarbeiten, wobei die 
+          Forschungsgebiete die in einen Baum mit 73 Blättern 
+          eingeordnet wurden. Aus diesen 73 Blättern wurden 5 Klassen
+          extrahiert und der Graph, der keine Zeitpunkte beinhaltet,
+          künstlich in 10 Graphen mit Zeitpunkten unterteilt. Wie
+          jedoch die TODO
+\end{itemize}

documents/DYCOS/Sprungtypen.tex

@@ -0,0 +1,87 @@
+\subsection{Sprungtypen}
+Die beiden bereits definierten Sprungtypen, der strukturelle Sprung
+sowie der inhaltliche Mehrfachsprung werden im folgenden erklärt.
+
+Der strukturelle Sprung entspricht einer zufälligen Wahl eines 
+Nachbarknotens. Hier gibt es nichts besonderes zu beachten.
+
+Bei inhaltlichen Mehrfachsprüngen sieht die Sache schon anders aus:
+Es ist nicht sinnvoll, direkt von einem strukturellem Knoten 
+$v \in \N_t$ zu einem mit $v$ verbundenen Wortknoten $w$ zu springen
+und von diesem wieder zu einem verbundenem strutkurellem Knoten 
+$v' \in \N_t$. Würde man dies machen, wäre zu befürchten, dass
+aufgrund von Homonymen die Qualität der Klassifizierung verringert
+wird. So hat \enquote{Brücke} im Deutschen viele Bedeutungen.
+Gemeint sein können z.~B. das Bauwerk, das Entwurfsmuster der
+objektorientierten Programmierung oder ein Teil des Gehirns.
+
+Deshalb wird für jeden Knoten $v$, von dem aus man einen inhaltlichen
+Mehrfachsprung machen will folgendes vorgehen gewählt:
+\begin{enumerate}
+    \item Gehe alle in $v$ startenden Random Walks der Länge 2 durch
+          und erstelle eine Liste $L$, der erreichbaren Knoten $v'$. Speichere
+          außerdem, durch wie viele Pfade diese Knoten $v'$ jeweils erreichbar sind.
+    \item Betrachte im folgenden nur die Top-$q$ Knoten, wobei $q \in \mathbb{N}$
+          eine zu wählende Konstante des Algorithmus ist.
+    \item Wähle mit Wahrscheinlichkeit $\frac{\Call{Anzahl}{v'}}{\sum_{w \in L} \Call{Anzahl}{v'}}$
+          den Knoten $v'$ als Ziel des Mehrfachsprungs.
+\end{enumerate}
+
+Konkret könnte also ein Inhaltlicher Mehrfachsprung sowie wie in
+Algorithmus~\ref{alg:DYCOS-content-multihop} beschrieben umgesetz werden.
+
+\begin{algorithm}[H]
+    \begin{algorithmic}[1]
+        \Procedure{InhaltlicherMehrfachsprung}{Knoten $v$}
+            \State \textit{//Alle Knoten bestimmen, die von $v$ aus über Pfade der Länge 2 erreichbar sind}
+            \State \textit{//Zusätzlich wird für diese Knoten die Anzahl der Pfade der Länge 2 bestimmt,}
+            \State \textit{//durch die sie erreichbar sind}
+            \State $reachableNodes \gets$ defaultdict
+            \ForAll{Wortknoten $w$ in $v.\Call{getWordNodes}{ }$}
+                \ForAll{Strukturknoten $x$ in $w.\Call{getStructuralNodes}{ }$}
+                    \State $reachableNodes[x] \gets reachableNodes[x] + 1$
+                \EndFor
+            \EndFor
+
+            \State \textit{//Im folgenden gehe ich davon aus, dass ich über Indizes wahlfrei auf Elemente }
+            \State \textit{//aus $M_H$ zugreifen kann. Dies muss bei der konkreten Wahl der Datenstruktur}
+            \State \textit{//berücksichtigt werden}
+            \State $M_H \gets \Call{max}{reachableNodes, q}$ \Comment{Also: $|M_H| = q$, falls $|reachableNodes|\geq q$}
+            \State \textit{//Generate dictionary with relative frequencies}
+            \State $s \gets 0$
+            \ForAll{Knoten $x$ in $M_H$}
+                \State $s \gets s + reachableNodes[x]$
+            \EndFor
+            \State $relativeFrequency \gets $ Dictionary
+            \ForAll{Knoten $x$ in $M_H$}
+                \State $relativeFrequency \gets \frac{reachableNodes[x]}{s}$
+            \EndFor
+
+            \State $random \gets \Call{random}{0, 1}$
+            \State $s \gets 0$
+            \State $i \gets 0$
+            \While{$s < random$}
+                \State $s \gets s + relativeFrequency[i]$
+                \State $i \gets i + 1$
+            \EndWhile
+            
+            \State $v \gets M_H[i-1]$ 
+            \State \Return $v$
+        \EndProcedure
+    \end{algorithmic}
+\caption{Inhaltlicher Mehrfachsprung}
+\label{alg:DYCOS-content-multihop}
+\end{algorithm}
+
+\begin{algorithm}[H]
+    \begin{algorithmic}[1]
+        \Procedure{SturkturellerSprung}{Knoten $v$, Anzahl $q$}
+            \State $n \gets v.\Call{NeighborCount}{}$ \Comment{Wähle aus der Liste der Nachbarknoten}
+            \State $r \gets \Call{RandomInt}{0, n-1}$ \Comment{einen zufällig aus}
+            \State $v \gets v.\Call{Next}{r}$ \Comment{Gehe zu diesem Knoten}
+            \State \Return $v$
+        \EndProcedure
+    \end{algorithmic}
+\caption{Struktureller Sprung}
+\label{alg:DYCOS-structural-hop}
+\end{algorithm}

documents/DYCOS/Vokabularbestimmung.tex

@@ -13,7 +13,6 @@ Gleichverteilung entspricht und $1$ der größt möglichen Ungleichverteilung.
 
 Sei nun $n_i(w)$ die Häufigkeit des Wortes $w$ in allen Texten mit 
 dem $i$-ten Label.
-\todo{darf ich hier im Nenner 1 addieren?}
 \begin{align}
     p_i(w) &:= \frac{n_i(w)}{\sum_{j=1}^{|\L_t|} n_j(w)} &\text{(Relative Häufigkeit des Wortes $w$)}\\
     G(w)   &:= \sum_{j=1}^{|\L_t|} p_j(w)^2              &\text{(Gini-Koeffizient von $w$)}
@@ -30,7 +29,7 @@ $\mathcal{O}(|\text{Wörter in } S_t|)$, wobei dazu die Vereinigung
 von Mengen $M,N$ in $\mathcal{O}(\min{|M|, |N|})$ sein muss.
 
 \begin{algorithm}[H]
-    \begin{algorithmic}
+    \begin{algorithmic}[1]
         \Require \\
                  $\T_t$ (Knoten mit Labels),\\
                  $\L_t$ (Labels),\\
@@ -65,4 +64,6 @@ von Mengen $M,N$ in $\mathcal{O}(\min{|M|, |N|})$ sein muss.
 \label{alg:vokabularbestimmung}
 \end{algorithm}
 
-
+Die Menge $S_t$ kann durch Aus der Menge aller Dokumenten, deren 
+Knoten gelabelt sind, mithile des in \cite{Vitter} vorgestellten
+Algorithmus bestimmt werden.

documents/DYCOS/abstract.tex

@@ -1,8 +1,11 @@
-In dieser Arbeit wird der DYCOS-Algorithmus mit einer kleinen
+In dieser Arbeit wird der DYCOS-Algorithmus, wie ihn Charu Aggarwal
-Modifikation vorgestellt. Er klassifiziert automatisch Knoten in 
+und Nan Li in \cite{aggarwal2011} vorgestellt haben, erklärt.
+Er klassifiziert automatisch Knoten in 
 Netzwerken, die bereits teilweise mit Labels versehen sind. Zur 
 Klassifizierung kann er textuelle Informationen, die den Knoten 
 zugeordnet sind, nutzen. Er ist auch für für viele $\num{10000}$ 
 Knoten große, dynamische Netzwerke geeignet.\\
+Zusätzlich wird auf Schwächen von \cite{aggarwal2011} hingewiesen
+und mögliche Verbesserungen vorgeschlagen.
 
 \textbf{Keywords:} DYCOS, Label Propagation, Knotenklassifizierung

documents/DYCOS/literatur.bib

@@ -72,3 +72,46 @@
   ee        = {http://dx.doi.org/10.1007/978-3-642-00528-2},
   bibsource = {DBLP, http://dblp.uni-trier.de}
 }
+
+@Online{bhagat,
+  author      = {Smriti Bhagat AND Graham Cormode AND S. Muthukrishnan},
+  title       = {Node Classification in Social Networks},
+  year        = {2011},
+  version     = {1},
+  date        = {2011-01-17},
+  eprinttype  = {arxiv},
+  eprintclass = {cs.SI, physics.soc-ph},
+  eprint      = {http://arxiv.org/abs/1101.3291v1}
+}
+
+@article{Vitter,
+    author = {Vitter, Jeffrey S.},
+    title = {Random Sampling with a Reservoir},
+    journal = {ACM Trans. Math. Softw.},
+    volume = {11},
+    number = {1},
+    year = {1985},
+    issn = {0098-3500},
+    pages = {37--57},
+    numpages = {21},
+    url = {http://doi.acm.org/10.1145/3147.3165},
+    doi = {10.1145/3147.3165},
+    acmid = {3165},
+    publisher = {ACM},
+    address = {New York, NY, USA},
+} 
+
+@incollection{porter,
+ author = {Porter, M. F.},
+ chapter = {An Algorithm for Suffix Stripping},
+ title = {Readings in Information Retrieval},
+ editor = {Sparck Jones, Karen and Willett, Peter},
+ year = {1997},
+ isbn = {1-55860-454-5},
+ pages = {313--316},
+ numpages = {4},
+ url = {http://dl.acm.org/citation.cfm?id=275537.275705},
+ acmid = {275705},
+ publisher = {Morgan Kaufmann Publishers Inc.},
+ address = {San Francisco, CA, USA},
+}