From 03d51526311de1e7ff1e7803e4bf8ce66bf17933 Mon Sep 17 00:00:00 2001
From: hanemile <emile.hansmaennel@gmail.com>
Date: Tue, 16 Jan 2018 15:55:51 +0100
Subject: updated the langfassung

---
 langfassung/docs/3_hauptteil.tex | 654 +++++++++++++++++++++++++++++----------
 1 file changed, 493 insertions(+), 161 deletions(-)

(limited to 'langfassung/docs/3_hauptteil.tex')

diff --git a/langfassung/docs/3_hauptteil.tex b/langfassung/docs/3_hauptteil.tex
index 617e4f9..c3edf57 100644
--- a/langfassung/docs/3_hauptteil.tex
+++ b/langfassung/docs/3_hauptteil.tex
@@ -1,27 +1,11 @@
-
-% \paragraph{ \( \Phi \) }
-%
-% \begin{equation}
-%   \Phi(r) = - \frac{4\pi G \rho_0 R_s^3}{r} \ln ( 1+ \frac{r}{R_s} )
-% \end{equation}
-%
-% with the limits
-%
-% \begin{equation}
-%   \lim_{r\to \infty} \Phi=0
-% \end{equation}
-%
-% and
-%
-
-
-\subsection{Generierung der Elliptischen Galaxien}
+\subsection{Generierung von elliptischen Galaxien}
 \subsubsection{Das Navarro-Frenk-White Profil}
 
-Das Navarro-Frenk-White profil (NFW-profil) ist im grunde genommen eine Funktion
-die einem die Warscheinlichkeit das ein Stern an einer bestimmten position ist
-liefert.
-Die Funktion ist im allgemeinen wie folgt aufgebaut:
+Das Navarro-Frenk-White Profil (NFW-profil) ist ein Profil zur Simulation
+von Masseverteilungen in N-Körper-Simulationen. Im Grunde genommen bekommt man durch das Profil die
+Wahrscheinlichkeit das ein Stern in einem Abstand \( r \) vom Mittelpunkt der
+Galaxie existiert.
+Die Funktion die dies bewerkstelligt ist im Allgemeinen wie folgt aufgebaut:
 
 \begin{equation} \label{eq:NFW_profile}
   \rho_{NFW}(r) = \frac{ 1 }{ \sqrt{ 2 \pi } \cdot \sigma } \cdot
@@ -33,87 +17,125 @@ Die Funktion ist im allgemeinen wie folgt aufgebaut:
   ln{ \left( 1 + \frac{ r }{ R_{s} } \right) }
 \end{equation*}
 
-Um die Formel (\ref{eq:NFW_profile}) einfach zu beschreiben kann man sie sich
-wie folgt vorstellen:
-Um zu gucken ob ein zufälliger Stern
-bei \( x_1 \), \( y_1 \) und \( z_1 \) generiert werden kann wird wie folgt
-vorgegangen: Aus den Koordinaten wird der Wert \( r \) mithilfe des Satz des
-Pytargoras berechnet ( \( r = \sqrt{{x_1}^2 + {x_2}^2 + {x_3}^2} \) ) , dieser gibt
-an wie weit der jeweilige Stern vom Zentrum der Galaxie entfernt ist. Um zu
-prüfen ob der Stern generiert wird, wird dieser \( r \)-wert in die Funktion
-\( \rho_{NFW} \) eingesetzt. Der entstehende Wert gibt an wie warscheinlich es ist,
-das ein Stern in der Entfernung zum Ursprung generiert wird.
+Beispiel Werte:
 
-\subsubsection{Random Sampling}
+\begin{tabular}{l l l}
+  \( sigma \) & = & 200 \\
+  \( f_0 \) & = & 0.1 \\
+  \( R_s \) & = & 10000 \\
+  \( pi \) & = & 3.141592 \\
+  \( e \) & = & 2.718281 \\
+  \( G \) & = & 4.302e-3 \\
+\end{tabular}
 
-Die sogennante ''Random Sampling`` Methode wird genutzt um herrauszufinden ob
-ein Stern generiert wird oder nicht.Es wird dazu ein zufälliger
-Wert \( x \) im bereich \( [~\rho_{max}~;~\rho_{min}~] \) generiert. Liegt dieser
-Wert über dem Wert aus der Funktion \( \rho \) wird kein Stern generiert.
-Liegt dieser Stern jedoch unter dem wert aus der \( \rho \) Funktion wird
-ein Stern an den Koordinaten \( x_1 \), \( y_1 \) und \( z_1 \) generiert.
+Möchte man herausfinden wie wahrscheinlich es ist das ein Stern generiert wird,
+setzt man den Abstand des Sternes vom Mittelpunkt der Galaxie in die Formel
+(\ref{eq:NFW_profile}) ein. Möchte man z. B. wissen wie wahrscheinlich es ist,
+das ein Stern der die Koordinaten \( (x_{1}, x_{2}, x_{3}) \) besitzt generiert
+wird, wird der Abstand zum Mittelpunkt der Galaxie mithilfe des Satzes des
+Pythagoras berechnet:
 
-Um das generieren zu Beschleunigen wird eine sogenneante ''lookuptable``
-verwendet. (\( \rightarrow \) \ref{subsec:lookuptable})
-
-Generiert man ein paar Sterne mithilfe des NFW-Profils hat man theoretisch
-schon eine Galaxie, jedoch ist diese nicht klar definiert. Um eine klare
-definition zu erreichen müssen mehrere hundert Sterne generiert werden.
-
-% \subsubsection{Das Einasto Profil}
-%
-% \begin{equation}
-%   \gamma(r) = \frac{ d \ln(\rho(r)) }{ d \ln(\rho) } \propto r^{\alpha}
-% \end{equation}
+\begin{equation}
+  r = \sqrt{ {x_{1}}^2 + {x_{2}}^2 + {x_{2}}^2 }
+\end{equation}
 
