Seminar - Exam

Aufgabe 1)

Geschichte und Entwicklung der Künstlichen Intelligenz: In dieser Aufgabe soll die Evolution der Künstlichen Intelligenz (KI) von den symbolischen Ansätzen der Anfänge hin zu den modernen Deep Learning-Techniken untersucht werden.

• 1956: Geburtsjahr der KI (Dartmouth-Konferenz)
• Symbolische KI und Expertensysteme (1950er-1980er)
• Erste KI-Winter (1970er und 1980er Jahre)
• Aufstieg neuronaler Netze und Machine Learning (1980er-2000er)
• Erfolge im Deep Learning durch GPU-Verbesserungen und Big Data (2010er)
• Aktuelle Trends: Reinforcement Learning, Explainable AI, Selbstüberwachtes Lernen

a)

Beschreibe und analysiere die Ursachen und Auswirkungen der sogenannten 'KI-Winter' in den 1970er und 1980er Jahren. Diskutiere, inwiefern diese Perioden die Entwicklung der Künstlichen Intelligenz beeinflusst haben und welche Lehren daraus gezogen wurden.

Lösung:

Ursachen und Auswirkungen der 'KI-Winter' in den 1970er und 1980er Jahren:

Die 'KI-Winter' waren Perioden, in denen das Interesse und die Finanzierung im Bereich der Künstlichen Intelligenz stark zurückgingen. Diese Phasen hatten bedeutende Ursachen und Auswirkungen, die die Entwicklung der Künstlichen Intelligenz nachhaltig beeinflusst haben:

• Ursachen der KI-Winter:
  • Überschätzte Erwartungen: In den frühen Jahren der KI-Forschung gab es übermäßigen Optimismus hinsichtlich dessen, was die Technologie leisten könnte. Viele Projekte konnten ihre hochgesteckten Ziele nicht erreichen, was zu Enttäuschung und einem Vertrauensverlust führte.
  • Technologische Beschränkungen: Die Hardware und Software der damaligen Zeit waren nicht leistungsfähig genug, um die komplexen Berechnungen für fortgeschrittene KI-Anwendungen durchzuführen.
  • Mangel an Daten: Zu dieser Zeit standen nicht genügend Daten zur Verfügung, um effektive Machine Learning-Modelle zu trainieren.
  • Fehlende Algorithmen: Viele der heute wichtigen Algorithmen und Methoden, insbesondere im Bereich der neuronalen Netze und des Deep Learnings, waren noch nicht entwickelt oder ausreichend erforscht.
  • Kritik und Skepsis: Es gab eine wachsende Skepsis gegenüber den tatsächlichen Fähigkeiten der KI, angeheizt durch mehrere fehlgeschlagene Projekte und negative Berichterstattung in den Medien.
• Auswirkungen der KI-Winter:
  • Rückgang der Finanzierung: Sowohl staatliche Institutionen als auch private Investoren zogen sich aus der Finanzierung von KI-Projekten zurück, was zu einem starken Rückgang der Forschungsaktivitäten führte.
  • Reduzierte Forschungsaktivität: Viele Forscher wandten sich von der KI-Forschung ab und suchten nach anderen wissenschaftlichen Bereichen mit besseren Finanzierungsaussichten und Erfolgswahrscheinlichkeiten.
  • Verlangsamte Entwicklung: Durch den Mangel an Ressourcen und Unterstützung wurde der Fortschritt der KI-Forschung erheblich verlangsamt.
  • Konservative Zielsetzungen: Die KI-Forschung wurde wesentlich konservativer, und viele Forscher setzten sich bescheidenere, erreichbare Ziele, um Enttäuschungen zu vermeiden.

Erkenntnisse und Lehren:

Aus den KI-Wintern haben die Forscher und Entwickler mehrere wichtige Erkenntnisse gewonnen, die die heutige KI-Landschaft beeinflussen:

