Praktische Lineare Algebra für Data Science

Kapitel 4. Vektorielle Anwendungen

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: [e-mail]

Während du die beiden vorangegangenen Kapitel durchgearbeitet hast, hattest du vielleicht das Gefühl, dass einige der Inhalte esoterisch und abstrakt sind. Vielleicht hattest du das Gefühl, dass sich die Herausforderung, lineare Algebra zu lernen, nicht auszahlt, wenn es darum geht, reale Anwendungen im Bereich Data Science und maschinelles Lernen zu verstehen.

Ich hoffe, dass dieses Kapitel diese Zweifel ausräumt. In diesem Kapitel lernst du, wie Vektoren und Vektoroperationen in datenwissenschaftlichen Analysen verwendet werden. Und du wirst dieses Wissen in den Übungen vertiefen können.

Korrelation und Kosinusähnlichkeit

Die Korrelation ist eine der grundlegendsten und wichtigsten Analysemethoden in der Statistik und im maschinellen Lernen. Ein Korrelationskoeffizient ist eine einzelne Zahl, die die lineare Beziehung zwischen zwei Variablen angibt. Die Korrelationskoeffizienten reichen von -1 bis +1, wobei -1 für eine perfekte negative Beziehung, +1 für eine perfekte positive Beziehung und 0 für keine lineare Beziehung steht. Abbildung 4-1 zeigt ein paar Beispiele für Variablenpaare und ihre Korrelationskoeffizienten.

Abbildung 4-1. Beispiele für Daten, die eine positive Korrelation, eine negative Korrelation und eine Nullkorrelation aufweisen. Das rechte untere Feld verdeutlicht, dass die Korrelation ein lineares Maß ist; nichtlineare Beziehungen zwischen Variablen können auch dann bestehen, wenn ihre Korrelation null ist.

In Kapitel 2 habe ich erwähnt, dass das Punktprodukt am Korrelationskoeffizienten beteiligt ist und dass die Größe des Punktprodukts mit der Größe der numerischen Werte in den Daten zusammenhängt (erinnere dich an die Diskussion über die Verwendung von Gramm gegenüber Pfund bei der Gewichtsmessung). Deshalb muss der Korrelationskoeffizient normalisiert werden, damit er in dem erwarteten Bereich von -1 bis +1 liegt. Diese beiden Normalisierungen sind:

Mittlere Mitte jeder Variable

Mittelwertzentrierung bedeutet, dass der Durchschnittswert von jedem Datenwert abgezogen wird.

Dividiere das Punktprodukt durch das Produkt der Vektornormen

Diese teilende Normalisierung hebt die Messeinheiten auf und skaliert die maximal mögliche Korrelationsgröße auf |1|.

Gleichung 4-1 zeigt die vollständige Formel für den Pearson-Korrelationskoeffizienten.

Gleichung 4-1. Formel für den Korrelationskoeffizienten nach Pearson

$$\rho =\frac{{\sum }_{i=1}^n(x_i-\overline{x})(y_i-\overline{y})}{\sqrt{{\sum }_{i=1}^n{(x_i-\overline{x})}^2}\sqrt{{\sum }_{i=1}^n{(y_i-\overline{y})}^2}}$$