-% \subsubsection{Blender + Python}
-%
-% Blender is Awesome, Python is Awesome and together they are
-% \bold{SUPER AWESOME!!!}
-%
-% \begin{enumerate}
-%   \item Generate the galaxy-data using the NFW-Profile or the Einasto-profile
-%   \item Display the data in Blender and create an image using the OpenGL-renderer
-%   \item Train a Neural Network (NN) to classify galaxies
-%   \item Let the NN modify the galaxy to generate a perfect galaxy
-% \end{enumerate}
+In dem Beispiel wird also der Wert \( r \) in das NFW-Profil gegeben:
 
+\begin{equation*}
+  \rho_{NFW}(r) = \dots = s
+\end{equation*}
 
-\subsection{Generierung eines Dunkle-Materie Halos}
+Als Lösung erhält man einen Wert der in einem Intervall
+\( [~\rho(r_{min})~;~\rho(r_{max})~] \) liegt. Rechnet man \( \rho(r_{min}) \) und
+\( \rho(r_{max}) \) aus, ist es möglich den jeweiligen Ergebnissen anhand dieser
+Werte eine Wahrscheinlichkeit zwischen \( 0 \) und \( 100\% \) zuzuordnen Sodas
+es möglich ist zu entscheiden, ob ein Stern bei \( P(x_1 | x_2 | x_3) \) generiert
+werden soll oder nicht.
+
+\begin{figure}
+  \centering
+  \includegraphics[width=0.75\textwidth]{figs/galaxy}
+  \caption{Eine mit dem NFW-profil und der Random Sampling Methode generierte Galaxie}
+  \label{fig:galaxy}
+\end{figure}
+
+\begin{figure}
+  \centering
+  \includegraphics[width=0.75\textwidth]{figs/lookup_table_rho_r_function_grid}
+  \caption{
+  Die Rho Funktion im Intervall \( [~0~;~10^7 ~] \) geplottet mithilfe von Logarithmischen Achsen. \\
+  Die x-Achse beschreibt die Entfernung zum Mittelpunkt der Galaxie \\
+  Die y-Achse beschreibt die Warscheinlichkeit das ein Stern generiert wird
+  }
+  \label{fig:rho}
+\end{figure}
 
-Das sogennannte ''Dunkle-Materie Halo`` ist eine art Kugel die eine Galaxie
-umspannt: Duch dieses Halo ist die Dichte der Dunklen Materie welches sich um die
-Galaxie herum befindet definiert. Problematisch ist jedoch, dass wir dieses
-Halo nicht sehen können weshalb wir nur aufgrund anderer phänomäne welche durch
-die Halos verursacht werden auf die Eigenschaften des Halos schließen können.
-\par
-Um diese Halos darzustellen wird das NFW-Profil~(\ref{eq:NFW_profile})
-abgewandelt und quasi mit dem Profil für Elliptische Galaxien verbunden.
+\subsubsection{Random Sampling}
 
-...
+Um jetzt herauszufinden ob der Stern bei \( P(x_{1} | x_{2} | x_{3}) \) generiert
+wird, wird ein zufälliger Wert \( n \) im Intervall
+\( [~\rho(0)~;~\rho(r_{max})~] \) generiert und mit dem Wert \( x \)
+verglichen.
+Ein Stern wird generiert wenn gilt \( n < x \). Wenn jedoch \( n > x \) gilt
+wird kein Stern generiert.
+Dieser Prozess wird Random Sampling gennant und ist einer der Knackpunkte wenn
+es darum geht die Zeit in der ein Stern generiert wird zu reduzieren. Eine
+Möglichkeit dies zu tun sind sogenannten Lookuptabellen (siehe Sektion \ref{subsec:lookup})
+
+\subsubsection{Lookup Tabellen} \label{subsec:lookup}
+
+Um das generieren zu Beschleunigen wird eine sogenannte ``lookuptable''
+verwendet. (\( \rightarrow \) \ref{subsec:lookuptable}) dabei wird die Funktion
+aus dem NFW-profile (\ref{eq:NFW_profile}) in eine Tabelle geschrieben die im
+.csv-format in eine Datei gespeichert. Dies hat den Vorteil das die
+Ergebnisse gespeichert vorliegen und somit für andere Berechnungen weiterverwendet
+werden können und bei der Berechnung in den Arbeitsspeicher geschrieben werden,
+wodurch die Ergebnisse aus der Funkion bei Bedarf vorliegen und nicht erst
+berechnet werden müssen.
+
+\subsection{Generierung eines Dunkle-Materie Halos durch Anpassung des NFW-Profils}
+
+Die Rotationskurve von Spiralgalaxien verhält sich in der Realität anders als
+in einer Simulation. Der Unterschied lässt sich durch eine Kraft erklären
+die Auswirkungen auf Materie haben kann, jedoch nicht sichtbar ist. Dadurch
+kann diese Kraft nur durch Rückschlüsse beschrieben werden. Verhält sich ein
+Objekt also nicht so, wie es aufgrund der sichtbaren auf es einwirkenden Kräfte
+tun sollte, so muss eine andere Kraft vorhanden sein, die das Objekt beeinflussen.
+Diese ``Kraft'' entsteht voraussichtlich aufgrund von dunkler Materie.
+Dadurch das man Dunkle Materie durch beobachten von Sternen orten kann
+indem man berechnet wie sich die Sterne theoretische verhalten sollten und dies mit den
+realen Gegebenheiten vergleicht kann man die Funktion die eigentlich die Dichte der
+Sternenverteilung (NFW-profil) erklären soll so anpassen das man die Dichte der
+Verteilung von dunkler Materie berechnen kann.
+Das NFW-profil (\ref{eq:NFW_profile}) kann also so angepasst werden, dass es
+statt die Wahrscheinlichkeit das ein Stern generiert wird die Wahrscheinlichkeit
+das Dunkle Materie an einem zufälligem Ort existiert, umgebaut werden.
+Das NFW-profil (\ref{eq:NFW_profile}) wird also zu (\ref{eq:dark_matter})
+umgebaut.
 