• Realistischere Erwartungen: Es ist wichtig, realistische Ziele und Erwartungen zu setzen, um nicht erneut in eine Phase der Enttäuschung und des Vertrauensverlustes zu geraten.
• Interdisziplinäre Forschung: Die KI-Forschung muss interdisziplinär angegangen werden, wobei Erkenntnisse aus den Bereichen Informatik, Neurowissenschaften, Mathematik und anderen Wissenschaften integriert werden.
• Robuste Finanzierung: Eine kontinuierliche und langfristige Finanzierung ist entscheidend, um stabilen Fortschritt zu gewährleisten und kurzzeitige Rückschläge abzufedern.
• Datennutzung: Die Bedeutung großer, qualitativ hochwertiger Datenbestände wird erkannt, und moderne KI-Methoden wie Machine Learning und Deep Learning profitieren davon.
• Technologische Fortschritte: Verbesserungen in der Hardware, insbesondere die Nutzung von GPUs, haben es ermöglicht, komplexe Berechnungen effizienter durchzuführen und somit die Entwicklung der KI voranzutreiben.

Insgesamt haben die KI-Winter die Forscher gelehrt, dass eine nachhaltige Entwicklung im Bereich der Künstlichen Intelligenz eine sorgfältige Planung, realistische Einschätzungen und eine stabile Finanzierung erfordert.

Aufgabe 2)

Überwachte und unüberwachte Lernmethoden im Machine Learning sind die beiden Hauptkategorien. Im überwachten Lernen werden Modelle unter Verwendung gelabelter Trainingsdaten trainiert, während im unüberwachten Lernen keine solchen gelabelten Daten verwendet werden, und stattdessen Muster oder Strukturen in den Daten gefunden werden sollen. Beispiele für überwachte Lernmethoden sind Lineare Regression, Entscheidungsbäume und Neuronale Netze. Zu den unüberwachten Lernmethoden gehören K-Means Clustering, Principal Component Analysis (PCA) und Anomalieerkennung. Der wesentliche Unterschied zwischen beiden Methoden liegt in der Verfügbarkeit von Labels in den Trainingsdaten und den Zielen der Datenanalyse und -modellierung.

a)

Vergleiche die Lineare Regression (überwachtes Lernen) und das K-Means Clustering Verfahren (unüberwachtes Lernen) hinsichtlich ihrer Ziele, Vorgehensweise und Anwendungsbereiche. Verdeutliche dabei mindestens drei wesentliche Unterschiede anhand eines Anwendungsbeispiels aus der Praxis.

Lösung:

Vergleich der Linearen Regression und des K-Means Clustering Verfahrens:

• Ziele:
  • Lineare Regression: Das Hauptziel der linearen Regression besteht darin, eine Beziehung zwischen einer abhängigen Variable (Ziel) und einer oder mehreren unabhängigen Variablen (Prädiktoren) zu modellieren. Sie wird verwendet, um Vorhersagen oder Prognosen basierend auf diesen Beziehungen zu treffen.
  • K-Means Clustering: Im Gegensatz dazu zielt K-Means Clustering darauf ab, Datenpunkte in mehrere Gruppen (Cluster) zu partitionieren, sodass Datenpunkte innerhalb des gleichen Clusters ähnlicher zueinander sind als zu Datenpunkten in anderen Clustern. Es gibt keine abhängige Variable – statt Vorhersagen zu machen, wird hier versucht, Muster und Strukturen in den Daten zu erkennen.
• Vorgehensweise:
  • Lineare Regression:
    • 1. Daten sammeln und kennzeichnen.
    • 2. Datenvorbereitung (Datenbereinigung, Umgang mit fehlenden Werten, Feature Engineering).
    • 3. Ein Modell erstellen, das die Beziehung zwischen abhängigen und unabhängigen Variablen beschreibt.
    • 4. Modellbewertung mit Metriken wie R^2, MSE usw.
    • 5. Verwendung des Modells zur Erstellung von Vorhersagen und zur Interpretation der Koeffizienten.
  • K-Means Clustering:
    • 1. Daten sammeln (Keine Anforderungen an Labels).
    • 2. Auswahl der Anzahl der Cluster (K).
    • 3. Initialisieren der Clusterzentren (zufällig oder anderweitig).
    • 4. Datenpunkte zuweisen zum nächsten Clusterzentrum basierend auf der minimalen Distanz (meistens euklidische Distanz).
    • 5. Berechnung neuer Clusterzentren als Mittelwert der zugehörigen Punkte.
    • 6. Wiederholen der Schritte 4 und 5, bis sich die Clusterzentren nicht mehr signifikant ändern.