Es ist vielleicht nicht offensichtlich, dass die Korrelation einfach aus drei Punktprodukten besteht. Gleichung 4-2 zeigt dieselbe Formel, die mit der Punktproduktschreibweise der linearen Algebra umgeschrieben wurde. In dieser Gleichung $\widetilde{𝐱}$ die mittelwert-zentrierte Version von $𝐱$ (das heißt, die Variable $𝐱$ mit angewandter Normalisierung #1).

Gleichung 4-2. Die Pearson-Korrelation, ausgedrückt in der Sprache der linearen Algebra

$$\rho =\frac{{\widetilde{𝐱}}^{\text{T}}\widetilde{𝐲}}{\parallel \widetilde{𝐱}\parallel \parallel \widetilde{𝐲}\parallel }$$

Da hast du es: Der berühmte und weit verbreitete Korrelationskoeffizient nach Pearson ist einfach das Punktprodukt zwischen zwei Variablen, normiert durch die Größen der Variablen. (Übrigens kannst du aus dieser Formel auch ersehen, dass, wenn die Variablen einheitsnormiert sind, wie folgt $\parallel 𝐱\parallel =\parallel 𝐲\parallel =1$dann ist ihre Korrelation gleich ihrem Punktprodukt. (Erinnere dich an Übung 2-6, dass $\parallel 𝐱\parallel =\sqrt{{𝐱}^{\text{T}}𝐱}$.)

Die Korrelation ist nicht die einzige Möglichkeit, die Ähnlichkeit zwischen zwei Variablen zu bewerten. Eine andere Methode ist die Kosinus-Ähnlichkeit. Die Formel für die Kosinusähnlichkeit ist einfach die geometrische Formel für das Punktprodukt(Gleichung 2-11), gelöst für den Kosinusterm:

$$cos\left({\theta }_{x,y}\right)=\frac{\alpha }{\parallel 𝐱\parallel \parallel 𝐲\parallel }$$

wobei $\alpha$ ist das Punktprodukt zwischen $𝐱$ und $𝐲$.

Es mag so aussehen, als ob Korrelation und Kosinusähnlichkeit genau dieselbe Formel sind. Erinnere dich aber daran, dass Gleichung 4-1 die vollständige Formel ist, während Gleichung 4-2 eine Vereinfachung ist, die davon ausgeht, dass die Variablen bereits mittig zentriert wurden. Bei der Kosinusähnlichkeit wird also der erste Normalisierungsfaktor nicht berücksichtigt.

Korrelation versus Kosinusähnlichkeit

Was bedeutet es, dass zwei Variablen "verwandt" sind? Die Pearson-Korrelation und die Cosinus-Ähnlichkeit können für dieselben Daten unterschiedliche Ergebnisse liefern, weil sie von unterschiedlichen Annahmen ausgehen. In den Augen von Pearson sind die Variablen [0, 1, 2, 3] und [100, 101, 102, 103] perfekt korreliert ($\rho =1$), weil sich Änderungen in einer Variablen genau in der anderen Variablen widerspiegeln; es spielt keine Rolle, dass eine Variable größere Zahlenwerte hat. Die Kosinusähnlichkeit zwischen diesen Variablen beträgt jedoch 0,808 - sie liegen nicht auf derselben numerischen Skala und sind daher nicht perfekt miteinander verbunden. Keines der beiden Maße ist falsch oder besser als das andere; es ist einfach so, dass verschiedene statistische Methoden unterschiedliche Annahmen über die Daten machen, und diese Annahmen haben Auswirkungen auf die Ergebnisse - und auf die richtige Interpretation. Du wirst in Übung 4-2 Gelegenheit haben, dies zu untersuchen.

Anhand dieses Abschnitts kannst du verstehen, warum die Pearson-Korrelation und die Kosinusähnlichkeit die lineare Beziehung zwischen zwei Variablen widerspiegeln: Sie basieren auf dem Punktprodukt, und das Punktprodukt ist eine lineare Operation.

Zu diesem Abschnitt gehören vier Kodierübungen, die am Ende des Kapitels erscheinen. Du kannst wählen, ob du diese Aufgaben lösen willst, bevor du den nächsten Abschnitt liest, oder ob du den Rest des Kapitels weiterliest und dann die Aufgaben durcharbeitest. (Ich persönlich empfehle Ersteres, aber du bist der Herr über dein lineares Algebra-Schicksal!)

Filterung von Zeitreihen und Erkennung von Merkmalen

Das Punktprodukt wird auch bei der Filterung von Zeitreihen verwendet. Bei der Filterung handelt es sich im Wesentlichen um eine Methode zur Erkennung von Merkmalen, bei der eine Vorlage - im Fachjargon Kernel genannt - mit Teilen eines Zeitreihensignals abgeglichen wird. Das Ergebnis der Filterung ist eine andere Zeitreihe, die angibt, inwieweit die Eigenschaften des Signals mit den Eigenschaften des Kernels übereinstimmen. Kernel werden sorgfältig konstruiert, um bestimmte Kriterien zu optimieren, z. B. gleichmäßige Schwankungen, scharfe Kanten, bestimmte Wellenformenusw.

Der Mechanismus der Filterung besteht darin, das Punktprodukt zwischen dem Kernel und dem Zeitreihensignal zu berechnen. Die Filterung erfordert jedoch in der Regel eine lokale Merkmalserkennung, und der Kernel ist in der Regel viel kürzer als die gesamte Zeitreihe. Deshalb berechnen wir das Punktprodukt zwischen dem Kernel und einem kurzen Ausschnitt der Daten, der genauso lang ist wie der Kernel. Dieses Verfahren erzeugt einen Zeitpunkt im gefilterten Signal(Abbildung 4-2). Dann wird der Kernel einen Zeitschritt nach rechts verschoben, um das Punktprodukt mit einem anderen (überlappenden) Signalsegment zu berechnen. Formal wird dieses Verfahren als Faltung bezeichnet und umfasst einige zusätzliche Schritte, die ich hier auslasse, um mich auf die Anwendung des Punktprodukts in der Signalverarbeitung zu konzentrieren.

Abbildung 4-2. Illustration der Zeitreihenfilterung

Zeitliche Filterung ist ein wichtiges Thema in Wissenschaft und Technik. Ohne zeitliche Filterung gäbe es keine Musik, kein Radio, keine Telekommunikation, keine Satelliten usw. Und doch ist das mathematische Herz, das deine Musik am Laufen hält, das Vektorpunktprodukt.

In den Übungen am Ende des Kapitels erfährst du, wie Punktprodukte verwendet werden, um Merkmale (Kanten) zu erkennen und Zeitreihendaten zu glätten.

k-Means Clustering

Dask-means Clustering ist eine unüberwachte Methode zur Klassifizierung multivariater Daten in eine relativ kleine Anzahl von Gruppen oder Kategorien, die auf der Minimierung des Abstands zum Gruppenzentrum basieren.

Dask-means Clustering ist eine wichtige Analysemethode im maschinellen Lernen, und es gibt ausgefeilte Varianten des k-means Clustering. Hier werden wir eine einfache Version von k-means implementieren, um zu sehen, wie Konzepte über Vektoren (insbesondere: Vektoren, Vektornormen und Übertragung) im k-means-Algorithmus verwendet werden.

Hier ist eine kurze Beschreibung des Algorithmus, den wir schreiben werden:

1. Initialisiere k Zentren als zufällige Punkte im Datenraum. Jeder Schwerpunkt ist eine Klasse oder Kategorie, und in den nächsten Schritten werden die Datenbeobachtungen den einzelnen Klassen zugeordnet. (Ein Schwerpunkt ist ein Zentrum, das auf eine beliebige Anzahl von Dimensionen verallgemeinert wird).

2. Berechne den euklidischen Abstand zwischen jeder Datenbeobachtung und jedemSchwerpunkt.¹

3. Ordne jede Datenbeobachtung der Gruppe mit dem nächstgelegenen Schwerpunkt zu.

4. Aktualisiere jeden Schwerpunkt als Durchschnitt aller Datenbeobachtungen, die diesem Schwerpunkt zugeordnet sind.

5. Wiederhole die Schritte 2 bis 4, bis ein Konvergenzkriterium erfüllt ist, oder für N Iterationen.

Wenn du mit der Python-Programmierung vertraut bist und diesen Algorithmus implementieren möchtest, solltest du das tun, bevor du fortfährst. Als Nächstes werden wir die Mathematik und den Code für jeden dieser Schritte durchgehen, wobei wir uns besonders auf die Verwendung von Vektoren und die Übertragung in NumPy konzentrieren. Außerdem werden wir den Algorithmus mit zufällig generierten 2D-Daten testen, um zu bestätigen, dass unser Code korrekt ist.

Beginnen wir mit Schritt 1: Initialisierung von k zufälligen Clusterschwerpunkten. k ist ein Parameter des k-means Clustering; in realen Daten ist es schwierig, das optimale k zu bestimmen, aber hier werden wir k = 3 festlegen. Es gibt verschiedene Möglichkeiten, zufällige Clusterschwerpunkte zu initialisieren; der Einfachheit halber wähle ich k Datenproben zufällig als Schwerpunkte aus. Die Daten sind in der Variable data enthalten (diese Variable ist 150 × 2, was 150 Beobachtungen und 2 Merkmalen entspricht) und werden in Abbildung 4-3 oben links dargestellt (der Online-Code zeigt, wie diese Daten erzeugt werden):

k = 3
ridx = np.random.choice(range(len(data)),k,replace=False)
centroids = data[ridx,:] # data matrix is samples by features

Nun zu Schritt 2: Berechne den Abstand zwischen jeder Datenbeobachtung und jedem Clusterschwerpunkt. Hier wenden wir die Konzepte der linearen Algebra an, die du in den vorherigen Kapiteln gelernt hast. Für eine Datenbeobachtung und einen Schwerpunkt wird der euklidische Abstand wie folgt berechnet

$${\delta }_{i,j}=\sqrt{{(d_i^x-c_j^x)}^2+{(d_i^y-c_j^y)}^2}$$

wobei ${\delta }_{i,j}$ den Abstand zwischen der Datenbeobachtung i und dem Schwerpunkt j angibt, _dxi das Merkmal x der i-tenDatenbeobachtung und _cxj die x-Achsenkoordinate des Schwerpunkts j ist.

Du könntest denken, dass dieser Schritt mit einer doppelten for Schleife umgesetzt werden muss: eine Schleife über k Zentren und eine zweite Schleife über N Datenbeobachtungen (du könntest sogar an eine dritte for Schleife über Datenmerkmale denken). Wir können jedoch Vektoren und Broadcasting verwenden, um diesen Vorgang kompakt und effizient zu gestalten. Dies ist ein Beispiel dafür, dass lineare Algebra in Gleichungen oft anders aussieht als im Code:

dists = np.zeros((data.shape[0],k))
for ci in range(k):
  dists[:,ci] = np.sum((data-centroids[ci,:])**2,axis=1)

Denken wir an die Größe dieser Variablen: data ist 150 × 2 (Beobachtungen nach Merkmalen) und centroids[ci,:] ist 1 × 2 (Cluster ci nach Merkmalen). Formal ist es nicht möglich, diese beiden Vektoren zu subtrahieren. Python implementiert jedoch das Broadcasting, indem es die Clusterschwerpunkte 150 Mal wiederholt und somit den Schwerpunkt von jeder Datenbeobachtung subtrahiert. Die Exponenten-Operation ** wird elementweise angewendet, und die Eingabe axis=1 weist Python an, über die Spalten zu summieren (separat pro Zeile). Die Ausgabe von np.sum() ist also ein 150 × 1 Array, das den euklidischen Abstand jedes Punktes zum Schwerpunkt ci kodiert.

Nimm dir einen Moment Zeit und vergleiche den Code mit der Entfernungsformel. Sind sie wirklich identisch? Eigentlich nicht: Die Quadratwurzel aus dem euklidischen Abstand fehlt im Code. Ist der Code also falsch? Denke einen Moment darüber nach; die Antwort erkläre ich dir später.

Schritt 3 besteht darin, jede Datenbeobachtung der Gruppe mit dem geringsten Abstand zuzuordnen. Dieser Schritt ist in Python recht kompakt und kann mit einer Funktion implementiert werden:

groupidx = np.argmin(dists,axis=1)

Beachte den Unterschied zwischen np.min, das den Mindestwert zurückgibt, und np.argmin, das den Index zurückgibt, bei dem das Minimum auftritt.

Wir können nun auf die Inkonsistenz zwischen der Distanzformel und ihrer Code-Implementierung zurückkommen. Bei unserem k-means-Algorithmus verwenden wir die Distanz, um jeden Datenpunkt dem nächstgelegenen Schwerpunkt zuzuordnen. Der Abstand und der quadrierte Abstand sind monoton zueinander, so dass beide Metriken die gleiche Antwort liefern. Das Hinzufügen der Quadratwurzel-Operation erhöht die Komplexität des Codes und die Berechnungszeit, ohne sich auf die Ergebnisse auszuwirken.

Schritt 4 besteht darin, die Schwerpunkte als Mittelwert aller Datenpunkte innerhalb der Klasse neu zu berechnen. Hier können wir eine Schleife über die k Cluster laufen lassen und die Python-Indizierung verwenden, um alle Datenpunkte zu finden, die den einzelnen Clustern zugeordnet sind:

for ki in range(k):
  centroids[ki,:] = [ np.mean(data[groupidx==ki,0]),
                      np.mean(data[groupidx==ki,1])  ]

In Schritt 5 werden die vorherigen Schritte in einer Schleife zusammengefasst, die so lange wiederholt wird, bis eine gute Lösung erreicht ist. Bei k-means-Algorithmen auf Produktionsebene werden die Iterationen so lange fortgesetzt, bis ein Stoppkriterium erreicht ist, z. B. dass sich die Clusterschwerpunkte nicht mehr bewegen. Der Einfachheit halber werden wir hier drei Iterationen durchführen (eine willkürliche Zahl, die so gewählt wurde, dass das Diagramm visuell ausgewogen ist).

Die vier Felder in Abbildung 4-3 zeigen die anfänglichen zufälligen Clusterschwerpunkte (Iteration 0) und ihre aktualisierten Positionen nach jeder der drei Iterationen.

Wenn du dich mit Clustering-Algorithmen beschäftigst, lernst du ausgefeilte Methoden für die Initialisierung von Zentren und Stoppkriterien sowie quantitative Methoden zur Auswahl eines geeigneten k-Parameters kennen. Dennoch sind alle k-means-Methoden im Wesentlichen Erweiterungen des obigen Algorithmus, und die lineare Algebra ist das Herzstück ihrer Implementierungen.

Abbildung 4-3. k-means

Code-Übungen

Korrelationsübungen

Übung 4-1.

Schreibe eine Python-Funktion, die zwei Vektoren als Eingabe nimmt und zwei Zahlen als Ausgabe liefert: den Pearson-Korrelationskoeffizienten und den Cosinus-Ähnlichkeitswert. Schreibe einen Code, der den in diesem Kapitel vorgestellten Formeln folgt; rufe nicht einfach np.corrcoef und spatial.distance.cosine auf. Überprüfe, ob die beiden Ausgabewerte identisch sind, wenn die Variablen bereits mittig zentriert sind, und unterschiedlich, wenn die Variablen nicht mittig zentriert sind.

Übung 4-2.

Lass uns weiter den Unterschied zwischen Korrelation und Kosinusähnlichkeit erforschen. Erstelle eine Variable, die die ganzen Zahlen 0 bis 3 enthält, und eine zweite Variable, die der ersten Variable plus einem Offset entspricht. Dann erstellst du eine Simulation, in der du diesen Offset systematisch zwischen -50 und +50 variierst (d.h. in der ersten Iteration der Simulation ist die zweite Variable gleich [-50, -49, -48, -47]). Berechne in einer for Schleife die Korrelation und die Kosinusähnlichkeit zwischen den beiden Variablen und speichere diese Ergebnisse. Erstelle dann ein Liniendiagramm, das zeigt, wie die Korrelation und die Kosinusähnlichkeit durch den Mittelwertversatz beeinflusst werden. Du solltest in der Lage sein, Abbildung 4-4 zu reproduzieren.

Abbildung 4-4. Ergebnisse der Übung 4-2

Übung 4-3.

Es gibt mehrere Python-Funktionen zur Berechnung des Pearson-Korrelationskoeffizienten. Eine davon heißt pearsonr und befindet sich im Modul stats der SciPy-Bibliothek. Öffne den Quellcode dieser Datei (Hinweis: ??functionname) und vergewissere dich, dass du verstehst, wie die Python-Implementierung auf die in diesem Kapitel vorgestellten Formeln passt.

Übung 4-4.

Warum musst du überhaupt eigene Funktionen programmieren, wenn es sie bereits in Python gibt? Ein Grund dafür ist, dass das Schreiben eigener Funktionen einen großen pädagogischen Wert hat, weil du siehst, dass es sich (in diesem Fall) um eine einfache Berechnung handelt und nicht um einen unglaublich ausgeklügelten Blackbox-Algorithmus, den nur ein promovierter Informatiker verstehen kann. Ein weiterer Grund ist, dass eingebaute Funktionen manchmal langsamer sind, weil sie unzählige Eingabeprüfungen durchführen, zusätzliche Eingabeoptionen verarbeiten, Datentypen umwandeln usw. Das erhöht die Benutzerfreundlichkeit, geht aber auf Kosten der Rechenzeit.

In dieser Übung sollst du herausfinden, ob deine eigene einfache Korrelationsfunktion schneller ist als die corrcoef Funktion von NumPy. Ändere die Funktion aus Übung 4-2 so ab, dass nur der Korrelationskoeffizient berechnet wird. Erzeuge dann in einer for Schleife über 1.000 Iterationen zwei Variablen mit 500 Zufallszahlen und berechne die Korrelation zwischen ihnen. Stoppe die for Schleife. Wiederhole dann den Vorgang mit np.corrcoef. In meinen Tests war die benutzerdefinierte Funktion etwa 33 % schneller als np.corrcoef. In diesen Beispielen werden die Unterschiede in Millisekunden gemessen, aber wenn du Milliarden von Korrelationen mit großen Datensätzen durchführst, summieren sich diese Millisekunden wirklich! (Wenn du deine eigenen Funktionen ohne Eingabeprüfungen schreibst, besteht die Gefahr von Eingabefehlern, die von np.corrcoef abgefangen werden). (Beachte auch, dass der Geschwindigkeitsvorteil bei größeren Vektoren zusammenbricht. Probiere es aus!)

Übungen zum Filtern und Erkennen von Merkmalen

Übung 4-5.

Lass uns einen Kanten-Detektor bauen. Der Kernel für einen Kanten-Detektor ist sehr einfach: [-1 +1]. Das Punktprodukt dieses Kerns mit einem Ausschnitt eines Zeitreihensignals mit konstantem Wert (z. B. [10 10]) ist 0. Aber dieses Punktprodukt ist groß, wenn das Signal eine steile Veränderung aufweist (z. B. würde [1 10] ein Punktprodukt von 9 ergeben). Das Signal, mit dem wir arbeiten werden, ist eine Plateaufunktion. Die Diagramme A und B in Abbildung 4-5 zeigen den Kernel und das Signal. Der erste Schritt in dieser Übung besteht darin, einen Code zu schreiben, der diese beiden Zeitreihen erzeugt.

Abbildung 4-5. Ergebnisse der Übung 4-5

Als Nächstes schreibst du eine for Schleife über die Zeitpunkte des Signals. Berechne zu jedem Zeitpunkt das Punktprodukt zwischen dem Kernel und einem Segment der Zeitreihendaten, das die gleiche Länge wie der Kernel hat. Du solltest ein Diagramm erstellen, das wie das Diagramm C in Abbildung 4-5 aussieht. (Konzentriere dich mehr auf das Ergebnis als auf die Ästhetik.) Beachte, dass unser Kantendetektor 0 zurückgegeben hat, wenn das Signal flach war, +1, wenn das Signal nach oben gesprungen ist, und -1, wenn das Signal nach unten gesprungen ist.

Du kannst diesen Code gerne weiter erforschen. Ändert sich zum Beispiel etwas, wenn du den Kernel mit Nullen auffüllst ([0 -1 1 0])? Was ist, wenn du den Kernel umdrehst, so dass er [1 -1] ist? Wie sieht es aus, wenn der Kernel asymmetrisch ist ([-1 2])?

Übung 4-6.

Jetzt wiederholen wir das gleiche Verfahren, aber mit einem anderen Signal und Kernel. Das Ziel ist es, eine robuste Zeitreihe zu glätten. Die Zeitreihe besteht aus 100 Zufallszahlen, die aus einer Gauß-Verteilung (auch Normalverteilung genannt) erzeugt werden. Der Kernel ist eine glockenförmige Funktion, die eine Gaußsche Funktion annähert, definiert als die Zahlen [0, .1, .3, .8, 1, .8, .3, .1, 0], aber so skaliert, dass die Summe über den Kernel 1 ist. Dein Kernel sollte dem Diagramm A in Abbildung 4-6 entsprechen, obwohl dein Signal aufgrund der Zufallszahlen nicht genau wie das Diagramm B aussehen wird.

Kopiere den Code aus der vorherigen Übung und passe ihn an, um die gleitende Zeitreihe der Punktprodukte zu berechnen - das mit dem Gauß-Kernel gefilterte Signal. Achtung: Achte auf die Indexierung in der Schleife for. Grafik C in Abbildung 4-6 zeigt ein Beispielergebnis. Du kannst sehen, dass das gefilterte Signal eine geglättete Version des ursprünglichen Signals ist. Dies wird auch als Tiefpassfilterung bezeichnet.

Abbildung 4-6. Ergebnisse der Übung 4-6

Übung 4-7.

Ersetze die 1 in der Mitte des Kernels durch -1 und zentriere den Kernel. Führe dann den Filter- und Plotting-Code erneut aus. Was ist das Ergebnis? Es hebt die scharfen Merkmale tatsächlich hervor! Tatsächlich ist dieser Kernel jetzt ein Hochpassfilter, d.h. er dämpft die glatten (niederfrequenten) Merkmale und hebt die sich schnell verändernden (hochfrequenten) Merkmale hervor.

k-Means-Übungen

Übung 4-8.

Eine Möglichkeit, das optimale k zu ermitteln, ist, das Clustering mehrmals zu wiederholen (jedes Mal mit zufällig initialisierten Clusterzentren) und zu prüfen, ob das endgültige Clustering gleich oder unterschiedlich ist. Ohne neue Daten zu generieren, wiederholst du den k-means Code mehrmals mit k = 3, um zu sehen, ob die resultierenden Cluster ähnlich sind (dies ist eine qualitative Bewertung, die auf einer visuellen Inspektion beruht). Scheinen die endgültigen Clusterzuordnungen im Allgemeinen ähnlich zu sein, obwohl die Zentren zufällig ausgewählt wurden?

Übung 4-9.

Wiederhole die Mehrfachclusterung mit k = 2 und k = 4. Was hältst du von diesen Ergebnissen?

¹ Zur Erinnerung: Der euklidische Abstand ist die Quadratwurzel aus der Summe der quadrierten Abstände zwischen der Datenbeobachtung und dem Schwerpunkt.