-\subsubsection{Anpassung des NFW-Profils}
+\bigskip
 
-\begin{equation}
-  \rho(r) = \frac{1}{\sqrt{2 \cdot \pi} \cdot \sigma} \cdot
+\begin{equation}\label{eq:dark_matter}
+  \rho_{NFWDM}(r) = \frac{1}{\sqrt{2 \cdot \pi} \cdot \sigma} \cdot
   e^{\left( - \frac{(\Phi(r)}{\sigma^{2}} \right)}
 \end{equation}
 
 \begin{equation}
-  \rho(r) \cdot 1-\frac{1}{(2 \cdot sigma^{2} )} \cdot
-  ( Mxx \cdot x^{2} + 2 \cdot Mxy \cdot xy + Myy \cdot y^{2} ))
+  \Phi(r) = 1-\frac{1}{(2 \cdot \sigma^{2} )} \cdot
+  ( M_{xx} \cdot x^{2} + 2 \cdot M_{xy} \cdot xy + M_{yy} \cdot y^{2} ))
 \end{equation}
 
-\begin{lstlisting}
+\bigskip
 
-# new rho function
-def rho_new(x, y, z):
+Eine Mögliche Implementation in der Programiersprache Python als Funktion:
+
+\begin{lstlisting}
+def rho(x, y, z):
   a = (1 - ((1) / (2 * (sigma ** 2)))
   b = ( Mxx * x**2 + 2 * Mxy * x * y + Myy * y**2 ) )
   c = a * b
-return rho(x, y, z) * c
+  return rho(x, y, z) * c
 
-# phi function
 def phi(x):
   if x == 0:
     return -4 * pi * f_0 * G * R_s**2
@@ -122,10 +144,8 @@ def phi(x):
   b = np.log(1. + (x / R_s) )
   c = a * b
   return c
-
 \end{lstlisting}
 
-
 \subsection{Stauchung und Streckung der Galaxie}
 
 Wird eine Galaxie gestreckt oder gestaucht kann das an der umliegenden Dunklen
@@ -133,53 +153,118 @@ Materie liegen. Um solch eine Streckung darzustellen wird wie folgt vorgegangen:
 Die Position eines Sternes an einer Achse muss mit einem Skalar multipliziert
 bzw. dividiert werden.
 Dies ist relativ einfach machbar da die Koordinaten der jeweiligen Sterne
-in einer Datei nach dem Format \( [x, y, z] \) gespeichert sind.
-Um die Galaxie vertikal zu strecken wird z.B. für jeden Stern die z-Koordinate
-mit dem skalar \( s \) multipliziert. Da gestaucht werden soll liegt dieser
+in einer Datei nach dem Format \( x, y, z \) gespeichert sind.
+Um die Galaxie vertikal zu strecken wird z. B. für jeden Stern die z-Koordinate
+mit dem skalar \( s \) multipliziert. Wenn gestaucht werden soll liegt dieser
 Wert im Intervall \( 0 < s < 1 \). Die neue Koordinate für einen Stern ist also
-\( [x, y, z \cdot s] \). Möchte man die Galaxie strecken muss das Skalar \( s \)
+\( x, y, z \cdot s \). Möchte man die Galaxie strecken muss das Skalar \( s \)
 im Intervall \( 1 < s < \infty \) liegen.
 
-\subsection{Beschleunigung der Generierung}
+Indem man ganz grob feststellt in welchen Bereichen der Galaxie der Anteil an
+dunkler Materie höher ist kann man dies mit in die Berechnungen einfließen lassen.
+In meinem Fall habe ich z. B. ausprobiert einen Richtungsvektor \( \vec{r} \)
+zu generieren der von einem Stern in die Richtung der dunklen Materie zeigt.
+anschließend hab ich den Richtungsvektor mit einem Skalar \( s \) multipliziert
+um die Stärke mit der die Dunkle Energie auf einen jeweiligen Stern wirkt
+kontrollieren zu können. Als letztes habe ich dann den Richtungsvektor
+mit mit den Koordinaten des Sternes multipliziert um eine theoretische neue
+Position für den Stern zu generieren. Tut man dies für alle Sterne entstehen
+kleinere sogenannte ''cluster'' in denen sich die Sterne bündeln. Ein Problem
+hierbei war, dass es unglaublich rechenaufwendig ist dies für mehrere hunderte
+von Tausenden Sternen zu berechnen (siehe Sektion \ref{subsec:big_o}
+und \ref{subsec:speeding_things_up})
+
+\subsection{Rechenaufwand} \label{subsec:big_o}
+
+Um den Rechenaufwand in der Informatik darzustellen wird die sogenannte
+''O notation'' verwendet. Diese Notation wird verwendet um zu beschreiben
+wie viele schritte gebraucht werden um an ein Ziel zu kommen, abhängig von der
+Anzahl der ''Objekte'':
 
-Die Sterne schnell zu generieren ist natürlich energieeffizienter aber auch
-wichtig damit das neuronale netzt in unserer lebzeit fertig wird.
+\begin{equation}
+  O(n) = |\dots|
+\end{equation}
 
-Es gibt ein paar Aktionen die umgebaut werden können um das generieren zu
-beschleunigen:
+Beispiel:
 
-\subsubsection{n-Sterne}
+\begin{equation*}
+  O(n) = |n^2|
+\end{equation*}
 
-Statt am Anfang mehrere Millionen Sterne zu generieren wird wenn eine
-neue Koordinate benötigt wird eine neue erstellt. So erstellt man auf keinen
-Fall zu viele Koordinaten was Zeit spaart.
-Dem programm kann also gesagt werden, dass es genau \( n_1 \) Sterne aus
-\( m_1 \) potentiellen Sternen generieren soll, andernfalls werden \( n_2 \)
-Sterne aus \( m_2 > m_1 \) potentiellen Sternen generiert.
+Möchte man z. B. die Kräfte zwischen \( n = 100 \) Sternen
+berechnen werden \( O(100) = 100^2 = 10000 \) Rechnungen ausgeführt.
 