• Anwendungsbereiche:
  • Lineare Regression:
    • Anwendung in der Wirtschaft zur Umsatzprognose und zur Analyse des Einflusses von Marketingausgaben auf den Absatz.
    • In der Medizin zur Vorhersage des Risikos von Krankheiten basierend auf Patientenmerkmalen wie Alter, Gewicht und Blutdruck.
    • In der Ökonomie zur Modellierung und Vorhersage von Preisentwicklungen auf dem Aktienmarkt.
  • K-Means Clustering:
    • Segmentierung von Kunden basierend auf deren Kaufverhalten im Einzelhandel.
    • Bildkompression, indem Farben in einem Bild in eine bestimmte Anzahl von Farbclustern gruppiert werden.
    • Erkennung von Mustern in der Genexpression in der Bioinformatik.

• Lineare Regression: Ein Unternehmen verwendet lineare Regression, um die Verkaufszahlen für das nächste Quartal basierend auf den Werbeausgaben, der Saison und anderen Faktoren vorherzusagen. Hier werden historische Verkaufsdaten und entsprechende Ausgaben genutzt, um ein Modell zu erstellen, das zukünftige Vertriebszahlen prognostiziert.
• K-Means Clustering: Ein Online-Händler segmentiert seine Kunden in verschiedene Gruppen basierend auf deren Browsing-Verhalten und Kaufhistorie, um maßgeschneiderte Marketingkampagnen zu erstellen. Hier gibt es keine Zielvariable, sondern das Ziel ist es, ähnliche Verhaltensmuster in den Kundendaten zu erkennen und auszunutzen.

b)

Berechne die Parameterschätzung für eine einfache lineare Regression anhand des gegebenen Datensatzes:

x = [1, 2, 3, 4], y = [2, 3, 5, 7]

Nutze dabei die Methode der kleinsten Quadrate. Lege alle Zwischenschritte deiner Berechnung dar und stelle die finalen Parameter \(\beta_1\) und \(\beta_0\) grafisch dar. Vergleiche dies abschließend mit einem Beispiel eines Clustering-Ergebnisses von K-Means Clustering und erläutere, warum K-Means für diese Art von Problem nicht geeignet wäre.

Lösung:

Berechnung der Parameterschätzung für eine einfache lineare Regression:

• Gegebener Datensatz:

  x = [1, 2, 3, 4], y = [2, 3, 5, 7]

• Ziel ist die Berechnung der Regressionsgleichung in der Form: \(y = \beta_0 + \beta_1 x\)

Schritt-für-Schritt Berechnung:

1. Berechnung der Mittelwerte:
   • Mittelwert von \(x\) (\(\bar{x}\)):

   \[\bar{x} = \frac{1+2+3+4}{4} = \frac{10}{4} = 2.5\]

2. Mittelwert von \(y\) (\(\bar{y}\)):

\[\bar{y} = \frac{2+3+5+7}{4} = \frac{17}{4} = 4.25\]

3. Berechnung der Regressionskoeffizienten:
   • \(\beta_1\) (Steigung):

   \[\beta_1 = \frac{\text{Cov}(x, y)}{\text{Var}(x)}\]

   • \[\text{Cov}(x, y) = \frac{\sum{(x_i - \bar{x})(y_i - \bar{y})}}{n}\]

   \[\text{Cov}(x, y) = \frac{(1-2.5)(2-4.25) + (2-2.5)(3-4.25) + (3-2.5)(5-4.25) + (4-2.5)(7-4.25)}{4}\]

   \[\text{Cov}(x, y) = \frac{(-1.5)(-2.25) + (-0.5)(-1.25) + (0.5)(0.75) + (1.5)(2.75)}{4}\]

   \[\text{Cov}(x, y) = \frac{3.375 + 0.625 + 0.375 + 4.125}{4} = \frac{8.5}{4} = 2.125\]

4. \[\text{Var}(x) = \frac{(1-2.5)^2 + (2-2.5)^2 + (3-2.5)^2 + (4-2.5)^2}{4}\]

\[\text{Var}(x) = \frac{(-1.5)^2 + (-0.5)^2 + (0.5)^2 + (1.5)^2}{4}\]

