diff --git a/documents/DYCOS/Abgrenzung.tex b/documents/DYCOS/Abgrenzung.tex index 16aaf7b..36986c6 100644 --- a/documents/DYCOS/Abgrenzung.tex +++ b/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 diff --git a/documents/DYCOS/Ausblick.tex b/documents/DYCOS/Ausblick.tex index cd3b14a..35968f8 100644 --- a/documents/DYCOS/Ausblick.tex +++ b/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 -werden. Durch diese Maßnahme wird das +Dafür könnte zum Beispiel der Porter-Stemming-Algorithmus verwendet +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, diff --git a/documents/DYCOS/DYCOS-Algorithmus.tex b/documents/DYCOS/DYCOS-Algorithmus.tex index e9e2cb9..8d58919 100644 --- a/documents/DYCOS/DYCOS-Algorithmus.tex +++ b/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} -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. +\input{Sprungtypen} +\input{Vokabularbestimmung} - 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} +\subsection{Der Algorithmus} +Der DYCOS-Algorithmus verwendet nun für jeden Knoten der gelabelt wird +$r$ Random Walks der Länge $l$, wobei mit einer Wahrscheinlichkeit +$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$ -im Graph $G_t$. Im Gegensatz dazu benötigt der inhaltliche $l$-Mehrfachsprung -tatsächlich die Grapherweiterung: +Die Vokabularbestimmung kann zu jedem Zeitpunkt $t$ durchgeführt +werden, muss es aber nicht. -\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$-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} +Im Folgenden werde ich den DYCOS-Algorithmus als Pseudocode vorstellen. +Dafür benötigt man die beiden Hilfsfunktionen für den strukturellen +Sprung sowie den inhaltlichen Mehrfachsprung: \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}$ - \If{$sprungTyp \leq p_S$} - \State \Call{SturkturellerSprung}{$v$, $l$} - \Else - \State \Call{InhaltlicherMehrfachsprung}{$v$, $l$} - \EndIf + \State $w \gets v$ + \For{$j$ von $1$ bis $l$} + \State $sprungTyp \gets \Call{random}{0, 1}$ + \If{$sprungTyp \leq p_S$} + \State $w \gets$ \Call{SturkturellerSprung}{$w$} + \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} - \State $M_H \gets \Call{HäufigsteLabelImGraph}{}$ - \ForAll{$label$ in $M_H$} - \State $v.\Call{AddLabel}{label}$ - \EndFor + \If{$d$ ist leer} \Comment{Es wurde kein gelabelter Knoten gesehen} + \State $M_H \gets \Call{HäufigsteLabelImGraph}{ }$ \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} diff --git a/documents/DYCOS/DYCOS.pdf b/documents/DYCOS/DYCOS.pdf index 3c1827f..91bd026 100644 Binary files a/documents/DYCOS/DYCOS.pdf and b/documents/DYCOS/DYCOS.pdf differ diff --git a/documents/DYCOS/DYCOS.tex b/documents/DYCOS/DYCOS.tex index 0e86613..0d91f8f 100644 --- a/documents/DYCOS/DYCOS.tex +++ b/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} -\titlerunning{\"Uber die Klassifizierung von Knoten in dynamischen Netzwerken mit Inhalt} +\title{Ãœber 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} -\input{Experimentelle-Analyse} - -\section{Abgrenzung} -\input{Abgrenzung} +\section{Schwächen und Verbesserungsvorschläge} +\input{SchwaechenVerbesserungen} \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} diff --git a/documents/DYCOS/Einleitung.tex b/documents/DYCOS/Einleitung.tex index fff87a4..4bb61fc 100644 --- a/documents/DYCOS/Einleitung.tex +++ b/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 - Knoten auf seine Labels abbildet. + Labels und $f:V_{L,t} \rightarrow L_t$ die Funktion, die einen + 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 -nochmals alles neu berechnen zu müssen, sondern basierend auf zuvor -berechneten Labels die Klassifizierung modifizieren zu können. +Bei kleinen Modifikationen sollte nicht alles nochmals berechnen +werden müssen, sondern basierend auf zuvor +berechneten Labels sollte die Klassifizierung modifiziert werden. diff --git a/documents/DYCOS/README.md b/documents/DYCOS/README.md new file mode 100644 index 0000000..61afed7 --- /dev/null +++ b/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. diff --git a/documents/DYCOS/SchwaechenVerbesserungen.tex b/documents/DYCOS/SchwaechenVerbesserungen.tex new file mode 100644 index 0000000..1c703a8 --- /dev/null +++ b/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} diff --git a/documents/DYCOS/Sprungtypen.tex b/documents/DYCOS/Sprungtypen.tex new file mode 100644 index 0000000..54efdf5 --- /dev/null +++ b/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} diff --git a/documents/DYCOS/Vokabularbestimmung.tex b/documents/DYCOS/Vokabularbestimmung.tex index 7838bbd..310c75b 100644 --- a/documents/DYCOS/Vokabularbestimmung.tex +++ b/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. diff --git a/documents/DYCOS/abstract.tex b/documents/DYCOS/abstract.tex index a92780a..24c674d 100644 --- a/documents/DYCOS/abstract.tex +++ b/documents/DYCOS/abstract.tex @@ -1,8 +1,11 @@ -In dieser Arbeit wird der DYCOS-Algorithmus mit einer kleinen -Modifikation vorgestellt. Er klassifiziert automatisch Knoten in +In dieser Arbeit wird der DYCOS-Algorithmus, wie ihn Charu Aggarwal +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 diff --git a/documents/DYCOS/literatur.bib b/documents/DYCOS/literatur.bib index 9c90bf9..94a8821 100644 --- a/documents/DYCOS/literatur.bib +++ b/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}, +}