-\subsubsection{Lookuptable} \label{subsec:lookuptable}
+Bei einer ''O notation'' von \( n^2 \) bei der Berechnung von
+Kräften zwischen den Sternen kann also davon ausgegangen werden das desto
+mehr Sterne existieren, die Rechenleistung die gebraucht wird um in derselben
+Zeit dieselbe Anzahl an Sternen zu generieren Exponentiell für jeden Stern
+Steigen wird.
 
-Eine Weitere Möglichkeit für meherere Berechnungen Zeit zu Spaaren ist, den
-Entsprechenden Wert aus dem NFW-Profil (Formel \ref{eq:NFW_profile}) vorher zu
-berechnen und in eine Tabelle zu schreiben.
-Dies kann für z.B. \( 2e8 \) Werte getan werden was zwar eine 6 GB große Datei
-erzeugt, diese kann jedoch innerhalb weniger Sekunden eingelesen werden.
-
-\subsubsection{Weitere Optimierungen}
+Eines Optimales Ergebnis wäre eine ''Big O notation'' von \( n\log{n} \),
+jedoch ist dies zurzeit nicht ganz möglich.
 
-\paragraph{Nichts in der Konsole ausgeben:}
+\subsection{Beschleunigung der Generation} \label{subsec:speeding_things_up}
 
-Eine Vorgang der erstaunlicherweise sehr viel Rechenleistung erfordert, ist
-der Vorgang beim ausgeben von Text in die Konsole. Gibt man jede potentielle
-Koordinate in die Konsole aus, stürtzt das Programm aufgund von Überlast ab.
-Um dies zu umgehen kann z.B. nur jeder 100.000 Wert in die Konsole ausgegeben
-werden.
+Die Geschwindigkeit mit der die Sterne generiert werden ist ohne irgendeine Art
+von Optimierung unglaublich langsam. Die NFW-Funktion (\ref{eq:NFW_profile})
+wird für jeden Stern aufs neue vom Computer berechnet was auf mehrere Tausend
+Sterne hochgerechnet unglaublich rechenaufwendig ist.
+Ein Weiteres Problem ist, dass das Programm von alleine nur einen Kern
+verwendet und somit auf eine menge Rechenleistung verzichtet.
+Durch Nutzung von mehreren Kernen kann die Zeit
+um \( n \) Sterne zu generieren schnell halbiert oder sogar geviertelt werden.
 
-\paragraph{...}
+\subsubsection{Lookuptable} \label{subsec:lookuptable}
 
-\newpage
-\subsection{Nutzung eines Neuronalen Netzes zum unbeaufsichtigeten generieren}
-\subsubsection{Aufbau des Neuronalen Netzes}
+Eine weitere Möglichkeit für mehrere Berechnungen Zeit zu Sparen ist, den
+entsprechenden Wert aus dem NFW-Profil (Formel \ref{eq:NFW_profile}) vorher zu
+berechnen und in eine Tabelle zu schreiben.
+Dies kann für z. B. \( 2 \cdot 10^8 \) Werte getan werden was zwar eine ca. 6 GB große
+Datei erzeugt, diese kann jedoch innerhalb weniger Sekunden eingelesen werden
+und somit das "errechnen" eines entsprechenden Wertes praktisch innerhalb von
+Bruchteilen einer Sekunde simulieren indem das Ergebnis einfach aus dem
+Arbeitsspeicher ausgelesen wird.
+
+\subsubsection{Mehr Rechenleistung!}
+
+Um mehr Sterne in weniger Zeit zu generieren können verschiedene
+Aspekte der Software optimiert werden. Um jedoch ohne Optimierung mehr Sterne
+zu generieren kann einfach mehr Rechenleistung verwendet werden. Dies ist im
+Grunde genommen die einfachste Möglichkeit mehr Sterne in einer relativ kurzen
+Zeitspanne zu generieren: Schon die Verwendung von vier statt zwei Kernen
+ermöglicht es einem in 30 Min. statt ca. 300 Sterne ca. 600 Sterne zu generieren.
+
+\paragraph{Amazon Web Services} ~\\
+Um das Generieren von Galaxien so "profitabel" wie möglich zu machen können
+sogenannte ''Amazon Web Services\footnote{
+Amazon Web Services (AWS) ist ein US-amerikanischer Cloud-Computing-Anbieter,
+der 2006 als Tochterunternehmen des Online-Versandhändlers Amazon.com gegründet
+wurde. Zahlreiche populäre Dienste wie beispielsweise Dropbox, Netflix,
+Foursquare oder Reddit greifen auf die Dienste von Amazon Web Services zurück.
+2013 stufte Gartner AWS als führenden internationalen Anbieter im Cloud
+Computing ein.
+} ''
+(AWS) genutzt werden.
+Der Dienst ''EC2'' kostet z.B. mit 60 Kernen und 256GB RAM nur \$3.712 pro Stunde.
+Statt mit einem Kern in einer Stunde ca. 600 Sterne zu generieren können
+also in einer Stunde 38400 Sterne generiert werden! Möchte man \( 1 \cdot
+10 ^ 6 \) Sterne generieren bräuchte man mit einer Geschwindigkeit von
+ca. 600 Sternen pro Stunde und 64 Kernen ca. 26 Stunden. Dies kostet umgerechnet
+ca. 100\$ (83€).
+Eine weitere Möglichkeit besteht darin, Virtuelle Server von Netcup anzumieten.
+Hierbei kosten z.B. 6 Kerne für einen Monat 8€ wodurch man frei nach Belieben
+den ganzen Tag Galaxien generieren kann.
+
+\subsubsection{Nichts in der Konsole ausgeben}~\\
+Ein Vorgang der erstaunlicherweise sehr viel Rechenleistung erfordert, ist
+der Vorgang beim Ausgeben von Text in die Konsole. Gibt man jede potentielle
+Koordinate in die Konsole aus, stürzt das Programm aufgrund von Zuviel Daten im Arbeitspeicher ab.
+Um dies zu umgehen kann z. B. nur jeder 100.000 Wert in die Konsole ausgegeben
+werden was jedoch auch überflüssig ist wenn man ungefähr abschätzen kann, wann
+das Script fertig gelaufen ist.
+
+\subsection{Nutzung eines neuronalen Netzes zum unbeaufsichtigten generieren von Galaxien}
+\subsubsection{Aufbau des neuronalen Netzes}
 
 Ein Neuronales Netz ist wie folgt aufgebaut:
 