\[\text{Var}(x) = \frac{2.25 + 0.25 + 0.25 + 2.25}{4} = \frac{5}{4} = 1.25\]

5. Daraus folgt:

\[\beta_1 = \frac{2.125}{1.25} = 1.7\]

6. \(\beta_0\) (y-Achsenabschnitt):

\[\beta_0 = \bar{y} - \beta_1 \bar{x}\]

\[\beta_0 = 4.25 - 1.7 \times 2.5\]

\[\beta_0 = 4.25 - 4.25 = 0\]

Daher ist die finale Regressionsgleichung: \(y = 1.7x + 0\)

Grafische Darstellung der finalen Parameter:

Vergleich mit einem Clustering-Ergebnis von K-Means:

• Ziel von K-Means: Gruppieren von Datenpunkten in Cluster, um Muster und Strukturen zu erkennen.
• Zur Veranschaulichung ein Beispiel mit dem K-Means Clustering-Verfahren:
• 
• Warum K-Means für dieses Problem nicht geeignet ist:
  • Das Ziel der linearen Regression ist die Vorhersage von \(y\) anhand von \(x\) (abhängige vs. unabhängige Variable), was Labels benötigt. K-Means hingegen ist unüberwacht und findet nur Datenmuster.
  • Bei K-Means gibt es keine echte Vorhersagebeziehung zwischen \(x\) und \(y\), sondern nur Gruppierung von Datenpunkten.
  • Clustering kann keine Linie finden, die den Trend erklärt oder Vorhersagen auf Basis von \(x\) macht.

Aufgabe 3)

Du bist ein Datenwissenschaftler und arbeitest mit einem Cluster, der sowohl Hadoop als auch Spark für die Verarbeitung großer Datenmengen verwendet. Deine Aufgabe ist es, eine umfassende Analyse von Nutzungsdaten einer Online-Plattform durchzuführen. Die Datenmengen sind sehr groß und erfordern verteilte Verarbeitung.

a)

Erkläre den Unterschied zwischen HDFS aus Hadoop und dem In-Memory Verarbeitungsansatz von Spark. Gehe dabei auf die Art und Weise der Datenspeicherung und -verarbeitung ein. Welche Vor- und Nachteile hat jeder Ansatz in Bezug auf Performance und Ausfallsicherheit?

Lösung:

• HDFS (Hadoop Distributed File System): HDFS ist das verteilte Dateisystem von Hadoop, das darauf ausgelegt ist, sehr große Datenmengen auf einer Vielzahl von Standardhardwareknoten zu speichern.
  • Speicherung: HDFS speichert Daten in großen Blöcken (typischerweise 128 MB oder 256 MB) und repliziert jeden Block standardmäßig dreimal, um Ausfallsicherheit zu gewährleisten.
  • Verarbeitung: Die Verarbeitung erfolgt durch das MapReduce-Framework, bei dem Daten von der Festplatte gelesen, verarbeitet und dann wieder geschrieben werden. Dies erfordert im Allgemeinen mehrere Festplatten-I/O-Operationen.
  • Vorteile:
    • Ausfallsicherheit: Dank der Replikation der Datenblöcke bietet HDFS eine hohe Ausfallsicherheit.
    • Skalierbarkeit: HDFS kann einfach durch das Hinzufügen weiterer Standardrechenknoten skaliert werden.
  • Nachteile:
    • Performance: Der wiederholte Zugriff auf Festplattenspeicher (I/O-Operationen) kann zu längeren Verarbeitungszeiten führen.
    • Latenz: Die Latenzzeiten können hoch sein, insbesondere bei sehr großen Datenmengen.
