Artikel

6.2: Lineare Karten und Funktionale. Matrizen


Für eine adäquate Definition der Differenzierbarkeit benötigen wir den Begriff einer linearen Abbildung. Unten bezeichnen (E^{prime}, E^{primeprime},) und (E) normierte Räume über dem gleichen Skalarkörper (E^{1}) oder (C .)

Definition 1

Eine Funktion (f : E^{prime} ightarrow E) ist genau dann eine lineare Abbildung, wenn für alle (vec{x}, vec{y} in E^{prime}) und Skalare (a, b)

[f(avec{x}+bvec{y})=a f(vec{x})+b f(vec{y});]

äquivalent, wenn für alle solchen (vec{x}, vec{y},) und (a)

[f(vec{x}+vec{y})=f(x)+f(y) ext { und } f(avec{x})=a f(vec{x}). ext {(Überprüfen!)}]

Falls (E=E^{prime},) ist eine solche Abbildung auch ein linearer Operator.

Ist der Bereichsraum (E) der Skalarkörper von (E^{prime},) (dh (E^{1}) oder (C,)), dann ist der lineare (f ) heißt auch ein (reelles oder komplexes) lineares Funktional auf (E^{prime}.)

Anmerkung 1. Induktion erweitert Formel (1) auf beliebige "Linearkombinationen":

[fleft(sum_{i=1}^{m} a_{i} vec{x}_{i} ight)=sum_{i=1}^{m} a_{i} f left(vec{x}_{i} ight)]

für alle (vec{x}_{i}in E^{prime}) und Skalare (a_{i}).

Kurz: Eine lineare Abbildung (f) bewahrt Linearkombinationen.

Anmerkung 2. Nehmen wir (a=b=0) in (1), so erhalten wir (f(overrightarrow{0})=0), falls (f) linear ist.

Beispiele

(a) Sei (E^{prime}=E^{n}left(C^{n} ight).) Fixiere einen Vektor (vec{v}=left(v_{1} , ldots, v_{n} ight)) in (E^{prime}) und Menge

[left(forallvec{x}in E^{prime} ight) quad f(vec{x})=vec{x} cdot vec{v}]

(inneres Produkt; siehe Kapitel 3, §§1-3 und §9).

Dann

[egin{ausgerichtet} f(avec{x}+bvec{y}) &=(avec{x}) cdot vec{v}+(bvec{y}) cdot vec{v} &=a(vec{x} cdot vec{v})+b(vec{y} cdot vec{v}) &=af(vec{ x})+bf(vec{y}); end{ausgerichtet}]

also ist (f) linear. Beachten Sie, dass, wenn (E^{prime}=E^{n},) dann per Definition

[f(vec{x})=vec{x} cdot vec{v}=sum_{k=1}^{n} x_{k} v_{k}=sum_{k=1 }^{n} v_{k} x_{k}.]

Ist jedoch (E^{prime}=C^{n},) dann

[f(vec{x})=vec{x} cdot vec{v}=sum_{k=1}^{n} x_{k} overline{v}_{k}= Summe_{k=1}^{n} overline{v}_{k} x_{k},]

wobei (overline{v}_{k}) die Konjugierte der komplexen Zahl (v_{k}) ist.

Nach Satz 3 in Kapitel 4, §3, ist (f) stetig (ein Polynom!).

Außerdem ist (f(vec{x})=vec{x} cdot vec{v}) ein Skalar (in (E^{1}) oder (C).) Also der Bereich von (f) liegt im Skalarkörper von (E^{prime};), also ist (f) ein lineares Funktional auf (E^{prime}.)

(b) Sei (I=[0,1].) Sei (E^{prime}) die Menge aller Funktionen (u : I ightarrow E) der Klasse (CD ^{infty}) (Kapitel 5, §6) auf (I), also dort beschränkt (Satz 2 von Kapitel 4, §8).

Wie in Beispiel (C) in Kapitel 3, §10, ist (E^{prime}) ein normierter linearer Raum mit norm

[|u|=sup_{xin I}|u(x)|.]

Hier wird jede Funktion (uin E^{prime}) als einzelner "Punkt" in (E^{prime}) behandelt
Abstand zwischen zwei solchen Punkten, (u) und (v,) ist per Definition gleich (|u-v|,).

Definieren Sie nun eine Abbildung (D) auf (E^{prime}) durch Setzen von (D(u)=u^{prime}) (Ableitung von (u) auf (I )). Da jedes (uin E^{prime}) von der Klasse (CD^{infty},) ist, ist auch (u^{prime}.)

Somit ist (D(u)=u^{prime}in E^{prime},) und damit (D : E^{prime} ightarrow E^{prime}) eine lineare Operator. (Seine Linearität folgt aus Satz 4 in Kapitel 5, §1.)

(c) Sei wieder (I=[0,1].) Sei (E^{prime}) die Menge aller Funktionen (u : I ightarrow E), die beschränkt sind und Stammfunktionen haben (Kapitel 5, §5) auf (I.) Mit Norm (|u|) wie in Beispiel (b) ist (E^{prime}) ein normierter linearer Raum.

Definiere nun (phi : E^{prime} ightarrow E) durch

[phi(u)=int_{0}^{1} u,]

mit (int u) wie in Kapitel 5, §5. (Erinnern Sie sich, dass (int_{0}^{1} u) ein Element von (E) ist, wenn (u : I ightarrow E.) ) Nach Korollar 1 in Kapitel 5, §5, (phi) ist eine lineare Abbildung von (E^{prime}) in (E). (Warum?)

(d) Die Nullabbildung (f=0) auf (E^{prime}) ist immer linear. (Warum?)

Satz (PageIndex{1})

Eine lineare Abbildung (f : E^{prime} ightarrow E) ist (sogar gleichmäßig) auf ganz (E^{prime}) stetig, wenn sie in (overrightarrow{0} ;) äquivalent, falls es ein reelles (c>0) gibt mit

[left(forallvec{x}in E^{prime} ight) quad|f(vec{x})| leqc|vec{x}|.]

(Wir nennen diese Eigenschaft lineare Beschränktheit.)

Beweis

Angenommen (f) sei stetig bei (overrightarrow{0}.) Dann gibt es (varepsilon>0,) (delta>0) mit

[|f(vec{x})-f(overrightarrow{0})|=|f(vec{x})| leq varepsilon]