@@ -206,15 +291,19 @@ Ein Neuronales Netz ist wie folgt aufgebaut:
 \begin{center}
   \begin{tikzpicture}[x=2cm, y=1.5cm, >=stealth]
 
+  % Input nodes
   \foreach \m/\l [count=\y] in {1,2,3,missing,4}
     \node [every neuron/.try, neuron \m/.try] (input-\m) at (0,2.5-\y) {};
 
+  % Hidden nodes
   \foreach \m [count=\y] in {1,missing,2}
     \node [every neuron/.try, neuron \m/.try ] (hidden-\m) at (2,2-\y*1.25) {};
 
+  % Output nodes
   \foreach \m [count=\y] in {1,missing,2}
     \node [every neuron/.try, neuron \m/.try ] (output-\m) at (4,1.5-\y) {};
 
+  % Synapses
   \foreach \l [count=\i] in {1,2,3,n}
     \draw [<-] (input-\i) -- ++(-1,0)
       node [above, midway] {$I_\l$};
@@ -234,6 +323,7 @@ Ein Neuronales Netz ist wie folgt aufgebaut:
     \foreach \j in {1,...,2}
       \draw [->] (hidden-\i) -- (output-\j);
 
+  % Labels
   \foreach \l [count=\x from 0] in {Eingabe, Versteckte, Ausgabe}
     \node [align=center, above] at (\x*2,2) {\l \\ ebene};
 
@@ -243,64 +333,306 @@ Ein Neuronales Netz ist wie folgt aufgebaut:
 
 \hrule
 
-\bigskip
+Im Grunde genommen werden Daten eingespeist und miteinander verrechnet, wodurch
+am Ende ein oder mehrere Werte rauskommen mit denen man die verschiedensten
+Sachen tun kann. In meinem Fall konnte ich z. B. die durchschnittliche Dichte
+von Sternen, die Größe der Galaxie und viele andere Faktoren in das neuronale
+Netz einspeisen um am Ende zwei Werte entnehmen. Das neuronale Netz muss
+trainiert werden, dabei werden echte funktionierende Daten in das Netz eingespeist
+und mit bereits vorhandenen Ergebnissen verglichen. Ist das Ergebnis gut und
+stimmt ungefähr mit dem bereits vorhandenen Ergebnis überein wird am Netz selber
+nichts getan. Stimmt das Ergebnis aus dem Netz mit dem bereits vorhandenen
+jedoch nicht überein, dann werden im neuronalen Netz die sogenannten Synapsen
+(Die Verbindungen zwischen den Neuronen (Oben als Kreis dargestellt))
+entsprechend anders gewichtet.
+
+\paragraph{Neuronen und Synapsen}
+
+In einem neuronalen Netz sind sogenannte Neuronen (In der Abbildung oben als
+Kreis dargestellt) über sogenannte Synapsen (In der Abbildung oben als Linie
+zwischen zwei Neuronen dargestellt) miteinander verbunden.
+Die Neuronen können als eine Art Funktion gesehen werden. Sie Wandeln die Daten
+die sie bekommen mithilfe einer Aktivierungsfunktion in einen Zahlenbereich
+zwischen 0 und 1 um. Eine solche Aktivierungsfunktion kann die folgende Form
+haben:
+
+\begin{equation}
+  S(x) = \frac{1}{1 + e^{-x}}
+\end{equation}
+
+Die Synapsen können verschieden gewichtet sein. Bekommt eine Synapse z. B.
+einen Eingabewert \( x \), dann kann der Eingabewert mit der Gewichtung \( w \)
+der Synapse verrechnet werden um den Ausgabewert \( a \) zu erhalten:
+
+\begin{equation}
+  x \cdot w = a
+\end{equation}
 
-Das \textbf{Neuronale Netz} besitze mehrere Ebenen: die \textbf{Eingabe ebene},
-die \textbf{Versteckte Ebene(n)} und die \textbf{Ausgabe Ebene}.
-Diese Ebenen bestehen aus sogennanten \textbf{Neuronen} die wie im Menschlichen
-Gehirn Informationen aufnehmen und weitergeben. Die Eingabe kann verschieden
-gewichtet sein, es kann also sein das eine Eingabe eine Gewichtung von
-\( 10\% \) hat und eine andere eine Gewichtung von \( 90\% \).
-Die Eingabe Ebene ist dazu da eine Eingabe inform einer Matrix an die
-verschiedenen Neuronen in der Versteckten Ebene weiterzuleiten.
-Die Versteckte Ebene verarbeitet die Information aus der Matrix und leitet
-diese an die Ausgabe Ebene weiter die die Information ausgibt.
-\par
-Das sogennante ''Trainieren`` ist der Prozess, bei dem die Gewichtung der
-Neuronen so Verändert wird, damit ein gewünschtes Ergebnis herrauskommt.
-Beispiel: man möchte ein Neuronales Netz darauf Trainieren eine Galaxie zu
-Identifizieren, dann werden ganz viele positiv Beispiele durch das Netz gejagt
-welche die Gewichtung immer weiter anpassen. In der Ausgangs Ebene wird dann
-mithilfe zweier Neuronen entweder dargestellt das das eingegebene Bild eine
-Galaxie ist oder das das eingegebene Bild eben keine Galaxie ist.
+Für eine weite Ausführung in den Bereich der neuronalen Netze reicht die vorgegebene
+Maximalanzahl an Seiten leider nicht, deshalb hier kurz das wesentliche:
+Um neuronale Netze effektiv nutzen zu können wird unglaublich viel
+Rechenleistung benötigt. Diese habe ich nicht einfach so zur Verfügung, weshalb
+ich Kontakt mit verschiedenen Unis und Unternehmen aufgenommen haben um dort
+vielleicht Zugang zu einem Hochleistungsrechner zu bekommen. Zum Zeitpunkt der
+Abgabe dieser Langfassung (\today) habe ich jedoch noch keine Möglichkeit gehabt
+meine Software auf einem solchen Hochleistungs-Rechner laufen zu lassen. Deshalb
+habe ich beschlossen die Nutzung von neuronalen Netzen nach hinten zu verschieben,
+auch wenn das Thema unglaublich spannend ist.
 