• In-Memory Verarbeitungsansatz von Spark: Spark ist ein Framework für die verteilte Datenverarbeitung, das besonders durch seine In-Memory-Fähigkeiten hervorsticht.
  • Speicherung: Spark speichert Daten im Arbeitsspeicher (RAM) anstatt auf der Festplatte. Dies ermöglicht einen schnellen Zugriff auf die Daten.
  • Verarbeitung: Da die Daten im Speicher gehalten werden, kann Spark sehr schnell darauf zugreifen und Verarbeitungen wie iterative Algorithmen effizient durchführen.
  • Vorteile:
    • Performance: Durch die Speicherung der Daten im RAM kann Spark sehr schnelle Verarbeitungszeiten erzielen, was sich besonders bei iterativen Algorithmen auszahlt.
    • Geringe Latenz: Die Latenzzeiten sind durch den In-Memory-Zugriff viel geringer im Vergleich zu Festplattenzugriffen.
  • Nachteile:
    • Speicheranforderungen: Der Bedarf an großem Arbeitsspeicher kann die Kosten erhöhen und stellt eine Einschränkung dar, wenn große Datenmengen verarbeitet werden müssen.
    • Ausfallsicherheit: Daten im RAM gehen verloren, wenn ein Knoten ausfällt. Spark bietet jedoch mit RDDs (Resilient Distributed Datasets) Mechanismen zur Wiederherstellung von Daten, was den Nachteil teilweise abmildert.

b)

Implementiere mithilfe von PySpark einen einfachen MapReduce-Job zur Berechnung der Anzahl der Besuche pro Benutzer. Beachte dabei die Verwendung von RDDs. Der Eingabedatensatz (input) ist eine Textdatei, in der jede Zeile wie folgt aufgebaut ist: 'userID,timestamp' . Der Algorithmus soll das Ergebnis als Textdatei ausgeben. Zeige den vollständigen Code inklusive der Erstellung des RDD und der Anwendung der Transformationen und Aktionen.

Lösung:

• Implementierung eines einfachen MapReduce-Jobs mit PySpark: Hier ist der vollständige Code zur Berechnung der Anzahl der Besuche pro Benutzer mithilfe von PySpark und RDDs. Der Eingabedatensatz ist eine Textdatei, in der jede Zeile die Struktur 'userID,timestamp' hat. Das Ergebnis wird als Textdatei ausgegeben.

from pyspark import SparkContext, SparkConf# Spark-Kontext und Konfigurationconf = SparkConf().setAppName('UserVisitsCount').setMaster('local[*]')sc = SparkContext(conf=conf)# Eingabedatei leseninput_path = 'path/to/your/input/file.txt'output_path = 'path/to/your/output/directory'input_rdd = sc.textFile(input_path)# Transformationen und Aktionen# Schritt 1: Jede Zeile in ein Tupel (userID, 1) umwandelnuser_visits = input_rdd.map(lambda line: (line.split(',')[0], 1))# Schritt 2: Anzahl der Besuche pro Benutzer summierenuser_visits_counts = user_visits.reduceByKey(lambda a, b: a + b)# Schritt 3: Ergebnis als Textdatei speichernuser_visits_counts.saveAsTextFile(output_path)# Spark-Kontext stoppensc.stop()

• Erklärung:
  • Zeilen 1-12: Einrichtung des Spark-Kontexts und der Konfiguration.
  • Zeilen 14-18: Lesen der Eingabedatei und Erstellung des initialen RDD.
  • Zeile 21: Transformation: Jede Zeile wird in ein Tupel umgewandelt, wobei der erste Wert die userID und der zweite Wert die Anzahl 1 ist.
  • Zeile 24: Transformation: reduceByKey wird verwendet, um die Anzahl der Besuche pro Benutzer zu summieren.
  • Zeilen 27: Aktion: Das Ergebnis wird als Textdatei in dem angegebenen Verzeichnis gespeichert.
  • Zeile 30: Stoppen des Spark-Kontexts nach Abschluss der Aufgabe.

Aufgabe 4)

Objekterkennung in der ComputervisionAutomatische Identifikation und Klassifikation von Objekten in Bildern oder Videos.

• Verwendung von Algorithmen und Modellen wie CNNs.
• Bestandteile: Merkmalsextraktion, Klassifizierung.
• Verfahren: Region Proposal Networks (RPN), YOLO, SSD.
• Loss-Funktion häufig: Kreuzentropie-Verlust \[ L_{CE} = - \sum (y \log(\hat{y})) \]
• Wichtige Metriken: Genauigkeit, Präzision, Recall.

b)

Implementiere ein einfaches YOLO-Modell in Python. Erkläre dabei den Code Schritt für Schritt und erläutere insbesondere, wie das Modell Objekte in einem Bild lokalisiert und klassifiziert. Verwende für die Implementierung folgende Pseudocode-Struktur:

'class YOLO:''    def __init__(self, ...):''        # Initialization ''    def forward_pass(self, image):''        # Apply convolutional layers''        # Generate bounding boxes and class probabilities''    def decode_predictions(self, outputs):''        # Process the network output to obtain final bounding boxes and class labels'

Lösung:

Implementierung eines einfachen YOLO-Modells in PythonIn dieser Implementierung zeigen wir die wesentlichen Schritte, um ein einfaches YOLO (You Only Look Once) Modell zu erstellen. YOLO ist ein Echtzeit-Objekterkennungsalgorithmus, der ein einziges neuronales Netzwerk verwendet, um sowohl die Lokalisierung als auch die Klassifizierung von Objekten in einem Bild durchzuführen.Hier ist der Pseudocode in Python umgesetzt und detailliert erklärt:

import torchimport torch.nn as nnimport numpy as npclass YOLO(nn.Module):    def __init__(self, num_classes):        super(YOLO, self).__init__()        self.num_classes = num_classes        # Initialisierung der Convolutional Layers        self.conv_layers = self._build_conv_layers()        # Ein Fully-connected Layer (oder Linear Layer) für die Ausgabe        self.fc = nn.Linear(1024 * 7 * 7, 7 * 7 * (5 + self.num_classes))    def _build_conv_layers(self):        layers = []        # Beispielhafter Aufbau der Convolutional Layers (nicht vollständig)        layers.append(nn.Conv2d(3, 32, kernel_size=3, padding=1))        layers.append(nn.ReLU(inplace=True))        layers.append(nn.MaxPool2d(kernel_size=2, stride=2, padding=0))        # Weitere Convolutional und Pooling Layers können hier hinzugefügt werden        return nn.Sequential(*layers)    def forward_pass(self, image):        # Bild durch die Convolutional Layers leiten        x = self.conv_layers(image)        # Bild flach machen        x = x.view(x.size(0), -1)        # Durch das Fully-connected Layer leiten        x = self.fc(x)        # Ausgabe in gewünschtens Format umformen        outputs = x.view(x.size(0), 7, 7, 5 + self.num_classes)        return outputs    def decode_predictions(self, outputs, confidence_threshold=0.5):        batch_size = outputs.size(0)        grid_size = outputs.size(1)        bbox_predictions = []        for i in range(batch_size):            boxes = []            for y in range(grid_size):                for x in range(grid_size):                    # Extract bounding box parameters                    box = outputs[i, y, x, :5].data                    conf = box[4]                    if conf >= confidence_threshold:                        class_scores = outputs[i, y, x, 5:].data                        class_id = torch.argmax(class_scores)                        class_conf = class_scores[class_id]                        final_conf = conf * class_conf                        boxes.append((box[:4], class_id, final_conf))            bbox_predictions.append(boxes)        return bbox_predictions# Beispiel der Benutzung:# yolo = YOLO(num_classes=20)# image = torch.randn((1, 3, 224, 224))  # Dummy Image# outputs = yolo.forward_pass(image)# bbox_predictions = yolo.decode_predictions(outputs)

• Initialisierung der YOLO-Klasse: Im Konstruktor der YOLO-Klasse wird die Anzahl der Klassen definiert und die Convolutional Layers sowie die Fully-connected Layer werden initialisiert.
• _build_conv_layers()-Methode: Hier werden mehrere Convolutional und Pooling Layers erstellt. In dieser einfacheren Implementierung zeigen wir nur einen Layer, aber im vollständigen Modell gibt es mehrere solcher Layer.
• forward_pass-Methode: Diese Methode führt die Eingabebilder durch die Convolutional Layers, formt die resultierenden Tensors flach und leitet sie durch eine Fully-connected Layer. Die Ausgabe wird schließlich in eine geeignete Form umgewandelt.
• decode_predictions-Methode: Diese Methode verarbeitet die Ausgaben des Netzwerks, um die endgültigen Bounding Boxes und Klassifizierungslabels zu erhalten. Hierbei werden die unnormalisierten Boxen und potentiell die zugehörigen Klassen extrahiert, basierend auf einem Konfidenzschwellenwert.