wann immer (|vec{x}-overrightarrow{0}|=|vec{x}|

Nun gilt für jedes (vec{x} eq overrightarrow{0},) sicherlich

[left|frac{delta vec{x}}{|vec{x}|} ight|=frac{delta}{2}

Daher

[(forall vec{x} eq overrightarrow{0}) quadleft|fleft(frac{delta vec{x}}{2|vec{x}|} ight ) echts| leq varepsilon,]

oder, durch Linearität,

[frac{delta}{2|vec{x}|}|f(vec{x})| leq varepsilon,]

d.h.,

[|f(vec{x})| leq frac{2 varepsilon}{delta}|vec{x}|.]

Nach Anmerkung 2 gilt dies auch, wenn (vec{x}=overrightarrow{0}).

Mit (c=2 varepsilon / delta,) erhalten wir also

[left(forallvec{x}in E^{prime} ight) quad f(vec{x}) leq c|vec{x}| quad ext {(lineare Beschränktheit).}]

Nehmen wir nun an (3). Dann

[left(forall vec{x}, vec{y} in E^{prime} ight) quad|f(vec{x}-vec{y})| leq c|vec{x}-vec{y}|;]

oder, durch Linearität,

[left(forall vec{x}, vec{y} in E^{prime} ight) quad|f(vec{x})-f(vec{y})| leq c|vec{x}-vec{y}|.]

Daher ist (f) gleichmäßig stetig (gegeben (varepsilon>0,) nehme (delta=varepsilon / c).) Dies wiederum impliziert Stetigkeit an (overrightarrow{0}; ) alle Bedingungen sind also wie behauptet äquivalent. (quad quadrat)

Eine lineare Abbildung muss nicht stetig sein. Aber für (E^{n}) und (C^{n},) haben wir folgendes Ergebnis.

Satz (PageIndex{2})

(i) Jede lineare Abbildung auf (E^{n}) oder (C^{n}) ist gleichmäßig stetig.

(ii) Jedes lineare Funktional auf (E^{n}left(C^{n} ight)) hat die Form

[f(vec{x})=vec{x} cdot vec{v} quad ext {(Punktprodukt)}]

für einen eindeutigen Vektor (vec{v}in E^{n}left(C^{n} ight),) nur abhängig von (f).

Beweis

Angenommen (f : E^{n} ightarrow E) ist linear; also erhält (f) Linearkombinationen.

Aber jedes (vec{x}in E^{n}) ist eine solche Kombination,

[vec{x}=sum_{k=1}^{n} x_{k} vec{e}_{k} quad ext {(Satz 2 in Kapitel 3, §§1-3) .}]

Somit ist nach Anmerkung 1

[f(vec{x})=fleft(sum_{k=1}^{n} x_{k} vec{e}_{k} ight)=sum_{k=1} ^{n} x_{k} fleft(vec{e}_{k} ight).]

Hier sind die Funktionswerte (fleft(vec{e}_{k} ight)) feste Vektoren im Entfernungsraum (E,) z.

[fleft(vec{e}_{k} ight)=v_{k}in E,]

so dass

[f(vec{x})=sum_{k=1}^{n} x_{k} fleft(vec{e}_{k} ight)=sum_{k=1} ^{n} x_{k} v_{k}, quad v_{k} in E.]

Also ist (f) ein Polynom in (n) reellen Variablen (x_{k},) also stetig (auch gleichmäßig nach Satz 1).

Insbesondere wenn (E=E^{1}) (d. h. (f) ein lineares Funktional ist), dann sind alle (v_{k}) in (5) reelle Zahlen; sie bilden also einen Vektor

[vec{v}=left(v_{1}, ldots, v_{k} ight) ext { in } E^{n},]

und (5) kann geschrieben werden als

[f(vec{x})=vec{x} cdot vec{v}.]

Der Vektor (vec{v}) ist eindeutig. Angenommen, es gibt zwei Vektoren (vec{u}) und (vec{v},) mit

[left(forallvec{x}in E^{n} ight) quad f(vec{x})=vec{x} cdot vec{v}=vec{x } cdot vec{u}.]

Dann

[left(forall vec{x} in E^{n} ight) quad vec{x} cdot(vec{v}-vec{u})=0.]

Nach Aufgabe 10 von Kapitel 3, §§1-3, ergibt dies (vec{v}-vec{u}=overrightarrow{0},) oder (vec{v}=vec{u }.) Damit ist der Beweis für (E=E^{n}.) abgeschlossen.

Analog gilt für (C^{n};) nur in (ii) sind die (v_{k}) komplex und man muss sie durch ihre Konjugierten (overline{v}_{k} ) bei der Bildung des Vektors (vec{v}), um (f(vec{x})=vec{x} cdot vec{v}) zu erhalten. Damit ist alles bewiesen. (quad quadrat)

Notiz 3. Formel (5) zeigt, dass eine lineare Abbildung (f : E^{n}left(C^{n} ight) ightarrow E) eindeutig durch die (n) Funktionswerte (v_{ k}=fleft(vec{e}_{k} ight)).

Falls weiterhin (E=E^{m}left(C^{m} ight),) die Vektoren (v_{k}) (m) -Tupel von Skalaren sind,

[v_{k}=left(v_{1k}, ldots, v_{mk} ight).]

Wir schreiben solche Vektoren oft vertikal, als (n) "Spalten" in einem Array von (m) "Zeilen" und (n) "Spalten":

[left(egin{array}{cccc}{v_{11}} & {v_{12}} & {dots} & {v_{1 n}} {v_{21}} & {v_ {22}} & {dots} & {v_{2 n}} {vdots} & {vdots} & {ddots} & {vdots} {v_{m 1}} & {v_ {m 2}} & {dots} & {v_{mn}} end{array} ight).]

Formal ist (6) eine doppelte Folge von (m n)-Termen, die als (m imes n)-Matrix bezeichnet wird. Wir bezeichnen es mit ([f]=left(v_{i k} ight),) wobei für (k=1,2, ldots, n)

[fleft(vec{e}_{k} ight)=v_{k}=left(v_{1k}, ldots, v_{mk} ight).]

Somit entsprechen lineare Abbildungen (f : E^{n} ightarrow E^{m}) (oder (f : C^{n} ightarrow C^{m})) eins zu eins ihrem Matrizen ([f].)

Der einfache Beweis der Korollare 1 bis 3 unten bleibt dem Leser überlassen.

Folgerung (PageIndex{1})

Wenn (f, g : E^{prime} ightarrow E) linear sind, ist auch

[h=a f+b g]

für beliebige Skalare (a, b).

Falls weiterhin (E^{prime}=E^{n}left(C^{n} ight)) und (E=E^{m}left(C^{m} ight) ,) mit ([f]=left(v_{ik} ight)) und ([g]=left(w_{ik} ight)), dann

[[h]=left(a v_{i k}+b w_{i k} ight).]

Folgerung (PageIndex{2})

Eine Abbildung (f : E^{n}left(C^{n} ight) ightarrow E) ist linear genau dann, wenn

[f(vec{x})=sum_{k=1}^{n} v_{k} x_{k},]

wobei (v_{k}=fleft(vec{e}_{k} ight)).

Hinweis: Verwenden Sie für das "wenn" Korollar 1. Für das "nur wenn" verwenden Sie die obige Formel (5).

Folgerung (PageIndex{3})

Wenn (f : E^{prime} ightarrow E^{primeprime}) und (g : E^{primeprime} ightarrow E) linear sind, so ist auch die zusammengesetzte ( h=g circ f.)

Unser nächster Satz beschäftigt sich mit der Matrix der zusammengesetzten linearen Abbildung (gcirc f)

Satz (PageIndex{3})

Seien (f : E^{prime} ightarrow E^{prime prime}) und (g : E^{primeprime} ightarrow E) linear, mit

[E^{prime}=E^{n}left(C^{n} ight), E^{primeprime}=E^{m}left(C^{m} ight ), ext { und } E=E^{r}left(C^{r} ight).]

Wenn ([f]=left(v_{i k} ight)) und ([g]=left(w_{j i} ight),) dann

[[h]=[gcirc f]=left(z_{jk} ight),]

wo

[z_{jk}=sum_{i=1}^{m} w_{ji} v_{ik}, quad j=1,2, ldots, r, k=1,2, ldots, n .]

Beweis

Bezeichne die Basiseinheitsvektoren in (E^{prime}) mit

[e_{1}^{prime}, ldots, e_{n}^{prime},]

die in (E^{prime prime}) durch

[e_{1}^{prime prime}, ldots, e_{m}^{prime prime},]

und die in (E) durch

[e_{1}, ldots, e_{r}.]

Dann gilt für (k=1,2, ldots, n),

[fleft(e_{k}^{prime} ight)=v_{k}=sum_{i=1}^{m} v_{ik} e_{i}^{prime prime} ext { und } hleft(e_{k}^{prime} ight)=sum_{j=1}^{r} z_{jk} e_{j},]

und für (i=1, dots m),

[gleft(e_{i}^{prime prime} ight)=sum_{j=1}^{r} w_{j i} e_{j}.]

Ebenfalls,

[hleft(e_{k}^{prime} ight)=gleft(fleft(e_{k}^{prime} ight) ight)=gleft(sum_{ i=1}^{m} v_{ik} e_{i}^{prime prime} ight)=sum_{i=1}^{m} v_{ik} gleft(e_{i} ^{primeprime} ight)=sum_{i=1}^{m} v_{ik}left(sum_{j=1}^{r} w_{ji} e_{j} ight ).]

So

[hleft(e_{k}^{prime} ight)=sum_{j=1}^{r} z_{jk} e_{j}=sum_{j=1}^{r} left(sum_{i=1}^{m} w_{ji} v_{ik} ight) e_{j}.]

Aber die Darstellung in Bezug auf (e_{j}) ist eindeutig (Satz 2 in Kapitel 3, §§1-3), also erhalten wir beim Gleichsetzen der Koeffizienten (7). (quad quadrat)

Hinweis 4. Beachten Sie, dass (z_{jk}) sozusagen durch "Punktmultiplikation" der (j)-ten Zeile von ([g]) (einer (r imes m) Matrix ) durch die (k)-te Spalte von ([f]) (eine (m imes n)-Matrix).

Es ist natürlich zu setzen

[[g][f]=[g circ f],]

oder

[left(w_{j i} ight)left(v_{i k} ight)=left(z_{j k} ight),]

mit (z_{jk}) wie in (7).

Vorsicht. Die so definierte Matrixmultiplikation ist nicht kommutativ.

Definition 2

Die Menge aller stetigen linearen Abbildungen (f : E^{prime} ightarrow E) (für feste (E^{prime}) und (E)) wird mit (L(E^ {prime}, E).)

Wenn (E=E^{prime},) ist, schreiben wir stattdessen (L(E)).

Für jedes (f) in (Lleft(E^{prime}, E ight),) definieren wir seine Norm durch

[|f|=sup_{|vec{x}| leq 1}|f(vec{x})|.]

Beachte, dass (|f|<+infty,) nach Satz 1 gilt.

Satz (PageIndex{4})

(L(E^{prime}, E)) ist ein normierter linearer Raum unter der oben definierten Norm und unter den üblichen Operationen auf Funktionen, wie in Korollar 1.

Beweis

Korollar 1 impliziert leicht, dass (L(E^{prime}, E)) ein Vektorraum ist. Wir zeigen nun, dass (|cdot|) eine echte Norm ist.

Das Dreiecksgesetz,

[|f+g| leq|f|+|g|,]

folgt genau wie in Beispiel (C) von Kapitel 3, §10. (Überprüfen!)

Außerdem gilt nach Aufgabe 5 in Kapitel 2, §§8-9, (sup |af(vec{x})|=|a|sup |f(vec{x})|.) Also (|af|=|a||f|) für jeden Skalar (a.)

Wie oben erwähnt, (0 leq|f|<+infty).

Es bleibt zu zeigen, dass (|f|=0) genau dann gilt, wenn (f) die Nullabbildung ist. Wenn

[|f|=sup_{|vec{x}| leq 1}|f(vec{x})|=0,]

dann (|f(vec{x})|=0), wenn (|vec{x}|leq 1.) Also, wenn (vec{x} eq overrightarrow{0} ),

[f(frac{vec{x}}{|vec{x}|})=frac{1}{|vec{x}|} f(vec{x})=0. ]

Da (f(overrightarrow{0})=0,) gilt (f(vec{x})=0) für alle (vec{x}in E^{prime} ).

Somit impliziert (|f|=0) (f=0,) und die Umkehrung ist klar. (quad quadrat)

Hinweis 5. Ein ähnlicher Beweis über (fleft(frac{vec{x}}{|vec{x}|} ight)) und Eigenschaften von lub zeigt, dass

[|f|=sup_{vec{x} eq 0}left|frac{f(vec{x})}{|vec{x}|} ight|]

und

[(forallvec{x}in E^{prime}) quad|f(vec{x})| leq|f||vec{x}|.]

Daraus folgt auch, dass (|f|) das kleinste reelle (c) ist, so dass

[(forallvec{x}in E^{prime}) quad|f(vec{x})| leqc|vec{x}|.]

Überprüfen. (Siehe Problem 3'.)

Wie in jedem normierten Raum definieren wir Abstände in (L(E^{prime}, E)) durch

[ ho(f, g)=|f-g|,]

einen metrischen Raum machen; wir können also von Konvergenz, Grenzen usw. darin sprechen.

Folgerung (PageIndex{4})

Wenn (fin L(E^{prime}, E^{primeprime})) und (gin L(E^{primeprime}, E),) dann

[|g circ f| leq|g||f|.]

Beweis

Nach Anmerkung 5,

[left(forallvec{x}in E^{prime} ight) quad|g(f(vec{x}))| leq|g||f(vec{x})| leq|g||f||vec{x}|.]

Daher

[(forallvec{x} eqoverrightarrow{0}) quadleft|frac{(gcirc f)(vec{x})}{|vec{x}|} richtig| leq|g||f|,]

und so

[|g||f| geq sup_{vec{x} eq overline{0}} frac{|(g circ f)(vec{x})|}{|vec{x}|}=| g circ f|. quad square]


Matrixoperationen¶

Im Zentrum der Linearen Algebra stehen lineare Operationen auf Vektoren. Die einfachste davon ist die Linearkombination zweier Vektoren (amathbf_1 + b mathbf_2) :

Eine weitere wichtige Operation ist die innere (oder Punkt) Produkt (d. h. die Summe der elementweisen Produkte). Das innere Produkt wird üblicherweise für zwei (Spalten-)Vektoren mit (mathbf_1 cdot mathbf_2) oder (mathbf_1^T mathbf_2) . In SymPy kann das innere Produkt auf zwei Arten berechnet werden:

Ebenso die äußeres Produkt (mathbf_1 mathbf_2^T) zweier Spaltenvektoren können über

Wahrscheinlich die am wichtigsten Operation im gesamten wissenschaftlichen Rechnen ist das Produkt einer Matrix und eines Vektors. Die gerade beobachteten inneren und äußeren Produkte sind Spezialfälle der Matrix-Vektor-Multiplikation. Eine allgemeinere Matrix-Matrix-Multiplikation kann als Folge von Matrix-Vektor-Multiplikationen betrachtet werden. SymPy handhabt die Matrix-Vektor-Multiplikation mit Leichtigkeit:

Grundsätzlich kann die Matrix-Vektor-Multiplikation in eine Folge einfacherer Vektoroperationen zerlegt werden. Sie haben höchstwahrscheinlich die Definition der “Reihe von Punktprodukten” gelernt, bei der das innere Produkt jeder Zeile von (mathbf) mit dem Vektor (mathbf) definiert ein Element des maxrix-Vektorprodukts. Für unser Beispiel wäre dies definiert als

Diese spaltenorientierte Ansicht ist unglaublich nützlich und wird seit langem von Gilbert Strang am MIT gefördert (dessen buchfreie Videos zur linearen Algebra ziemlich gut sind!).


5.3. Tupel und Sequenzen¶

Wir haben gesehen, dass Listen und Strings viele gemeinsame Eigenschaften haben, wie z. Sie sind zwei Beispiele für Reihenfolge Datentypen (siehe Sequenztypen — list, tuple, range ). Da Python eine sich entwickelnde Sprache ist, können andere Sequenzdatentypen hinzugefügt werden. Es gibt noch einen weiteren Standard-Sequenzdatentyp: Tupel.

Ein Tupel besteht aus einer Reihe von durch Kommas getrennten Werten, zum Beispiel:

Wie Sie sehen, werden bei der Ausgabe Tupel immer in Klammern eingeschlossen, damit verschachtelte Tupel korrekt interpretiert werden, können sie mit oder ohne umgebende Klammern eingegeben werden, obwohl oft Klammern ohnehin notwendig sind (wenn das Tupel Teil eines größeren Ausdrucks ist). Eine Zuordnung zu den einzelnen Items eines Tupels ist nicht möglich, jedoch ist es möglich Tupel zu erstellen, die veränderbare Objekte, wie zB Listen, enthalten.

Obwohl Tupel Listen ähnlich erscheinen mögen, werden sie oft in verschiedenen Situationen und für unterschiedliche Zwecke verwendet. Tupel sind unveränderlich und enthalten normalerweise eine heterogene Folge von Elementen, auf die durch Entpacken (siehe weiter unten in diesem Abschnitt) oder Indexieren (oder im Fall von benannten Tupeln sogar per Attribut) zugegriffen wird. Listen sind veränderbar und ihre Elemente sind normalerweise homogen und werden durch Iteration über die Liste aufgerufen.

Ein besonderes Problem ist die Konstruktion von Tupeln, die 0 oder 1 Elemente enthalten: Die Syntax hat einige zusätzliche Eigenheiten, um diese zu berücksichtigen. Leere Tupel werden durch ein leeres Klammerpaar konstruiert ein Tupel mit einem Element wird konstruiert, indem einem Wert ein Komma folgt (es reicht nicht aus, einen einzelnen Wert in Klammern einzuschließen). Hässlich, aber effektiv. Beispielsweise:

Die Aussage t = 12345, 54321, 'Hallo!' ist ein Beispiel für Tupelverpackung: die Werte 12345 , 54321 und 'Hallo!' sind in einem Tupel zusammengepackt. Auch der umgekehrte Betrieb ist möglich:

Dies nennt man passenderweise Reihenfolge Auspacken und funktioniert für jede Sequenz auf der rechten Seite. Das Entpacken einer Sequenz erfordert, dass sich auf der linken Seite des Gleichheitszeichens so viele Variablen befinden, wie die Sequenz Elemente enthält. Beachten Sie, dass die Mehrfachzuweisung eigentlich nur eine Kombination aus Tupelpacken und Sequenzentpacken ist.


6.2: Lineare Karten und Funktionale. Matrizen

Im letzten Abschnitt haben wir das Problem der Bildklassifizierung vorgestellt, bei der es sich um die Aufgabe handelt, einem Bild aus einer festen Menge von Kategorien ein einzelnes Label zuzuweisen. Darüber hinaus haben wir den k-Nearest Neighbor (kNN)-Klassifikator beschrieben, der Bilder kennzeichnet, indem er sie mit (annotierten) Bildern aus dem Trainingssatz vergleicht. Wie wir gesehen haben, hat kNN eine Reihe von Nachteilen:

  • Der Klassifikator muss merken alle Trainingsdaten und speichern sie für zukünftige Vergleiche mit den Testdaten. Dies ist platzsparend, da Datasets leicht Gigabyte groß sein können.
  • Das Klassifizieren eines Testbildes ist teuer, da es einen Vergleich mit allen Trainingsbildern erfordert.

Überblick. Wir werden jetzt einen leistungsfähigeren Ansatz zur Bildklassifizierung entwickeln, den wir schließlich natürlich auf ganze neuronale Netze und neuronale Faltungsnetze ausweiten werden. Der Ansatz besteht aus zwei Hauptkomponenten: a Punktefunktion das die Rohdaten den Klassenergebnissen zuordnet, und a verlustfunktion die die Übereinstimmung zwischen den vorhergesagten Werten und den Ground-Truth-Labels quantifiziert. Wir werden dies dann als Optimierungsproblem formen, bei dem wir die Verlustfunktion in Bezug auf die Parameter der Bewertungsfunktion minimieren.

Parametrisiertes Mapping von Bildern zu Label-Scores

Die erste Komponente dieses Ansatzes besteht darin, die Bewertungsfunktion zu definieren, die die Pixelwerte eines Bildes auf Konfidenzbewertungen für jede Klasse abbildet. Wir werden den Ansatz anhand eines konkreten Beispiels erarbeiten. Nehmen wir wie zuvor einen Trainingsdatensatz von Bildern ( x_i in R^D ) an, die jeweils mit einem Label ( y_i ) verknüpft sind. Hier ( i = 1 dots N ) und ( y_i in < 1 dots K >). Das heißt, wir haben Nein Beispiele (jeweils mit einer Dimensionalität D) und K unterschiedliche Kategorien. Zum Beispiel haben wir in CIFAR-10 einen Trainingssatz von Nein = 50.000 Bilder, jedes mit D = 32 x 32 x 3 = 3072 Pixel und K = 10, da es 10 verschiedene Klassen gibt (Hund, Katze, Auto usw.). Wir werden nun die Bewertungsfunktion (f: R^D mapsto R^K) definieren, die die rohen Bildpixel auf Klassenbewertungen abbildet.

Linearer Klassifikator. In diesem Modul beginnen wir mit der wohl einfachsten Funktion, einer linearen Abbildung:

In der obigen Gleichung nehmen wir an, dass das Bild (x_i) alle seine Pixel auf einen einzelnen Spaltenvektor der Form [D x 1] abgeflacht hat. Die Matrix W (der Größe [K x D]), und der Vektor b (der Größe [K x 1]) sind die Parameter der Funktion. In CIFAR-10 enthält (x_i) alle Pixel im i-ten Bild, die in eine einzelne [3072 x 1]-Spalte abgeflacht sind, W ist [10 x 3072] und b ist [10 x 1], also kommen 3072 Zahlen in die Funktion (die rohen Pixelwerte) und 10 Zahlen kommen heraus (die Klassenwerte). Die Parameter in W werden oft genannt Gewichte, und b heißt der Bias-Vektor weil es die Ausgabewerte beeinflusst, aber ohne mit den tatsächlichen Daten (x_i) zu interagieren. Sie werden jedoch oft hören, dass die Leute die Begriffe verwenden Gewichte und Parameter austauschbar.

Es gibt ein paar Dinge zu beachten:

  • Beachten Sie zunächst, dass die Single-Matrix-Multiplikation (W x_i) effektiv 10 separate Klassifikatoren parallel auswertet (einen für jede Klasse), wobei jeder Klassifikator eine Reihe von ist W.
  • Beachten Sie auch, dass wir uns die Eingabedaten ( (x_i, y_i) ) als gegeben und fest vorstellen, aber wir haben die Kontrolle über die Einstellung der Parameter W,b. Unser Ziel wird es sein, diese so festzulegen, dass die berechneten Werte mit den Ground-Truth-Labels des gesamten Trainingssatzes übereinstimmen. Wir werden viel detaillierter darauf eingehen, wie dies geschieht, aber intuitiv wünschen wir, dass die richtige Klasse eine Punktzahl hat, die höher ist als die Punktzahl der falschen Klassen.
  • Ein Vorteil dieses Ansatzes ist, dass die Trainingsdaten verwendet werden, um die Parameter zu lernen W,b, aber sobald das Lernen abgeschlossen ist, können wir den gesamten Trainingssatz verwerfen und nur die gelernten Parameter behalten. Das liegt daran, dass ein neues Testbild einfach durch die Funktion weitergeleitet und basierend auf den berechneten Scores klassifiziert werden kann.
  • Beachten Sie schließlich, dass das Klassifizieren des Testbilds eine einzelne Matrixmultiplikation und -addition umfasst, was erheblich schneller ist als das Vergleichen eines Testbilds mit allen Trainingsbildern.

Vorahnung: Convolutional Neural Networks werden Bildpixel genau wie oben gezeigt auf Scores abbilden, aber die Abbildung ( f ) wird komplexer sein und mehr Parameter enthalten.

Interpretieren eines linearen Klassifikators

Beachten Sie, dass ein linearer Klassifikator die Punktzahl einer Klasse als gewichtete Summe aller ihrer Pixelwerte über alle 3 ihrer Farbkanäle berechnet. Je nachdem, welche Werte wir für diese Gewichte genau festlegen, kann die Funktion bestimmte Farben an bestimmten Positionen im Bild mögen oder nicht mögen (je nach Vorzeichen der einzelnen Gewichte). Sie können sich beispielsweise vorstellen, dass die Klasse „Schiff“ wahrscheinlicher ist, wenn die Seiten eines Bildes viel Blau aufweisen (was wahrscheinlich Wasser entsprechen könnte). Sie könnten erwarten, dass der Klassifikator „Schiff“ dann viele positive Gewichtungen in seinen blauen Kanalgewichtungen hat (das Vorhandensein von Blau erhöht die Punktzahl des Schiffes) und negative Gewichtungen in den Rot/Grün-Kanälen (das Vorhandensein von Rot/Grün verringert die Punktzahl). des Schiffes).

Analogie von Bildern als hochdimensionale Punkte. Da die Bilder in hochdimensionale Spaltenvektoren gestreckt werden, können wir jedes Bild als einen einzelnen Punkt in diesem Raum interpretieren (z. B. ist jedes Bild in CIFAR-10 ein Punkt im 3072-dimensionalen Raum von 32 x 32 x 3 Pixeln). Analog ist der gesamte Datensatz eine (beschriftete) Menge von Punkten.

Da wir die Bewertung jeder Klasse als gewichtete Summe aller Bildpixel definiert haben, ist jede Klassenbewertung eine lineare Funktion über diesen Raum. Wir können uns keine 3072-dimensionalen Räume vorstellen, aber wenn wir uns vorstellen, all diese Dimensionen in nur zwei Dimensionen zu zerlegen, können wir versuchen, uns vorzustellen, was der Klassifikator tun könnte:

Wie wir oben gesehen haben, ist jede Zeile von (W) ein Klassifikator für eine der Klassen. Die geometrische Interpretation dieser Zahlen ist, dass sich die entsprechende Linie im Pixelraum in verschiedene Richtungen dreht, wenn wir eine der Zeilen von (W) ändern. Die Verzerrungen (b) hingegen ermöglichen es unseren Klassifikatoren, die Zeilen zu übersetzen. Beachten Sie insbesondere, dass das Einfügen von ( x_i = 0 ) ohne die Bias-Terme unabhängig von den Gewichtungen immer eine Punktzahl von Null ergeben würde, sodass alle Linien gezwungen wären, den Ursprung zu kreuzen.

Interpretation linearer Klassifikatoren als Template-Matching. Eine andere Interpretation für die Gewichte (W) ist, dass jede Zeile von (W) a Vorlage (oder manchmal auch als a . bezeichnet Prototyp) für eine der Klassen. Die Punktzahl jeder Klasse für ein Bild wird dann durch Vergleichen jeder Vorlage mit dem Bild unter Verwendung eines erhalten Innenprodukt (oder Skalarprodukt) nacheinander, um diejenige zu finden, die am besten „passt“. Bei dieser Terminologie führt der lineare Klassifikator einen Template-Matching durch, bei dem die Templates gelernt werden. Man kann es sich auch so vorstellen, dass wir Nearest Neighbor immer noch effektiv machen, aber anstatt Tausende von Trainingsbildern zu haben, verwenden wir nur ein einziges Bild pro Klasse (obwohl wir es lernen werden und es nicht unbedingt eines sein muss die Bilder im Trainingssatz), und wir verwenden das (negative) innere Produkt als Abstand anstelle des L1- oder L2-Abstands.

Beachten Sie außerdem, dass die Pferdevorlage ein zweiköpfiges Pferd zu enthalten scheint, was auf sowohl nach links als auch nach rechts gerichtete Pferde im Datensatz zurückzuführen ist. Der lineare Klassifikator verschmilzt diese beiden Pferdemodi in den Daten in eine einzige Vorlage. In ähnlicher Weise scheint der Autoklassifikator mehrere Modi in einer einzigen Vorlage zusammengeführt zu haben, die Autos von allen Seiten und in allen Farben identifizieren muss. Insbesondere wurde diese Vorlage rot, was darauf hindeutet, dass der CIFAR-10-Datensatz mehr rote Autos enthält als jede andere Farbe. Der lineare Klassifikator ist zu schwach, um verschiedenfarbige Autos richtig zu berücksichtigen, aber wie wir später sehen werden, werden neuronale Netze es uns ermöglichen, diese Aufgabe auszuführen. Mit Blick auf die Zukunft kann ein neuronales Netzwerk in seinen verborgenen Schichten Zwischenneuronen entwickeln, die bestimmte Fahrzeugtypen erkennen können (z. B. grünes Auto nach links, blaues Auto nach vorne usw.), und Neuronen auf der nächsten Schicht könnten diese kombinieren in eine genauere Fahrzeugbewertung durch eine gewichtete Summe der einzelnen Fahrzeugdetektoren.

Bias-Trick. Bevor wir fortfahren, möchten wir einen gemeinsamen Vereinfachungstrick erwähnen, um die beiden Parameter (W,b) als einen darzustellen. Denken Sie daran, dass wir die Bewertungsfunktion wie folgt definiert haben:

Während wir das Material durchgehen, ist es etwas mühsam, zwei Parametersätze (die Verzerrungen (b) und die Gewichte (W)) getrennt zu verfolgen. Ein häufig verwendeter Trick besteht darin, die beiden Parametersätze zu einer einzigen Matrix zu kombinieren, die beide enthält, indem der Vektor (x_i) um eine zusätzliche Dimension erweitert wird, die immer die Konstante (1) enthält - eine Vorgabe Bias-Dimension. Mit der zusätzlichen Dimension vereinfacht sich die neue Bewertungsfunktion zu einer einzelnen Matrixmultiplikation:

In unserem CIFAR-10-Beispiel ist (x_i) jetzt [3073 x 1] anstelle von [3072 x 1] - (wobei die zusätzliche Dimension die Konstante 1 hält), und (W) ist jetzt [10 x 3073 ] statt [10 x 3072]. Die zusätzliche Spalte (W) entspricht nun dem Bias (b). Eine Illustration könnte zur Verdeutlichung beitragen:

Vorverarbeitung der Bilddaten. Als kurze Anmerkung haben wir in den obigen Beispielen die Rohpixelwerte verwendet (die im Bereich von [0…255] liegen). Beim maschinellen Lernen ist es eine sehr gängige Praxis, Ihre Eingabe-Features immer zu normalisieren (bei Bildern wird jedes Pixel als Feature betrachtet). Insbesondere ist es wichtig, zentrieren Sie Ihre Daten indem man von jedem Merkmal den Mittelwert abzieht. Bei Bildern entspricht dies der Berechnung von a gemeines bild über die Trainingsbilder verteilt und von jedem Bild subtrahiert, um Bilder zu erhalten, deren Pixel im Bereich von ungefähr [-127 … 127] liegen. Eine weitere übliche Vorverarbeitung besteht darin, jedes Eingabe-Feature so zu skalieren, dass seine Werte von [-1, 1] reichen. Von diesen ist die Null-Mittelwert-Zentrierung wohl wichtiger, aber wir müssen auf ihre Rechtfertigung warten, bis wir die Dynamik des Gradientenabstiegs verstehen.

Verlustfunktion

Im vorherigen Abschnitt haben wir eine Funktion von den Pixelwerten zu Klassenwerten definiert, die durch einen Satz von Gewichten (W) parametrisiert wurde. Außerdem haben wir gesehen, dass wir keine Kontrolle über die Daten haben ( (x_i,y_i) ) (sie sind fest und gegeben), aber wir haben die Kontrolle über diese Gewichte und wollen sie so setzen, dass die vorhergesagte Klasse Scores stimmen mit den Ground-Truth-Labels in den Trainingsdaten überein.

Wenn wir zum Beispiel auf das Beispielbild einer Katze und ihre Bewertungen für die Klassen „Katze“, „Hund“ und „Schiff“ zurückgehen, sahen wir, dass der spezielle Gewichtssatz in diesem Beispiel überhaupt nicht gut war: Wir haben gefüttert in den Pixeln, die eine Katze darstellen, aber der Katzenwert war im Vergleich zu den anderen Klassen sehr niedrig (-96,8) (Hundewert 437,9 und Schiffswert 61,95). Wir werden unsere Unzufriedenheit mit Ergebnissen wie diesem mit a messen verlustfunktion (oder manchmal auch als . bezeichnet Kostenfunktion oder der Zielsetzung). Intuitiv wird der Verlust hoch sein, wenn wir die Trainingsdaten schlecht klassifizieren, und er wird gering sein, wenn wir gut abschneiden.

Verlust der Multiclass Support Vector Machine

Es gibt mehrere Möglichkeiten, die Details der Verlustfunktion zu definieren. Als erstes Beispiel werden wir zunächst einen gebräuchlichen Verlust namens Multiclass Support Vector Machine (SVM) Verlust. Der SVM-Verlust ist so eingerichtet, dass die SVM „will“, dass die richtige Klasse für jedes Bild eine Punktzahl hat, die um einen festen Abstand (Delta) höher ist als die der falschen Klassen. Beachten Sie, dass es manchmal hilfreich ist, die Verlustfunktionen wie oben beschrieben zu vermenschlichen: Die SVM „will“ ein bestimmtes Ergebnis in dem Sinne, dass das Ergebnis einen geringeren Verlust ergibt (was gut ist).

Lassen Sie uns nun genauer werden. Denken Sie daran, dass wir für das i-te Beispiel die Pixel des Bildes ( x_i ) und das Label ( y_i ) erhalten, das den Index der richtigen Klasse angibt. Die Score-Funktion nimmt die Pixel und berechnet den Vektor ( f(x_i, W) ) der Klassenergebnisse, den wir mit (s) (kurz für Scores) abkürzen. Zum Beispiel ist die Punktzahl für die j-te Klasse das j-te Element: ( s_j = f(x_i, W)_j ). Der Multiclass-SVM-Verlust für das i-te Beispiel wird dann wie folgt formalisiert:

[L_i = sum_ max(0, s_j - s_ + Delta)]

Beispiel. Packen wir dies mit einem Beispiel aus, um zu sehen, wie es funktioniert. Angenommen, wir haben drei Klassen, die die Punktzahlen ( s = [13, -7, 11]) erhalten, und die erste Klasse ist die wahre Klasse (d. h. (y_i = 0)). Nehmen Sie außerdem an, dass (Delta) (ein Hyperparameter, auf den wir in Kürze näher eingehen werden) 10 ist. Der obige Ausdruck summiert über alle falschen Klassen ((j eq y_i)), sodass wir zwei Terme erhalten:

[L_i = max(0, -7 - 13 + 10) + max(0, 11 - 13 + 10)]

Sie können sehen, dass der erste Term Null ergibt, da [-7 - 13 + 10] eine negative Zahl ergibt, die dann mit der Funktion (max(0,-)) auf Null reduziert wird. Wir erhalten null Verlust für dieses Paar, weil der korrekte Klassenwert (13) um mindestens 10 höher war als der falsche Klassenwert (-7). Tatsächlich betrug der Unterschied 20, was viel größer als 10 ist, aber nur die SVM kümmert sich darum, dass die Differenz mindestens 10 beträgt. Jede zusätzliche Differenz über der Marge wird bei der Max-Operation auf Null geklemmt. Der zweite Term berechnet [11 - 13 + 10], was 8 ergibt. Das heißt, obwohl die richtige Klasse eine höhere Punktzahl hatte als die falsche Klasse (13 > 11), war sie nicht um die gewünschte Marge von 10 höher. Die Differenz war nur 2, weshalb der Verlust 8 beträgt (dh wie viel höher die Differenz sein müsste, um die Marge zu erfüllen). Zusammenfassend möchte die SVM-Verlustfunktion, dass die Bewertung der richtigen Klasse (y_i) um mindestens (Delta) (Delta) größer ist als die Bewertungen der falschen Klasse. Ist dies nicht der Fall, kumulieren wir den Schaden.

Note that in this particular module we are working with linear score functions ( ( f(x_i W) = W x_i ) ), so we can also rewrite the loss function in this equivalent form:

[L_i = sum_ max(0, w_j^T x_i - w_^T x_i + Delta)]

where (w_j) is the j-th row of (W) reshaped as a column. However, this will not necessarily be the case once we start to consider more complex forms of the score function (f).

A last piece of terminology we’ll mention before we finish with this section is that the threshold at zero (max(0,-)) function is often called the hinge loss. You’ll sometimes hear about people instead using the squared hinge loss SVM (or L2-SVM), which uses the form (max(0,-)^2) that penalizes violated margins more strongly (quadratically instead of linearly). The unsquared version is more standard, but in some datasets the squared hinge loss can work better. This can be determined during cross-validation.

The loss function quantifies our unhappiness with predictions on the training set

Regularization. There is one bug with the loss function we presented above. Suppose that we have a dataset and a set of parameters W that correctly classify every example (i.e. all scores are so that all the margins are met, and (L_i = 0) for all i). The issue is that this set of W is not necessarily unique: there might be many similar W that correctly classify the examples. One easy way to see this is that if some parameters W correctly classify all examples (so loss is zero for each example), then any multiple of these parameters ( lambda W ) where ( lambda > 1 ) will also give zero loss because this transformation uniformly stretches all score magnitudes and hence also their absolute differences. For example, if the difference in scores between a correct class and a nearest incorrect class was 15, then multiplying all elements of W by 2 would make the new difference 30.

In other words, we wish to encode some preference for a certain set of weights W over others to remove this ambiguity. We can do so by extending the loss function with a regularization penalty (R(W)). The most common regularization penalty is the squared L2 norm that discourages large weights through an elementwise quadratic penalty over all parameters:

In the expression above, we are summing up all the squared elements of (W). Notice that the regularization function is not a function of the data, it is only based on the weights. Including the regularization penalty completes the full Multiclass Support Vector Machine loss, which is made up of two components: the data loss (which is the average loss (L_i) over all examples) and the regularization loss. That is, the full Multiclass SVM loss becomes:

Or expanding this out in its full form:

[L = frac<1> sum_i sum_ left[ max(0, f(x_i W)_j - f(x_i W)_ + Delta) ight] + lambda sum_ksum_l W_^2]

Where (N) is the number of training examples. As you can see, we append the regularization penalty to the loss objective, weighted by a hyperparameter (lambda). There is no simple way of setting this hyperparameter and it is usually determined by cross-validation.

In addition to the motivation we provided above there are many desirable properties to include the regularization penalty, many of which we will come back to in later sections. For example, it turns out that including the L2 penalty leads to the appealing max margin property in SVMs (See CS229 lecture notes for full details if you are interested).

The most appealing property is that penalizing large weights tends to improve generalization, because it means that no input dimension can have a very large influence on the scores all by itself. For example, suppose that we have some input vector (x = [1,1,1,1] ) and two weight vectors (w_1 = [1,0,0,0]), (w_2 = [0.25,0.25,0.25,0.25] ). Then (w_1^Tx = w_2^Tx = 1) so both weight vectors lead to the same dot product, but the L2 penalty of (w_1) is 1.0 while the L2 penalty of (w_2) is only 0.5. Therefore, according to the L2 penalty the weight vector (w_2) would be preferred since it achieves a lower regularization loss. Intuitively, this is because the weights in (w_2) are smaller and more diffuse. Since the L2 penalty prefers smaller and more diffuse weight vectors, the final classifier is encouraged to take into account all input dimensions to small amounts rather than a few input dimensions and very strongly. As we will see later in the class, this effect can improve the generalization performance of the classifiers on test images and lead to less overfitting.

Note that biases do not have the same effect since, unlike the weights, they do not control the strength of influence of an input dimension. Therefore, it is common to only regularize the weights (W) but not the biases (b). However, in practice this often turns out to have a negligible effect. Lastly, note that due to the regularization penalty we can never achieve loss of exactly 0.0 on all examples, because this would only be possible in the pathological setting of (W = 0).

Code. Here is the loss function (without regularization) implemented in Python, in both unvectorized and half-vectorized form:

The takeaway from this section is that the SVM loss takes one particular approach to measuring how consistent the predictions on training data are with the ground truth labels. Additionally, making good predictions on the training set is equivalent to minimizing the loss.

All we have to do now is to come up with a way to find the weights that minimize the loss.

Practical Considerations

Setting Delta. Note that we brushed over the hyperparameter (Delta) and its setting. What value should it be set to, and do we have to cross-validate it? It turns out that this hyperparameter can safely be set to (Delta = 1.0) in all cases. The hyperparameters (Delta) and (lambda) seem like two different hyperparameters, but in fact they both control the same tradeoff: The tradeoff between the data loss and the regularization loss in the objective. The key to understanding this is that the magnitude of the weights (W) has direct effect on the scores (and hence also their differences): As we shrink all values inside (W) the score differences will become lower, and as we scale up the weights the score differences will all become higher. Therefore, the exact value of the margin between the scores (e.g. (Delta = 1), or (Delta = 100)) is in some sense meaningless because the weights can shrink or stretch the differences arbitrarily. Hence, the only real tradeoff is how large we allow the weights to grow (through the regularization strength (lambda)).

Relation to Binary Support Vector Machine. You may be coming to this class with previous experience with Binary Support Vector Machines, where the loss for the i-th example can be written as:

[L_i = C max(0, 1 - y_i w^Tx_i) + R(W)]

where (C) is a hyperparameter, and (y_i in < -1,1 >). You can convince yourself that the formulation we presented in this section contains the binary SVM as a special case when there are only two classes. That is, if we only had two classes then the loss reduces to the binary SVM shown above. Also, (C) in this formulation and (lambda) in our formulation control the same tradeoff and are related through reciprocal relation (C propto frac<1>).

Aside: Optimization in primal. If you’re coming to this class with previous knowledge of SVMs, you may have also heard of kernels, duals, the SMO algorithm, etc. In this class (as is the case with Neural Networks in general) we will always work with the optimization objectives in their unconstrained primal form. Many of these objectives are technically not differentiable (e.g. the max(x,y) function isn’t because it has a kink when x=y), but in practice this is not a problem and it is common to use a subgradient.

Aside: Other Multiclass SVM formulations. It is worth noting that the Multiclass SVM presented in this section is one of few ways of formulating the SVM over multiple classes. Another commonly used form is the One-Vs-All (OVA) SVM which trains an independent binary SVM for each class vs. all other classes. Related, but less common to see in practice is also the All-vs-All (AVA) strategy. Our formulation follows the Weston and Watkins 1999 (pdf) version, which is a more powerful version than OVA (in the sense that you can construct multiclass datasets where this version can achieve zero data loss, but OVA cannot. See details in the paper if interested). The last formulation you may see is a Structured SVM, which maximizes the margin between the score of the correct class and the score of the highest-scoring incorrect runner-up class. Understanding the differences between these formulations is outside of the scope of the class. The version presented in these notes is a safe bet to use in practice, but the arguably simplest OVA strategy is likely to work just as well (as also argued by Rikin et al. 2004 in In Defense of One-Vs-All Classification (pdf)).

Softmax classifier

It turns out that the SVM is one of two commonly seen classifiers. The other popular choice is the Softmax classifier, which has a different loss function. If you’ve heard of the binary Logistic Regression classifier before, the Softmax classifier is its generalization to multiple classes. Unlike the SVM which treats the outputs (f(x_i,W)) as (uncalibrated and possibly difficult to interpret) scores for each class, the Softmax classifier gives a slightly more intuitive output (normalized class probabilities) and also has a probabilistic interpretation that we will describe shortly. In the Softmax classifier, the function mapping (f(x_i W) = W x_i) stays unchanged, but we now interpret these scores as the unnormalized log probabilities for each class and replace the hinge loss with a cross-entropy loss that has the form:

where we are using the notation (f_j) to mean the j-th element of the vector of class scores (f). As before, the full loss for the dataset is the mean of (L_i) over all training examples together with a regularization term (R(W)). The function (f_j(z) = frac<>>> ) is called the softmax function: It takes a vector of arbitrary real-valued scores (in (z)) and squashes it to a vector of values between zero and one that sum to one. The full cross-entropy loss that involves the softmax function might look scary if you’re seeing it for the first time but it is relatively easy to motivate.

Information theory view. Das cross-entropy between a “true” distribution (p) and an estimated distribution (q) is defined as:

The Softmax classifier is hence minimizing the cross-entropy between the estimated class probabilities ( (q = e^<>> / sum_j e^ ) as seen above) and the “true” distribution, which in this interpretation is the distribution where all probability mass is on the correct class (i.e. (p = [0, ldots 1, ldots, 0]) contains a single 1 at the (y_i) -th position.). Moreover, since the cross-entropy can be written in terms of entropy and the Kullback-Leibler divergence as (H(p,q) = H(p) + D_(p||q)), and the entropy of the delta function (p) is zero, this is also equivalent to minimizing the KL divergence between the two distributions (a measure of distance). In other words, the cross-entropy objective wants the predicted distribution to have all of its mass on the correct answer.

Probabilistic interpretation. Looking at the expression, we see that

can be interpreted as the (normalized) probability assigned to the correct label (y_i) given the image (x_i) and parameterized by (W). To see this, remember that the Softmax classifier interprets the scores inside the output vector (f) as the unnormalized log probabilities. Exponentiating these quantities therefore gives the (unnormalized) probabilities, and the division performs the normalization so that the probabilities sum to one. In the probabilistic interpretation, we are therefore minimizing the negative log likelihood of the correct class, which can be interpreted as performing Maximum Likelihood Estimation (MLE). A nice feature of this view is that we can now also interpret the regularization term (R(W)) in the full loss function as coming from a Gaussian prior over the weight matrix (W), where instead of MLE we are performing the Maximum a posteriori (MAP) estimation. We mention these interpretations to help your intuitions, but the full details of this derivation are beyond the scope of this class.

Practical issues: Numeric stability. When you’re writing code for computing the Softmax function in practice, the intermediate terms (e^<>>) and (sum_j e^) may be very large due to the exponentials. Dividing large numbers can be numerically unstable, so it is important to use a normalization trick. Notice that if we multiply the top and bottom of the fraction by a constant (C) and push it into the sum, we get the following (mathematically equivalent) expression:

We are free to choose the value of (C). This will not change any of the results, but we can use this value to improve the numerical stability of the computation. A common choice for (C) is to set (log C = -max_j f_j ). This simply states that we should shift the values inside the vector (f) so that the highest value is zero. In code:

Possibly confusing naming conventions. To be precise, the SVM classifier uses the hinge loss, or also sometimes called the max-margin loss. Das Softmax classifier uses the cross-entropy loss. The Softmax classifier gets its name from the softmax function, which is used to squash the raw class scores into normalized positive values that sum to one, so that the cross-entropy loss can be applied. In particular, note that technically it doesn’t make sense to talk about the “softmax loss”, since softmax is just the squashing function, but it is a relatively commonly used shorthand.

SVM vs. Softmax

A picture might help clarify the distinction between the Softmax and SVM classifiers:

Softmax classifier provides “probabilities” for each class. Unlike the SVM which computes uncalibrated and not easy to interpret scores for all classes, the Softmax classifier allows us to compute “probabilities” for all labels. For example, given an image the SVM classifier might give you scores [12.5, 0.6, -23.0] for the classes “cat”, “dog” and “ship”. The softmax classifier can instead compute the probabilities of the three labels as [0.9, 0.09, 0.01], which allows you to interpret its confidence in each class. The reason we put the word “probabilities” in quotes, however, is that how peaky or diffuse these probabilities are depends directly on the regularization strength (lambda) - which you are in charge of as input to the system. For example, suppose that the unnormalized log-probabilities for some three classes come out to be [1, -2, 0]. The softmax function would then compute:

[[1, -2, 0] ightarrow [e^1, e^<-2>, e^0] = [2.71, 0.14, 1] ightarrow [0.7, 0.04, 0.26]]

Where the steps taken are to exponentiate and normalize to sum to one. Now, if the regularization strength (lambda) was higher, the weights (W) would be penalized more and this would lead to smaller weights. For example, suppose that the weights became one half smaller ([0.5, -1, 0]). The softmax would now compute:

[[0.5, -1, 0] ightarrow [e^<0.5>, e^<-1>, e^0] = [1.65, 0.37, 1] ightarrow [0.55, 0.12, 0.33]]

where the probabilites are now more diffuse. Moreover, in the limit where the weights go towards tiny numbers due to very strong regularization strength (lambda), the output probabilities would be near uniform. Hence, the probabilities computed by the Softmax classifier are better thought of as confidences where, similar to the SVM, the ordering of the scores is interpretable, but the absolute numbers (or their differences) technically are not.

In practice, SVM and Softmax are usually comparable. The performance difference between the SVM and Softmax are usually very small, and different people will have different opinions on which classifier works better. Compared to the Softmax classifier, the SVM is a more local objective, which could be thought of either as a bug or a feature. Consider an example that achieves the scores [10, -2, 3] and where the first class is correct. An SVM (e.g. with desired margin of (Delta = 1)) will see that the correct class already has a score higher than the margin compared to the other classes and it will compute loss of zero. The SVM does not care about the details of the individual scores: if they were instead [10, -100, -100] or [10, 9, 9] the SVM would be indifferent since the margin of 1 is satisfied and hence the loss is zero. However, these scenarios are not equivalent to a Softmax classifier, which would accumulate a much higher loss for the scores [10, 9, 9] than for [10, -100, -100]. In other words, the Softmax classifier is never fully happy with the scores it produces: the correct class could always have a higher probability and the incorrect classes always a lower probability and the loss would always get better. However, the SVM is happy once the margins are satisfied and it does not micromanage the exact scores beyond this constraint. This can intuitively be thought of as a feature: For example, a car classifier which is likely spending most of its “effort” on the difficult problem of separating cars from trucks should not be influenced by the frog examples, which it already assigns very low scores to, and which likely cluster around a completely different side of the data cloud.

Interactive web demo

Zusammenfassung

  • We defined a score function from image pixels to class scores (in this section, a linear function that depends on weights W and biases b).
  • Unlike kNN classifier, the advantage of this parametric approach is that once we learn the parameters we can discard the training data. Additionally, the prediction for a new test image is fast since it requires a single matrix multiplication with W, not an exhaustive comparison to every single training example.
  • We introduced the bias trick, which allows us to fold the bias vector into the weight matrix for convenience of only having to keep track of one parameter matrix.
  • We defined a loss function (we introduced two commonly used losses for linear classifiers: the SVM and the Softmax) that measures how compatible a given set of parameters is with respect to the ground truth labels in the training dataset. We also saw that the loss function was defined in such way that making good predictions on the training data is equivalent to having a small loss.

We now saw one way to take a dataset of images and map each one to class scores based on a set of parameters, and we saw two examples of loss functions that we can use to measure the quality of the predictions. But how do we efficiently determine the parameters that give the best (lowest) loss? This process is optimization, and it is the topic of the next section.


6.2.2. Feature hashing¶

The class FeatureHasher is a high-speed, low-memory vectorizer that uses a technique known as feature hashing, or the “hashing trick”. Instead of building a hash table of the features encountered in training, as the vectorizers do, instances of FeatureHasher apply a hash function to the features to determine their column index in sample matrices directly. The result is increased speed and reduced memory usage, at the expense of inspectability the hasher does not remember what the input features looked like and has no inverse_transform method.

Since the hash function might cause collisions between (unrelated) features, a signed hash function is used and the sign of the hash value determines the sign of the value stored in the output matrix for a feature. This way, collisions are likely to cancel out rather than accumulate error, and the expected mean of any output feature’s value is zero. This mechanism is enabled by default with alternate_sign=True and is particularly useful for small hash table sizes ( n_features < 10000 ). For large hash table sizes, it can be disabled, to allow the output to be passed to estimators like MultinomialNB or chi2 feature selectors that expect non-negative inputs.

FeatureHasher accepts either mappings (like Python’s dict and its variants in the collections module), (feature, value) pairs, or strings, depending on the constructor parameter input_type . Mapping are treated as lists of (feature, value) pairs, while single strings have an implicit value of 1, so ['feat1', 'feat2', 'feat3'] is interpreted as [('feat1', 1), ('feat2', 1), ('feat3', 1)] . If a single feature occurs multiple times in a sample, the associated values will be summed (so ('feat', 2) and ('feat', 3.5) become ('feat', 5.5) ). The output from FeatureHasher is always a scipy.sparse matrix in the CSR format.

Feature hashing can be employed in document classification, but unlike CountVectorizer , FeatureHasher does not do word splitting or any other preprocessing except Unicode-to-UTF-8 encoding see Vectorizing a large text corpus with the hashing trick , below, for a combined tokenizer/hasher.

As an example, consider a word-level natural language processing task that needs features extracted from (token, part_of_speech) pairs. One could use a Python generator function to extract features:


How to find a basis of an image of a linear transformation?

I apologize for asking a question though there are pretty much questions on math.stackexchange with the same title, but the answers on them are still not clear for me.

I have this linear operator:

$ Ax = (2x_1-x_2-x_3, x_1-2x_2+x_3, x_1+x_2-2x_3) $

And I need to find the basis of the kernel and the basis of the image of this transformation.

First, I wrote the matrix of this transformation, which is:

I found the basis of the kernel by solving a system of 3 linear equations:

But how can I find the basis of the image? What I have found so far is that I need to complement a basis of a kernel up to a basis of an original space. But I do not have an idea of how to do this correctly. I thought that I can use any two linear independent vectors for this purpose, like

because the image here is $mathbb^2$

But the correct answer from my textbook is:

And by the way I cannot be sure that there is no error in the textbook's answer.

So could anyone help me with this. I will be very grateful, thank you in advance.


The functools module¶

The functools module in Python 2.5 contains some higher-order functions. EIN higher-order function takes one or more functions as input and returns a new function. The most useful tool in this module is the functools.partial() function.

For programs written in a functional style, you’ll sometimes want to construct variants of existing functions that have some of the parameters filled in. Consider a Python function f(a, b, c) you may wish to create a new function g(b, c) that’s equivalent to f(1, b, c) you’re filling in a value for one of f() ’s parameters. This is called “partial function application”.

The constructor for partial() takes the arguments (function, arg1, arg2, . kwarg1=value1, kwarg2=value2) . The resulting object is callable, so you can just call it to invoke function with the filled-in arguments.

Here’s a small but realistic example:

functools.reduce(func, iter, [initial_value]) cumulatively performs an operation on all the iterable’s elements and, therefore, can’t be applied to infinite iterables. func must be a function that takes two elements and returns a single value. functools.reduce() takes the first two elements A and B returned by the iterator and calculates func(A, B) . It then requests the third element, C, calculates func(func(A, B), C) , combines this result with the fourth element returned, and continues until the iterable is exhausted. If the iterable returns no values at all, a TypeError exception is raised. If the initial value is supplied, it’s used as a starting point and func(initial_value, A) is the first calculation.

If you use operator.add() with functools.reduce() , you’ll add up all the elements of the iterable. This case is so common that there’s a special built-in called sum() to compute it:

For many uses of functools.reduce() , though, it can be clearer to just write the obvious for loop:

A related function is itertools.accumulate(iterable, func=operator.add) . It performs the same calculation, but instead of returning only the final result, accumulate() returns an iterator that also yields each partial result:

The operator module¶

The operator module was mentioned earlier. It contains a set of functions corresponding to Python’s operators. These functions are often useful in functional-style code because they save you from writing trivial functions that perform a single operation.

Some of the functions in this module are:

Math operations: add() , sub() , mul() , floordiv() , abs() , …

Logical operations: not_() , truth() .

Bitwise operations: and_() , or_() , invert() .

Comparisons: eq() , ne() , lt() , le() , gt() , and ge() .

Object identity: is_() , is_not() .

Consult the operator module’s documentation for a complete list.


About

This is the documentation of the ComplexHeatmap package. Examples in the book are generated under version 2.7.7.

You can get a stable Bioconductor version from http://bioconductor.org/packages/release/bioc/html/ComplexHeatmap.html, but the most up-to-date version is always on Github and you can install it by:

The development branch on Bioconductor is basically synchronized to Github repository.

Das ComplexHeatmap package is inspired from the pheatmap package. You can find many arguments in ComplexHeatmap have the same names as in pheatmap. Also you can find this old package that I tried to develop by modifying pheatmap.

Please note, this documentation is not completely compatible with older versions (< 1.99.0, before Oct, 2018), but the major functionality keeps the same.

If you use ComplexHeatmap in your publications, I am appreciated if you can cite:

Gu, Z. (2016) Complex heatmaps reveal patterns and correlations in multidimensional genomic data. DOI: 10.1093/bioinformatics/btw313


Graph Representation – Adjacency Matrix and Adjacency List

Graph is a collection of nodes or vertices (V) and edges(E) between them. We can traverse these nodes using the edges. These edges might be weighted or non-weighted.

There can be two kinds of Graphs

  • Un-directed Graph – when you can traverse either direction between two nodes.
  • Directed Graph – when you can traverse only in the specified direction between two nodes.

Now how do we represent a Graph, There are two common ways to represent it:

Adjacency Matrix:

Adjacency Matrix is 2-Dimensional Array which has the size VxV, where V are the number of vertices in the graph. See the example below, the Adjacency matrix for the graph shown above.

adjMaxtrix[i][j] = 1 when there is edge between Vertex i and Vertex j, else 0.

It’s easy to implement because removing and adding an edge takes only O(1) time.

But the drawback is that it takes O(V 2 ) space even though there are very less edges in the graph.

Adjacency List:

Adjacency List is the Array[] of Linked List, where array size is same as number of Vertices in the graph. Every Vertex has a Linked List. Each Node in this Linked list represents the reference to the other vertices which share an edge with the current vertex. The weights can also be stored in the Linked List Node.

The code below might look complex since we are implementing everything from scratch like linked list, for better understanding. Read the articles below for easier implementations (Adjacency Matrix and Adjacency List)


Schau das Video: Funktionalanalysis,: Beispiele linearer Operatoren (Oktober 2021).