-\subsubsection{Nutzung eines Neuronalen Netztes zur verbesserung von Galaxien Simulationen}
+\bigskip
+%
+% \paragraph{Was ist ein Neuronales Netz?}
+% Ein Neuronales Netz ist ein Gebilde das aus Neuronen und Synapsen besteht.
+%
+% \paragraph{Was ist ein Neuron?}
+% Ein Neuron ist ein Knotenpunkt in einem Neuronalen Netz. Es summiert die
+% einkommenden synapsen.
+%
+% \paragraph{Was ist eine Synapse}
+% Eine Synapse ist eine Verbindung zwischen zwei Neuronen. Die Synapsen
+% können verschiden gewichtet sein wobei der Eingabewert mit der Gewichtung der
+% Synapse multipliziert wird.
+%
+% \paragraph{Was ist eine Aktivierungsfunktion?}
+% Eine Aktivierungsfunktion ist die Funktion die genutzt wird um einen beliebigen
+% Wert in einen Wert \( x \) für den gilt \( 0 < x < 1 \).
+% Beispiel einer Aktivierungsfunktion:
+% Die Funktion (\ref{eq:pyth}) ist der Satz des Pythagoras.
+%
+% \begin{equation}\label{sigmoid}
+%   \frac{1}{1+e^{-x}}
+% \end{equation}
+%
+% \begin{equation}
+%   2 + 2 = 4
+% \end{equation}
+%
+% \begin{equation}
+%   1 + 1 = 2
+% \end{equation}
+%
+% \begin{equation}\label{eq:pyth}
+%   a^2 + b^2 = c^2
+% \end{equation}
+%
+% \paragraph{Was haben die verschiedenen Ebenen zu bedeuten?}
+% Die Verschiedenen Ebenen in einem Neuronalen Netzt haben verschiedene
+% Funktionen: Die erste Ebene, die sogennante Eingabe Ebene, ist dazu da, eine
+% Eingabe in das Netzt einzuschleusen.
+% Die Ebenen zwischen der Eingabeebene und er Ausgabeebene werden als Versteckte
+% Ebenen bezeichten. Es muss mindestens eine Versteckte Ebene geben damit das
+% Netz lernfähig ist, es gibt jedoch keine Begrenzung wieviele Ebenen es geben
+% kann.
+% Die Ausgabe Ebene ist dazu da die Verarbeiteten Werte auszugeben.
+% Hier Bekommt man bei einer Aktivierungsfunktion (\ref{sigmoid}) die eine Ausgabe
+% zwischen 0 und 1 liefert einen Wert zwischen 0 und 1.
+%
+% \paragraph{Was bringen die ``versteckten Ebenen''?}
+% Die Versteckten Ebenen liegen zwischen den Ein- und Asugabeebenen. Sie sind
+% dazu da das lernen im Neuronalen Netz zu ermöglichen.
+%
+% \paragraph{Was ist ``Foward Propagation''?}
+% Als "Foward Propagation" wird der Vorgang bezwichten, bei dem ein Wert durch
+% das Neuronale Netz geschleust wird.
+%
+% \paragraph{Wie lernt das Neuronale Netz?}
+% Das Neuronale Netz lernt indem es immer wieder die Eingabewerte durch das
+% Neuronale Netz schiebt. Hierbei werden am Ende die Gewichtugnen der Synapsen
+% verändert wodurch das Netz sich immer weiter verändert.
+%
+% \paragraph{Was ist ``Backward Propagation?''}
+% Als "Backward Propagation" wird der Vorgang bezeichnet indem man nachdem man
+% einen Wert duch das Netz geschoben hat im Netz zurück geht und mögliche
+% Fehlerquellen sucht. Damit kann wenn bereits ein richtiges Ergebniss vorhanden
+% ist, wie z.B. bei der Digitalen Bilderkennung eine Zahl, einen Fehlerkoeffizinet
+% berechnet werden der dazu genutzt wird ein besseres Ergebniss zu erzielen.
+%
+%
+% Das \textbf{Neuronale Netz} besitze mehrere Ebenen: die \textbf{Eingabe ebene},
+% die \textbf{Versteckte Ebene(n)} und die \textbf{Ausgabe Ebene}.
+% Diese Ebenen bestehen aus sogennanten \textbf{Neuronen} die wie im Menschlichen
+% Gehirn Informationen aufnehmen und weitergeben. Die Eingabe kann verschieden
+% gewichtet sein, es kann also sein das eine Eingabe eine Gewichtung von
+% \( 10\% \) hat und eine andere eine Gewichtung von \( 90\% \).
+% Die Eingabe Ebene ist dazu da eine Eingabe inform einer Matrix an die
+% verschiedenen Neuronen in der Versteckten Ebene weiterzuleiten.
+% Die Versteckte Ebene verarbeitet die Information aus der Matrix und leitet
+% diese an die Ausgabe Ebene weiter die die Information ausgibt.
+% \par
+% Das sogennante ''Trainieren`` ist der Prozess, bei dem die Gewichtung der
+% Neuronen so Verändert wird, damit ein gewünschtes Ergebnis herrauskommt.
+% Beispiel: man möchte ein Neuronales Netz darauf Trainieren eine Galaxie zu
+% Identifizieren, dann werden ganz viele positiv Beispiele durch das Netz gejagt
+% welche die Gewichtung immer weiter anpassen. In der Ausgangs Ebene wird dann
+% mithilfe zweier Neuronen entweder dargestellt das das eingegebene Bild eine
+% Galaxie ist oder das das eingegebene Bild eben keine Galaxie ist.
+%
+% \subsubsection{Nutzung eines Neuronalen Netztes zur verbesserung von Galaxien Simulationen}
+%
+% Möchte man mithilfe eines Neuronalen Netztes vorhandene Galaxiensimulationen
+% verbessern, wird wie im folgenden Diagramm zusehen vorgegangen:
+%
+% \begin{tikzpicture}
+% [node distance = 4cm, auto, ->, on grid]
+%
+% \node [draw, minimum width=3cm, text depth = 1cm] (galaxy) {Galaxie};
+% \node [draw, right of=galaxy] (neural_net) {Neuralonales Netz};
+%
+% \node [draw] (yes) [right of=neural_net] {Ja}
+% node [right=3cm of yes, align=center] {Galaxie ist eine Galaxie};
+%
+% \node [draw] (no) [below=2cm of neural_net] {Nein}
+% node [right=3.5cm of no, align=center] {Galaxie ist keine Galaxie \\
+% \( \rightarrow \) ändere parameter und \\generiere eine neue Galaxie};
+%
+%
+% \draw[->, line width=0.25mm] (galaxy) -- (neural_net)
+% node [above=1cm of neural_net, align=center] {Testet ob die Eingabe \\eine
+% Galaxie ist oder nicht};
+%
+% \node[draw, yshift=5mm] (paramter) at (galaxy.south) {paramter};
+%
+% \draw[->, line width=0.25mm] (neural_net) -- (yes);
+% \draw[->, line width=0.25mm] (neural_net) -- (no);
+%
+% \path[line width=0.25mm] (no) edge [bend left] node {} (paramter);
+%
+% \end{tikzpicture}
 
-Möchte man mithilfe eines Neuronalen Netztes vorhandene Galaxiensimulationen
-verbessern, wird wie im folgenden Diagramm zusehen vorgegangen:
+\subsection{Spiralgalaxien}
 
-\begin{tikzpicture}
-[node distance = 4cm, auto, ->, on grid]
+Spiralgalaxien sind im allgemeinen faszinierende Gebilde: Aus mehreren Millionen
+Sternen entsteht eine Reisige Spirale. Dies zu simulieren ist jedoch unglaublich
+Rechenaufwendig weshalb ich dies bisher nur mir kleineren Galaxien durchgeführt
+habe. Das Problem ist, dass die Kräfte zwischen jedem Stern und jedem anderem
+Stern ausgerechnet werden müssen was wie in Sektion \ref{subsec:big_o} beschrieben
+mit steigender Anzahl an Sternen eine Exponentielle Steigerung der Rechenzeit
+hervorruft.
 
-\node [draw, minimum width=3cm, text depth = 1cm] (galaxy) {Galaxie};
-\node [draw, right of=galaxy] (neural_net) {Neuralonales Netz};
+\par Ein interessanter Aspekt der Spiralgalaxien den ich in die Simulationen
+einzubauen ist die Diskrepanz zwischen der realen Position
+der Sterne und der berechneten Position durch die Auf Dunkle Materie geschlossen
+wird.
 
-\node [draw] (yes) [right of=neural_net] {Ja}
-node [right=3cm of yes, align=center] {Galaxie ist eine Galaxie};
+\subsubsection{Das n-Körper Problem}
 
-\node [draw] (no) [below=2cm of neural_net] {Nein}
-node [right=3.5cm of no, align=center] {Galaxie ist keine Galaxie \\
-\( \rightarrow \) ändere parameter und \\generiere eine neue Galaxie};
+(nach der Ph.D. Thesis von Jakub Schwarzmeier s. 18 - 22, Pilsen 2007)
 
+Das sogenannte \( N \)-Körper Problem wird dazu genutzt um ein System mit
+\( N \)-Körpern zu simulieren. Hierbei müssen alle von außen einwirkenden
+Kräfte \(\vec{F_{i}} \) mit eingerechnet werden, im falle von Galaxien also die
+universelle Gravitationsregel von Newton.
 
-\draw[->, line width=0.25mm] (galaxy) -- (neural_net)
-node [above=1cm of neural_net, align=center] {Testet ob die Eingabe \\eine
-Galaxie ist oder nicht};
+\begin{equation}
+  m_{i} \cdot \frac{d\vec{v_{i}}}{dt} = \vec{F_i}
+\end{equation}
 
-\node[draw, yshift=5mm] (paramter) at (galaxy.south) {paramter};
+Für zwei Punkte in einer Galaxie gilt nach der universellen Gravitationsregel von
+Isaac Newton:
 
-\draw[->, line width=0.25mm] (neural_net) -- (yes);
-\draw[->, line width=0.25mm] (neural_net) -- (no);
+\begin{equation}
+  m_{i} \cdot \frac{d\vec{v_{i}}}{dt} =
+  G \cdot \frac{m_{i} \cdot m_{j}}{r^{3}_{ij}} \cdot \vec{r_{ij}}
+\end{equation}
 
-\path[line width=0.25mm] (no) edge [bend left] node {} (paramter);
+bzw.
 
-\end{tikzpicture}
+\begin{equation}\label{eq:n-body-2nd}
+  \frac{d^{2}\vec{r_{i}}}{dt^{2}} =
+  G \cdot \sum_{j = 1} \frac{m_j}{r^{3}_ij} \cdot \vec{r_{ij}}
+\end{equation}
 
-\subsection{Spiralgalaxien}
-\subsubsection{Das n-Körper Problem}
+Die neue Position und Geschwindigkeit eines Körpers wird mithilfe der bereits
+bekannten Beschleunigung berechnet, was zu der Formel (\ref{eq:n-body-2nd}), die
+eine zweite Ableitung enthält, führt. Die Formel (\ref{eq:n-body-2nd}) kann
+jedoch in zwei neue Formeln umgeschrieben werden, die jeweils nur eine erste
+Ableitung enthalten:
+
+\begin{align}\label{eq:hamilton}
+  \frac{d\vec{r_{i}}}{dt} &= \vec{v_i} \\
+  \frac{d\vec{v_{i}}}{dt} &= G \cdot \sum_{j = 1} \frac{m_j}{r^{3}_{ij}}
+  \cdot \vec{r_{ij}}
+\end{align}
+
+Die Formeln (\ref{eq:hamilton}) entsprechen der Bewegungsgleichung nach
+Hamilton. Möchte man nun die Position der einzelnen Sterne berechnen, müssen
+die Werte aus der Funktion in für einen Computer darstellbare Werte umgewandelt
+werden.
 
-\subsection{Größeneinheiten}
+Eines der Probleme um die Bewegung eines Sternes zu formulieren liegt dabei,
+einen Anfangswert für die Bewegung zu finden. Dies wird durch die folgende
+Formel gelöst:
 
 \begin{equation}
-  3.086 \cdot 10^{36} m
+  x_{t + 1} = x_{t} + \Delta t \cdot F(x_{i}, t_{i})
+\end{equation}
+
+Die Position eines Sternes nach einer Zeit von \( \Delta t \) wird durch die
+vorherige Position und die auf der Stern wirkenden Kräfte bestimmt.
+Der Term \( \Delta t \cdot F(x_{i}, t_{i}) \) wird auch als erster Schritt in
+der Taylor-reihe bezeichnet mit der weitere Punkte anhand der Ableitung
+vorheriger Punkte errechnet werden können.
+Die Veränderung der Position kann aus der Formel (\ref{eq:hamilton}) abgeleitet
+werden:
+
+\begin{align}
+  \Delta \vec{r_{i}} &=
+  \vec{v_{i}} \cdot \Delta t \\
+  \Delta \vec{v_{i}} &=
+  G \cdot \Delta t \cdot \sum_{j = 1} \frac{m_{j}}{r^{3}_{ij}} \vec{r_{ij}}
+\end{align}
+
+\subsubsection{Unterteilung des Vektorraumes in verschiedene Zellen}
+Die Kräfte die innerhalb der Galaxie wirken können mithilfe eines Vektorraumes
+dargestellt werden. Dabei kann jedem Punkt im Raum ein Vektor zugewiesen werden.
+Der Vektorraum im falle von Galaxien stellt erstmal nur die Kräfte, die die
+Sterne aufeinander auswirken da.
+Um nicht unendlich viel rechnen zu müssen wird der Vektorraum in verschiedene
+Zellen unterteilt in denen jeweils die mittlere Kraft berechnet wird.
+
+\subsubsection{Berechnung der wirkenden Kräfte}
+Die wirkenden Kräfte können wie in Formel (\ref{eq:gravitation_law}) zu sehen
+berechnet werden:
+
+\begin{equation}\label{eq:gravitation_law}
+  F_{1} = F_{2} = G \cdot \frac{m_{1} \cdot m_{2}}
+  {\sqrt{(a_1 - b_1)^2 + (a_2 - b_2)^2 + (a_3 - b_3)^2}}
 \end{equation}
+
+\begin{tabular}{l l}
+\( F_1 , F_2 \) & Wirkende Kräfte zwischen zwei Massen \\
+G & Gravitationskonstante \( 6,67408 \cdot 10^{-11} \frac{m^3}{kg \cdot s^2} \) \\
+\( m_1 \) & Erste Masse \\
+\( m_2 \) & Zweite Masse \\
+\( r \) & Abstand der Massen
+\end{tabular}
+
+\paragraph{Masse der Sterne}
+Die Masse der Sterne ist einer der entscheidende Faktoren wenn es darum geht
+Galaxien zu generieren: verändert man die Masse der Sterne verändert sich sofort
+das gesamte Gleichgewicht in der Galaxie was zu unerwarteten Ereignissen führen
+kann.
+\par Allgemein gesehen werden zwei Variablen gebraucht: die
+\textbf{Minimalmasse} und die \textbf{Maximalmasse}. Zwischen diesen beiden
+Werten werden zufällig Werte generiert und den Sternen zugewiesen.
+\par Die Veränderung der Masse wird erstmal nicht berücksichtigt.
+
+\paragraph{Abstand der Sterne}
+Der Abstand der Sterne kann mit dem Satz des Pythagoras (Formel
+(\ref{eq:pytagoras})) berechnet werden.
+
+\begin{equation}\label{eq:pytagoras}
+  r_{a, b} = \sqrt{(a_x - b_x)^2 + (a_y - b_y)^2 + (a_z - b_z)^2)}
+\end{equation}
+
+\subsection{Weiteres}
+Um die Simulation zu beschleunigen können andere Simulationsmodelle
+verwendet werden wie z. B. die Kräfte in verschiedenen Feldern berechnen um
+diese anschließend weiter zu evaluieren.
+
+\begin{figure}
+  \centering
+  \includegraphics[width=0.75\textwidth]{figs/spiralgalaxy}
+  \caption{Eine Spiralgalaxie generiert mithilfe von Daten aus dem Max-Plank-Institut in Heidelberg}
+  \label{fig:spiralgalaxy}
+\end{figure}
-- 
cgit 1.4.1

