Der Wissenschaftler bedeutet unweigerlich, an mehreren Abstraktionsebenen, vorbemosen Abstraktionen von Code und Mathematik zu arbeiten. Dies ist großartig, denn so können Sie schnell erstaunliche Ergebnisse erzielen. Aber manchmal ist es intestine beraten, eine Sekunde innehalten und darüber nachdenken, was tatsächlich hinter einer ordentlichen Schnittstelle passiert. Dieser Nachdenkensprozess wird häufig durch Visualisierungen unterstützt. In diesem Artikel möchte ich präsentieren, wie animierte Köcherplots dazu beitragen können, über lineare Transformationen nachzudenken, die häufig in der Dunkelheit von Algorithmen für maschinelles Lernen und zugehörigen Schnittstellen zuverlässig wegfahren. Am Ende können wir Konzepte wie die Zersetzung von Singular Worth mit unserem Köcherplot visualisieren.

Zeichnen Sie statische Köcherdiagramme

Eine Köcherhandlung aus dem matplotlib Das Python -Paket ermöglicht es uns, Pfeile zu zeichnen (was in unserem Fall Vektoren darstellt). Schauen wir uns zunächst eine statische Köcherung an:

Wir können die Transformationsmatrix direkt aus dem Bild ableiten, indem wir die Zielpositionen der beiden Basisvektoren betrachten. Der erste Basisvektor beginnt an Place (1, 0) und landet auf (1, 1), während der zweite Basisvektor von (0, 1) bis (-1, 1) bewegt. Daher ist die Matrix, die diese Transformation beschreibt,:

(
start {pmatrix}
1 & -1
1 & 1
finish {pmatrix}
)

Visuell entspricht dies einer Rotation gegen den Uhrzeigersinn um 45 Grad (oder ( pi/4 ) in Radian und eine leichte Dehnung (durch den Faktor ( sqrt {2} )).

Schauen wir uns mit diesen Informationen an, wie dies mit dem Quimer implementiert wird (beachten Sie, dass ich einen Boilerplate -Code wie Skalierung der Achse weglässt):

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm

def quiver_plot_base_vectors(transformation_matrix: np.ndarray):
    # Outline vectors
    basis_i = np.array((1, 0))
    basis_j = np.array((0, 1))
    i_transformed = transformation_matrix(:, 0)
    j_transformed = transformation_matrix(:, 1)
    
    # plot vectors with quiver-function
    cmap = cm.inferno
    fig, ax = plt.subplots()
    ax.quiver(0, 0, basis_i(0), basis_i(1), 
        shade=cmap(0.2), 
        scale=1, 
        angles="xy", 
        scale_units="xy", 
        label="i", 
        alpha=0.3)
    ax.quiver(0, 0, i_transformed(0), i_transformed(1), 
        shade=cmap(0.2), 
        scale=1,   
        angles="xy",  
        scale_units="xy", 
        label="i_transformed")
    ax.quiver(0, 0, basis_j(0), basis_j(1), 
        shade=cmap(0.5), 
        scale=1, 
        angles="xy", 
        scale_units="xy", 
        label="j", 
        alpha=0.3)
    ax.quiver(0, 0, j_transformed(0), j_transformed(1), 
        shade=cmap(0.5), 
        scale=1, 
        angles="xy", 
        scale_units="xy", 
        label="j_transformed")

if __name__ == "__main__":
    matrix = np.array((
        (1, -1),
        (1, 1)  
    ))
    quiver_plot_base_vectors(matrix)

Wie Sie sehen können, haben wir ein Köcher professional Vektor definiert. Dies ist nur für veranschaulichende Zwecke. Wenn wir uns die Signatur der Köcherfunktion ansehen – quiver((X, Y), U, V, (C), /, **kwargs) – Wir können beobachten, dass u und v Numpy -Arrays als Eingabe nutzen, was besser ist als die Bereitstellung von Skalarwerten. Lassen Sie uns diese Funktion mit nur einem Köcheraufruf neu ausführen. Lassen Sie uns außerdem einen Vektor v = (1,5, -0,5) hinzufügen, um die darauf angewendete Transformation anzuzeigen.

def quiver_plot(transformation_matrix: np.ndarray, vector: np.ndarray):
    # Outline vectors
    basis_i = np.array((1, 0))
    basis_j = np.array((0, 1))
    i_transformed = transformation_matrix(:, 0)
    j_transformed = transformation_matrix(:, 1)
    vector_transformed = transformation_matrix @ vector
    U, V = np.stack(
        (
            basis_i, i_transformed,
            basis_j, j_transformed,
            vector, vector_transformed,
        ),
        axis=1)

    # Draw vectors
    shade = np.array((.2, .2, .5, .5, .8, .8))
    alpha = np.array((.3, 1.0, .3, 1.0, .3, 1.0))
    cmap = cm.inferno
    fig, ax = plt.subplots()
    ax.quiver(np.zeros(6), np.zeros(6), U, V,
        shade=cmap(shade),
        alpha=alpha,
        scale=1,
        angles="xy",
        scale_units="xy",
    )

if __name__ == "__main__":
    matrix = np.sqrt(2) * np.array((
        (np.cos(np.pi / 4), np.cos(3 * np.pi / 4)),
        (np.sin(np.pi / 4), np.sin(3 * np.pi / 4))
    ))
    vector = np.array((1.5, -0.5))
    quiver_plot(matrix, vector)

Dies ist viel kürzer und bequem als das erste Beispiel. Was wir hier getan haben, struggle, jeden Vektor horizontal das folgende Array zu stapeln:

Die erste Zeile entspricht dem U-Parameter von quiver und die zweite nach V., während die Spalten unsere Vektoren halten, wobei ( vec {i} ) der erste Basisvektor ist, ist ( vec {j} ) der zweite und ( vec {v} ) ist unser individueller Vektor. Die Indizes B und A stehen für vor Und nach (dh ob Die lineare Transformation wird angewendet oder nicht). Schauen wir uns die Ausgabe an:

Wenn Sie einen zweiten Blick auf den Code werfen, könnte es verwirrt werden, was mit unserer ordentlichen und einfachen Transformationsmatrix passiert ist, die angezeigt wurde:

(
{ scriptSize
M = start {pmatrix}
{1} & {-1}
{1} & {1}
finish {pmatrix} = { sqrt {2}}
start {pmatrix}
{ cos hyperlinks ( frac {1} {4} pi rechts)} & { cos hyperlinks ( frac {3} {4} pi rechts)}
{ sin hyperlinks ( frac {1} {4} pi rechts)} & { sin hyperlinks ( frac {3} {4} pi rechts)}
finish {pmatrix}
}
)

Der Grund ist, dass diese Darstellung nützlich sein wird, wenn wir durch das Hinzufügen von Animationen weitermachen. Die skalare Multiplikation durch die Quadratwurzel von zwei zeigt, wie stark unsere Vektoren gedehnt werden, während die Elemente der Matrix in trigonometrischer Notation umgeschrieben werden, um die Rotation im Einheitskreis darzustellen.

Lass uns animieren

Gründe, Animationen hinzuzufügen, können sauberere Handlungen enthalten, da wir die Geistervektoren loswerden und ein ansprechenderes Erlebnis für Präsentationen schaffen können. Um unsere Handlung mit Animationen zu verbessern, können wir im Matplotlib -Ökosystem bleiben, indem wir die verwenden FuncAnimation() Funktion von matplotlib.animation. Die Funktion nimmt die folgenden Argumente an:

• A matplotlib.determine.Determine Objekt
• eine Aktualisierungsfunktion
• die Anzahl der Frames

Für jeden Body wird die Aktualisierungsfunktion aufgerufen, um eine aktualisierte Model des ersten Kreidels zu erstellen. Weitere Informationen finden Sie unter der offizielle Dokumentation von Matplotlib.

Unter Berücksichtigung dieser Informationen besteht unsere Aufgabe darin, die Logik zu definieren, die in der Aktualisierungsfunktion implementiert werden soll. Beginnen wir einfach mit nur drei Frames und unseren Basisvektoren. Auf Rahmen 0 sind wir im Anfangszustand. Während wir auf dem letzten Rahmen (Rahmen 2) zu der angepassten Matrix M. ankommen müssen. Daher würden wir erwarten, dass wir auf dem Rahmen auf halbem Weg auf dem Rahmen sind. Da die Argumente von ( cos ) und ( sin ) in M ​​die Radians zeigen (dh, wie weit wir auf dem Einheitskreis gereist sind), können wir sie durch zwei Teilen durch zwei Teilen durch zwei Teilen, um die gewünschten Rotation zu erzählen. (Der zweite Vektor erhält ein negatives ( cos ), weil wir jetzt im zweiten Quadranten sind). In ähnlicher Weise müssen wir die Dehnung berücksichtigen, die durch den Skalarfaktor dargestellt wird. Wir tun dies, indem wir die Größenänderung berechnen, die ( sqrt {2} -1 ) ist und die Hälfte dieser Änderung zur anfänglichen Skalierung hinzufügen.

(
{ scriptSize
start {ausgerichtet}
textual content {Body 0:} quad &
start {pmatrix}
cos (0) & cos hyperlinks ( frac { pi} {2} rechts)
sin (0) & sin hyperlinks ( frac { pi} {2} rechts)
finish {pmatrix}
(1em)
textual content {Body 1:} quad &
S cdot start {pmatrix}
cos hyperlinks ( frac {1} {2} cdot frac { pi} {4} rechts) & – cos hyperlinks ( frac {1} {2} cdot frac {3 pi} {4} rechts)
sin hyperlinks ( frac {1} {2} cdot frac { pi} {4} rechts) & sin hyperlinks ( frac {1} {2} cdot frac {3 pi} {4} rechts)
finish {pmatrix}, quad textual content {mit} s = 1 + frac { sqrt {2} – 1} {2}
(1em)
textual content {Body 2:} quad &
sqrt {2} cdot start {pmatrix}
cos hyperlinks ( frac { pi} {4} rechts) & cos hyperlinks ( frac {3 pi} {4} rechts)
sin hyperlinks ( frac { pi} {4} rechts) & sin hyperlinks ( frac {3 pi} {4} rechts)
finish {pmatrix}
finish {ausgerichtet}
}
)

Eine Einschränkung der obigen Erklärung: Sie dient dem Zweck, der Implementierungsidee intuitioniert zu werden, und gilt für die Basisvektoren. Die tatsächliche Implementierung enthält jedoch einige weitere Schritte, z. B. einige Transformationen mit ( arctan ), um das gewünschte Verhalten für alle Vektoren im zweidimensionalen Raum zu erhalten.

Überprüfen wir additionally die Hauptteile der Implementierung. Der vollständige Code kann auf meinem gefunden werden Github.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import animation
from matplotlib import cm

class AnimationPlotter:
(...)
def animate(self, filename='output/mat_transform.gif'):
        self.initialize_plot()
        anim = animation.FuncAnimation(
            self.fig,
            self.update_quiver,
            frames=self.frames + 1,
            init_func=self.init_quiver,
            blit=True,
        )
        anim.save(filename, author='ffmpeg', fps=self.frames/2)
        plt.shut()
   
if __name__ == "__main__":
    matrix = np.sqrt(2) * np.array((
        (np.cos(np.pi / 4), np.cos(3 * np.pi / 4)),
        (np.sin(np.pi / 4), np.sin(3 * np.pi / 4))
       
    ))
    vector = np.array((1.5, -0.5)).reshape(2, 1)
    transformer = Transformer(matrix)
    animation_plotter = AnimationPlotter(transformer, vector)
    animation_plotter.animate()

Der animate() Die Methode gehört zu einer benutzerdefinierten Klasse, die genannt wird AnimationPlotter. Es tut das, was wir bereits mit den oben angegebenen Eingaben gelernt haben. Die zweite Klasse in der Szene ist eine benutzerdefinierte Klasse Transformerdie sich um die Berechnung der linearen Transformationen und Zwischenvektoren für jeden Body kümmert. Die Hauptlogik liegt in der AnimationPlotter.update_quiver() Und Transformer.get_intermediate_vectors() Methoden und sieht wie folgt aus.

class AnimationPlotter:
    (...)
    def update_quiver(self, body: int):
        incremented_vectors = self.transformer.get_intermediate_vectors(
            body, self.frames
        )
        u = incremented_vectors(0)
        v = incremented_vectors(1)
        self.quiver_base.set_UVC(u, v)
        return self.quiver_base,

class Transformer:
    (...)
    def get_intermediate_vectors(self, body: int, total_frames: int) -> np.ndarray:
         change_in_direction = self.transformed_directions - self.start_directions
         change_in_direction = np.arctan2(np.sin(change_in_direction), np.cos(change_in_direction))
         increment_direction = self.start_directions + change_in_direction * body / total_frames
         increment_magnitude = self.start_magnitudes + (self.transformed_magnitudes - self.start_magnitudes) * body / total_frames
         incremented_vectors = np.vstack((np.cos(increment_direction), np.sin(increment_direction))) @ np.diag(increment_magnitude)
         return incremented_vectors

Was hier passiert, ist, dass für jeden Body die Zwischenvektoren berechnet werden. Dies geschieht durch den Unterschied zwischen Finish- und Startanweisungen (die Vektorwinkel darstellen). Die Änderung der Richtung/des Richtungswinkels wird dann auf den Bereich ((- pi, pi) ) normalisiert und durch ein Verhältnis in die Anfangsrichtung hinzugefügt. Das Verhältnis wird durch den Strom und die Gesamtrahmen bestimmt. Die Größe wird wie bereits beschrieben bestimmt. Schließlich wird der inkrementierte Vektor basierend auf Richtung und Größe berechnet, und dies sehen wir bei jedem Body in der Animation. Durch das Erhöhen der Frames, um 30 oder 60 zu sagen, wird die Animation reibungslos.

Animation Singular Worth Decomposition (SVD)

Schließlich möchte ich zeigen, wie die Einführungsanimation erstellt wurde. Es zeigt, wie 4 Vektoren (jeweils für jeden Quadranten) dreimal nacheinander transformiert werden. In der Tat entsprechen die drei angewendeten Transformationen unserer inzwischen bekannten Transformationsmatrix M von oben, zersetzt jedoch durch die Singularwert-Zersetzung (SVD). Sie können Ihr Kenntnis Das Großer und intuitiver TDS -Artikel. Oder schauen Sie sich an Hier Wenn Sie eine eher mathematischer Lesen vorziehen. Jedoch mit numpy.linalg.svd() Es ist einfach, die SVD unserer Matrix M zu berechnen. Dies führt zu der folgenden Zerlegung:

(
{ scriptSize
start {align}
A vec {v} & = u sigma v^t vec {v} (1em)
sqrt {2} cdot start {pmatrix}
cos hyperlinks ( frac { pi} {4} rechts) & cos hyperlinks ( frac {3 pi} {4} rechts)
sin hyperlinks ( frac { pi} {4} rechts) & sin hyperlinks ( frac {3 pi} {4} rechts)
finish {pmatrix} vec {v} & =
start {pmatrix}
cos hyperlinks ( frac {3 pi} {4} rechts) & cos hyperlinks ( frac {3 pi} {4} rechts)
sin hyperlinks ( frac {- pi} {4} rechts) & sin hyperlinks ( frac { pi} {4} rechts)
finish {pmatrix}
start {pmatrix}
sqrt {2} & 0
0 & sqrt {2}
finish {pmatrix}
start {pmatrix}
-1 & 0
0 & 1
finish {pmatrix} vec {v}
finish {align}
}
)

Beachten Sie, wie die Dehnung der Quadratwurzel durch die mittlere Matrix destilliert wird. Die folgende Animation zeigt, wie dies in Aktion (oder Bewegung) für V = (1,5, -0,5) aussieht.

Am Ende kommt der lila Vektor ( vec {v} ) in beiden Fällen an seiner entschlossenen Place an.

Abschluss

Um es abzuschließen, können wir verwenden quiver() Vektoren im 2D -Bereich anzeigen und mit Hilfe von matplotlib.animation.FuncAnimation(), Fügen Sie ansprechende Animationen oben hinzu. Dies führt zu klaren Visualisierungen linearer Transformationen, die Sie beispielsweise verwenden können, um die zugrunde liegenden Mechanik Ihrer Algorithmen für maschinelles Lernen zu demonstrieren. Fühlen Sie sich frei, mein Repository zu geben und Ihre eigenen Visualisierungen zu implementieren. Ich hoffe, Sie haben die Lektüre genossen!

Voller Code für dieses Beispiel am Ende dieses Beitrags.

Eine a number of Regression wird verwendet, wenn Ihre Antwortvariable y kontinuierlich ist und Sie mindestens Ok -Kovariaten oder unabhängige Variablen haben, die linear damit korrelieren. Die Daten sind aus der Kind:

(Y₁, x₁),…, (yᵢ, xᵢ),…, (yₙ, xₙ)

wobei xᵢ = (xᵢ₁,…, xᵢₖ) ein Vektor von Kovariaten ist und n die Anzahl der Beobachtungen. Hier ist XI der Vektor der ok -kovariaten Werte für die ITH -Beobachtung.

Die Daten verstehen

Stellen Sie sich das folgende Szenario vor:

Sie gerne laufen und verfolgen Ihre Leistung, indem Sie die Distanz aufzeichnen, die Sie jeden Tag ausführen. Über 100 aufeinanderfolgende Tage sammeln Sie vier Informationen:

• Die Entfernung, die Sie laufen,
• Die Anzahl der Stunden, die Sie verbracht haben,
• Die Anzahl der Stunden, die du letzte Nacht geschlafen hast,
• Und die Anzahl der Stunden, in denen Sie gearbeitet haben

Jetzt, am 101. Tag, haben Sie alles aufgenommen außer die Entfernung, die du gelaufen bist. Sie möchten diesen fehlenden Wert anhand der Informationen, die Sie haben, schätzen: Die Anzahl der Stunden, die Sie verbracht haben, die Anzahl der Stunden, die Sie in der Nacht zuvor geschlafen haben, und die Anzahl der Stunden, die Sie an diesem Tag gearbeitet haben.

Dazu können Sie sich auf die Daten aus den letzten 100 Tagen verlassen, die das Formular annehmen:

(Y₁, x₁),…, (yᵢ, xᵢ),…, (y₁₀₀, x₁₀₀)

Hier, jeweils Yᵢ Ist die Entfernung, die Sie am Tag gelaufen sind ichund jeder kovariate Vektor Xᵢ = (xᵢ₁, xᵢ₂, xᵢ₃) entspricht:

• Xᵢ₁: Anzahl der Stunden, die verbracht haben,
• Xᵢ₂: Anzahl der Stunden in der vergangenen Nacht geschlafen,
• Xᵢ₃: Anzahl der Arbeitsstunden an diesem Tag.

Der Index i = 1,…, 100 bezieht sich auf die 100 Tage mit vollständigen Daten. Mit diesem Datensatz können Sie nun ein mehrfach lineares Regressionsmodell anpassen, um die fehlende Antwortvariable für Tag 101 abzuschätzen.

Spezifikation des Modells

Wenn wir die lineare Beziehung zwischen der Antwortvariablen und den Kovariaten annehmen, die Sie mit der Pearson -Korrelation messen können, können wir das Modell als:

für i = 1,…, n wo e (ϵᵢ | xᵢ₁,…, xᵢₖ). Um den Abfangen zu berücksichtigen, wird die erste Variable auf Xᵢ₁ = 1, für i = 1,…, n. Um den Koeffizienten abzuschätzen, wird das Modell in Matrixnotation ausgedrückt.

Und die Kovariaten werden mit:

Dann können wir das Modell als:

Y = xβ + ε

Schätzung der Koeffizienten

Unter der Annahme, dass die (ok+1)*(ok+1) Matrix invertierbar ist, ist die Kind der Schätzung der kleinsten Quadrate angegeben durch:

Wir können die Schätzung der Regressionsfunktion, eine unvoreingenommene Schätzung von σ² und ein ungefähres 1 -α -Konfidenzintervall für βⱼ ableiten:

• Schätzung der Regressionsfunktion: r (x) = ∑ⱼ₌₁ᵏ βⱼ xⱼ
• σ̂² = (1 / (n – ok)) × ∑ᵢ₌₁ⁿ ε̂ᵢ² wobei ϵ̂ = y – xβ̂ der Vektor der Residuen ist.
• Und β̂ⱼ ± Tₙ₋ₖ, ₁₋α⁄₂ × SE (β̂ⱼ) ist ungefähr (1 – α) Konfidenzintervall. Wobei SE (β̂ⱼ) das jth -diagonale Aspect der Matrix σ̂² (xᵀ x) ⁻¹ ist

Beispiel für die Anwendung

Da wir die Daten unserer laufenden Leistung nicht aufgezeichnet haben, werden wir 1960 einen Kriminalitätsdatensatz aus 47 Bundesstaaten verwenden Hier. Bevor wir zu einer linearen Regression passen, müssen wir viele Schritte befolgen.

Verständnis verschiedener Variablen der Daten.

Die ersten 9 Beobachtungen der Daten sind gegeben durch:

 R	   Age	S	Ed	Ex0	Ex1	LF	M	N	NW	U1	U2	W	X
79.1	151	1	91	58	56	510	950	33	301	108	41	394	261
163.5	143	0	113	103	95	583	1012 13	102	96	36	557	194
57.8	142	1	89	45	44	533	969	18	219	94	33	318	250
196.9	136	0	121	149	141	577	994	157	80	102	39	673	167
123.4	141	0	121	109	101	591	985	18	30	91	20	578	174
68.2	121	0	110	118	115	547	964	25	44	84	29	689	126
96.3	127	1	111	82	79	519	982	4	139	97	38	620	168
155.5	131	1	109	115	109	542	969	50	179	79	35	472	206
85.6	157	1	90	65	62	553	955	39	286	81	28	421	239

Die Daten haben 14 kontinuierliche Variablen (die Antwortvariable R, die 12 Prädiktorvariablen und eine kategoriale Variable S):

1. R: Kriminalitätsrate: Anzahl der Straftaten, die der Polizei professional Million Bevölkerung gemeldet haben
2. Alter: Die Anzahl der Männer im Alter von 14 bis 24 Jahren professional 1000 Bevölkerung
3. S: Indikatorvariable für südliche Zustände (0 = Nein, 1 = Ja)
4. ED: Mittelwert der Schuljahre x 10 für Personen im Alter von 25 Jahren oder älter
5. Ex0: 1960 Professional -Kopf -Ausgaben für die Polizei durch staatliche und lokale Regierung
6. EX1: 1959 Professional -Kopf -Ausgaben für die Polizei durch staatliche und örtliche Regierung
7. LF: Erwerbsbeteiligungsrate professional 1000 zivile städtische Männer im Alter von 14 bis 24 Jahren
8. M: Die Anzahl der Männer professional 1000 Frauen
9. N: Staatsbevölkerungsgröße in hunderttausenden
10. NW: Die Anzahl der Nicht-Weiße professional 1000 Bevölkerung
11. U1: Arbeitslosenquote von städtischen Männern professional 1000 Alter von 14 bis 24 Jahren
12. U2: Arbeitslosenquote von städtischen Männern professional 1000 Alter von 35 bis 39 Jahren
13. W: mittlerer Wert von übertragbaren Waren und Vermögenswerten oder Familieneinkommen in Zehn $
14. X: Die Anzahl der Familien professional 1000 verdiente unter 1/2 das Durchschnittseinkommen

Die Daten haben keine fehlenden Werte.

Grafische Analyse der Beziehung zwischen den Kovariaten x und der Antwortvariablen y

Grafische Analyse der Beziehung zwischen erklärenden Variablen und der Antwortvariablen ist ein Schritt bei der linearen Regression.

Es hilft, lineare Traits zu visualisieren, Anomalien zu erkennen und die Relevanz von Variablen vor dem Erstellen eines Modells zu bewerten.

Einige Variablen korrelieren positiv mit der Kriminalitätsrate, während andere negativ korreliert sind.

Zum Beispiel beobachten wir eine starke optimistic Beziehung zwischen R (der Kriminalitätsrate) und Ex1.

Im Gegensatz dazu scheint das Alter negativ mit der Kriminalität korreliert zu sein.

Schließlich legt der Boxplot der binären Variablen (anzeigen Area: Nord oder Süd) nahe, dass die Kriminalitätsrate zwischen den beiden Regionen relativ ähnlich ist. Dann können wir die Korrelationsmatrix analysieren.

Heatmap der Pearson -Korrelationsmatrix

Die Korrelationsmatrix ermöglicht es uns, die Stärke der Beziehung zwischen Variablen zu untersuchen. Während die Pearson -Korrelation üblicherweise zur Messung linearer Beziehungen verwendet wird, die Spearman -Korrelation ist angemessener, wenn wir monotonische, potenziell nichtlineare Beziehungen zwischen Variablen erfassen wollen.

In dieser Analyse werden wir die Spearman-Korrelation verwenden, um solche nichtlinearen Assoziationen besser zu berücksichtigen.

Die erste Zeile der Korrelationsmatrix zeigt die Stärke der Beziehung zwischen den einzelnen Kovariaten und der Antwortvariablen R.

Beispielsweise zeigen EX0 und EX1 eine Korrelation von mehr als 60% mit R, was auf eine starke Assoziation hinweist. Diese Variablen scheinen gute Prädiktoren für die Kriminalitätsrate zu sein.

Da die Korrelation zwischen Ex0 und EX1 jedoch nahezu perfekt ist, vermitteln sie wahrscheinlich ähnliche Informationen. Um Redundanz zu vermeiden, können wir nur einen von ihnen auswählen, vorzugsweise die mit der stärksten Korrelation mit R.

Wenn mehrere Variablen sind stark miteinander korreliert (zum Beispiel eine Korrelation von 60%)Sie neigen dazu, redundante Informationen zu tragen. In solchen Fällen behalten wir nur einen von ihnen auf – derjenige, der am stärksten mit der Antwortvariablen R korreliert. Dies ermöglicht es uns, die Multikollinearität zu reduzieren.

Diese Übung ermöglicht es uns, diese Variablen auszuwählen: (‚ex1‘, ‚lf‘, ‚m‘, ’n‘, ’nW‘, ‚u2‘).

Untersuchung der Multikollinearität unter Verwendung des VIF (Varianzinflationsfaktoren)

Vor der Anpassung der logistischen Regression ist es wichtig, die Multikollinearität zu untersuchen.

Wenn die Korrelation zwischen Prädiktoren besteht, nehmen die Standardfehler der Koeffizientenschätzungen zu, was zu einer Inflation ihrer Varianzen führt. Der Varianzinflationsfaktor (VIF) ist ein diagnostisches Instrument, mit dem die Varianz des Koeffizienten eines Prädiktors aufgrund von Multikollinearität aufgeblasen wird, und er wird typischerweise in der Regressionsausgabe unter einer „VIF“ -Säule bereitgestellt.

Dieser VIF wird für jeden Prädiktor im Modell berechnet. Der Ansatz besteht darin, die I-Th-Prädiktorvariable gegen alle anderen Prädiktoren zurückzugewinnen. Wir erhalten dann Rᵢ², mit dem das VIF unter Verwendung der Formel berechnet werden kann:

Die folgende Tabelle zeigt die VIF -Werte für die sechs verbleibenden Variablen, die alle unter 5 liegen. Dies zeigt, dass Multikollinearität kein Downside darstellt, und wir können mit dem linearen Regressionsmodell fortfahren.

Anpassung einer linearen Regression auf sechs Variablen

Wenn wir eine lineare Regression der Kriminalitätsrate auf 10 Variablen anpassen, erhalten wir Folgendes:

Diagnose von Residuen

Vor der Interpretation der Regressionsergebnisse müssen wir zunächst die Qualität der Residuen bewerten, insbesondere durch Überprüfung auf Autokorrelation, Homoskedastizität (konstante Varianz) und Normalität. Die Diagnose von Residuen wird in der folgenden Tabelle angegeben:

• Der Durbin-Watson ~ 2 zeigt keine Autokorrelation in Residuen an.
• Vom Omnibus bis zur Kurtosis zeigen alle Werte, dass die Residuen symmetrisch sind und eine Normalverteilung aufweisen.
• Die Zahl niedriger Zustandszahl (3.06) bestätigt, dass unter den Prädiktoren keine Multikollinearität besteht.

Hauptpunkte, an die man sich erinnern sollte

Wir können auch die Gesamtqualität des Modells anhand von Indikatoren wie R-Quadatoren und F-Statistik bewerten, die in diesem Fall zufriedenstellende Ergebnisse zeigen. (Weitere Informationen finden Sie im Anhang.)

Wir können jetzt die Regressionskoeffizienten aus statistischer Sicht interpretieren.
Wir schließen absichtlich jede geschäftsspezifische Interpretation der Ergebnisse aus.
Das Ziel dieser Analyse ist es, einige einfache und wesentliche Schritte zur Modellierung eines Issues mithilfe einer multiplen linearen Regression zu veranschaulichen.

Bei 5% Signifikanzniveau sind zwei Koeffizienten statistisch signifikant: EX1 und NW.

Dies ist nicht überraschend, da es sich um die beiden Variablen handelte, die eine Korrelation von mehr als 40% mit der Antwortvariablen R zeigten.

Dieser Beitrag gibt Ihnen einige Richtlinien, um eine lineare Regression durchzuführen:

• Es ist wichtig zu überprüfen Linearität durch grafische Analyse und um die zu untersuchen Korrelation zwischen der Antwortvariablen und den Prädiktoren.
• Die Untersuchung von Korrelationen zwischen Variablen hilft, zu reduzieren Multikollinearität und unterstützt Variable Auswahl.
• Wenn zwei Prädiktoren stark korreliert sind, können sie vermitteln redundante Informationen. In solchen Fällen können Sie die aufbewahren, die ist stärker korreliert mit der Reaktionoder – basierend auf Area -Experience – die mit größeren Geschäftsrelevanz oder Praktische Interpretierbarkeit.
• Der Varianzinflationsfaktor (VIF) ist ein nützliches Instrument zur Quantifizierung und Bewertung der Multikollinearität.
• Vor der statistischen Interpretation der Modellkoeffizienten ist es wichtig, die Autokorrelation, Normalität und Homoskedastizität der Residuen zu überprüfen, um sicherzustellen, dass die Modellannahmen erfüllt sind.

Während diese Analyse wertvolle Erkenntnisse liefert, hat sie auch bestimmte Einschränkungen.

Das Fehlen fehlender Werte im Datensatz vereinfacht die Studie, dies ist jedoch in realen Szenarien selten der Fall.

Wenn Sie a bauen PrädiktivmodellEs ist wichtig, dass es wichtig ist Teilen Sie die Daten hinein AusbildungAnwesend Testenund möglicherweise eine OPT-of-Time-Validierungssatz um eine robuste Bewertung zu gewährleisten.

Für Variable AuswahlTechniken wie z. schrittweise Auswahl und andere Merkmalsauswahlmethoden können angewendet werden.

Beim Vergleich mehrerer Modelle ist es wichtig, geeignet zu definieren Leistungsmetriken.

Bei der linearen Regression umfassen häufig verwendete Metriken die Mittlerer absoluter Fehler (MAE) und die Mittlerer quadratischer Fehler (MSE).

Bildnachweis

Alle Bilder und Visualisierungen in diesem Artikel wurden vom Autor unter Verwendung von Python (Pandas, Matplotlib, Seeborn und Plotly) und Excel erstellt, sofern nicht anders angegeben.

Referenzen

Wasserman, L. (2013). Alle Statistiken: ein prägnanter Kurs in statistischer Inferenz. Springer Science & Enterprise Media.

Daten & Lizenzierung

Der in diesem Artikel verwendete Datensatz enthält 1960 kriminelle und demografische Statistiken für 47 US-Bundesstaaten.
Es stammt aus dem UCR -Programm (Uniform Crime Reporting) des FBI und den zusätzlichen Quellen der US -Regierung.

Als Arbeit in der US -Regierung sind die Daten unter 17 US -Code § 105 öffentlich zugänglich und können ohne Einschränkung frei zu verwenden, zu teilen und sich zu reproduzieren.

Quellen:

Codes

Daten importieren

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Load the dataset
df = pd.read_csv('information/Multiple_Regression_Dataset.csv')
df.head()

Visuelle Analyse der Variablen

Create a brand new determine

# Extract response variable and covariates
response = 'R'
covariates = (col for col in df.columns if col != response)

fig, axes = plt.subplots(nrows=4, ncols=4, figsize=(20, 18))
axes = axes.flatten()

# Plot boxplot for binary variable 'S'
sns.boxplot(information=df, x='S', y='R', ax=axes(0))
axes(0).set_title('Boxplot of R by S')
axes(0).set_xlabel('S')
axes(0).set_ylabel('R')

# Plot regression strains for all different covariates
plot_index = 1
for cov in covariates:
    if cov != 'S':
        sns.regplot(information=df, x=cov, y='R', ax=axes(plot_index), scatter=True, line_kws={"shade": "pink"})
        axes(plot_index).set_title(f'{cov} vs R')
        axes(plot_index).set_xlabel(cov)
        axes(plot_index).set_ylabel('R')
        plot_index += 1

# Cover unused subplots
for i in vary(plot_index, len(axes)):
    fig.delaxes(axes(i))

fig.tight_layout()
plt.present()

Analyse der Korrelation zwischen Variablen

spearman_corr = df.corr(methodology='spearman')
plt.determine(figsize=(12, 10))
sns.heatmap(spearman_corr, annot=True, cmap="coolwarm", fmt=".2f", linewidths=0.5)
plt.title("Correlation Matrix Heatmap")
plt.present()

Filterprädiktoren mit hoher Interkorrelation (ρ> 0,6)

# Step 2: Correlation of every variable with response R
spearman_corr_with_R = spearman_corr('R').drop('R')  # exclude R-R

# Step 3: Establish pairs of covariates with robust inter-correlation (e.g., > 0.9)
strong_pairs = ()
threshold = 0.6
covariates = spearman_corr_with_R.index

for i, var1 in enumerate(covariates):
    for var2 in covariates(i+1:):
        if abs(spearman_corr.loc(var1, var2)) > threshold:
            strong_pairs.append((var1, var2))

# Step 4: From every correlated pair, preserve solely the variable most correlated with R
to_keep = set()
to_discard = set()

for var1, var2 in strong_pairs:
    if abs(spearman_corr_with_R(var1)) >= abs(spearman_corr_with_R(var2)):
        to_keep.add(var1)
        to_discard.add(var2)
    else:
        to_keep.add(var2)
        to_discard.add(var1)

# Remaining choice: all covariates excluding those to discard resulting from redundancy
final_selected_variables = (var for var in covariates if var not in to_discard)

final_selected_variables

Analyse der Multikollinearität mit VIF

from statsmodels.stats.outliers_influence import variance_inflation_factor
from statsmodels.instruments.instruments import add_constant
from sklearn.preprocessing import StandardScaler

X = df(final_selected_variables)  

X_with_const = add_constant(X)  

vif_data = pd.DataFrame()
vif_data("variable") = X_with_const.columns
vif_data("VIF") = (variance_inflation_factor(X_with_const.values, i)
                   for i in vary(X_with_const.form(1)))

vif_data = vif_data(vif_data("variable") != "const")

print(vif_data)

Machen Sie nach der Standardisierung ein lineares Regressionsmodell auf sechs Variablen, ohne die Daten in Zug und Check aufzuteilen

from sklearn.preprocessing import StandardScaler
from statsmodels.api import OLS, add_constant
import pandas as pd

# Variables
X = df(final_selected_variables)
y = df('R')

scaler = StandardScaler()
X_scaled_vars = scaler.fit_transform(X)

X_scaled_df = pd.DataFrame(X_scaled_vars, columns=final_selected_variables)

X_scaled_df = add_constant(X_scaled_df)

mannequin = OLS(y, X_scaled_df).match()
print(mannequin.abstract())

Dies ist der (und wahrscheinlich letzte) Teil von a Lineare Programmierung Serie, die ich geschrieben habe. Mit den Kernkonzepten, die in den früheren Artikeln behandelt werden, konzentriert sich dieser Artikel auf die Zielprogrammierung, die ein weniger häufiges Anwendungsfall (Linear Programming) darstellt. Die Zielprogrammierung ist ein spezifisches lineares Programmieraufbau, das die Optimierung mehrerer Ziele in einem einzelnen LP -Drawback verarbeiten kann.

Am Ende dieses Artikels werden Sie verstehen:
1. Definition der Zielprogrammierung und wann sollte sie verwendet werden
2. Der gewichtete Ziel -Programmieransatz – illustriert mit einem Beispiel
3. Der präventive Ziel -Programmieransatz – illustriert mit einem Beispiel

Definition und Anwendungsfall der Zielprogrammierung

Zielprogrammierung ist ein spezieller Fall einer linearen Programmierung, die es ermöglicht, dass mehrere – häufig widersprüchliche – Ziele ausgeglichen werden. Bei regelmäßigen LP -Problemen wählen Sie eine einzelne Metrik aus, um Einschränkungen zu optimieren (minimieren oder maximieren), um sicherzustellen, dass die optimale Lösung möglich ist. Zielprogrammierung ist eine Technik, mit der mehrere objektive Metriken gleichzeitig gezielt werden können.

Die „Denkweise“ der Zielprogrammierung unterscheidet sich grundlegend von Problemen mit einfachem Vanille -LP. Grundlegende LP -Suche nach Möglichkeiten, um so wenig oder so viel zu bekommen einzel Metrik wie möglich – z. B. den Gewinn maximieren oder Abfall minimieren – unterliegt Einschränkungen. Oft werden widersprüchliche Prioritäten in der Zielfunktion gefunden oder die Einschränkungen. Beispielsweise maximieren Sie den Gewinn (objektiv) unter einer maximalen Abfallmenge (Einschränkung). Mit der Zielprogrammierung können wir wichtige Einschränkungen in die objektive Funktion verschieben, damit wir sie optimieren können, anstatt sie nur einzuschränken. Wir können den Gewinn maximieren und Abfall gleichzeitig minimieren!

Jetzt ist ein guter Zeitpunkt, um das Beispiel zu ermitteln, das wir für den Relaxation des Artikels untersuchen werden:

Stellen wir uns vor, wir verwalten eine Fabrik, die Kleidung herstellt. Unsere Fabrik kann Hosen, Hemden und Kleider herstellen. Jeder Kleidungsstück hat Kosten, Gewinn und Abfall, die mit ihrer Produktion verbunden sind. Wir möchten einen Produktionsplan erstellen, der aufgrund eines Umweltverpflichtung ein gewisses Maß an Gewinn und Verschwendung unter eine bestimmte Menge macht. Nehmen wir an, wir wollen einen Gewinn mit 150.000 Greenback profitieren und wir wollen auch weniger als 20.000 Meter Stoff verschwenden. Zusätzlich zu unseren Zielen können wir nicht mehr als 50.000 US -Greenback an Materialien und Arbeitskräften ausgeben.

Das obige Beispiel oben klingt ein regelmäßiges lineares Programmierungsproblem, oder? Nun, die Wendung ist, dass wir keinen Gewinn von 150.000 US -Greenback erzielen und weniger als 20.000 Yards gleichzeitig verschwenden können. Mit anderen Worten, es würde keine praktikable Lösung geben, wenn wir diese in ein regelmäßiges lineares Programmierungsproblem anschließen würden. In der Regel können die Ziele, die in den Problemen festgelegt sind, nicht alle mit einer einzigen Lösung erreicht werden, da es sonst keinen Sinn bei der Verwendung der Zielprogrammierung geben würde. Wir würden einfach eine regelmäßige alte lineare Programmierung mit unseren Zielen als Einschränkungen verwenden. Der eigentliche Wert der Zielprogrammierung besteht darin, dass sie einen Kompromiss zwischen widersprüchlichen Zielen erstellen kann, wenn eine regelmäßige lineare Programmierung eine nicht realisierbare Lösung erzeugt.

Der eigentliche Wert der Zielprogrammierung besteht darin, dass sie einen Kompromiss zwischen widersprüchlichen Zielen erstellen kann, wenn eine regelmäßige lineare Programmierung eine nicht realisierbare Lösung erzeugt.

Wie kann das Programmierprogrammierung mit widersprüchlichen Zielen ausgleichen und kompromittieren? Es gibt zwei beliebte Ansätze: (1) gewichtet und (2) Präventiv. Wir werden diese in den folgenden Abschnitten ausführlich behandeln.

Der Gewichtsansatz

Hier werden wir uns mit den Particulars des Gewichtsansatzes befassen. Die Gewichtsmethode hat eine einzelne objektive Funktion und führt eine einzelne aus Optimierung Basierend auf (Sie haben es erraten) Gewichte! Die Tatsache, dass nur eine Optimierung unter der Gewichtsmethode ausgeführt wird, magazine wie eine Selbst sein – aber die präventive Methode führt tatsächlich mehrere lineare Programmieroptimierungen aus. Wir werden im nächsten Abschnitt dazu kommen…

Die Gewichtsmethode enthält spezifische Ziele oder Ziele für mehrere Metriken – z. B. mindestens 150.000 US -Greenback in Gewinnverkaufskleidung oder verschwenden nicht mehr als 20 km Stoff. Für die reguläre LP möchten wir vollständig optimieren. Für die Gewichtsmethode der Zielprogrammierung möchten wir so nahe wie möglich an die Ziele erreichen. Nachdem wir ein Ziel erreicht haben, ist die Optimierung bei der weiteren Maximierung oder Minimierung nicht mehr Vorteile, sodass sie das nächst wichtigste Ziel priorisiert. Wenn dies jetzt verwirrend erscheint, machen Sie sich keine Sorgen, dass es sinnvoller ist, wenn wir uns mit dem Beispiel einlassen.

Der objektive Funktion Für den Gewichtsansatz ist speziell formuliert, um die zu minimieren gewichtet Unterschiede zwischen dem Ziel einer Metrik und dem tatsächlichen Wert der Metrik. Lassen Sie uns von oben zu unserem Beispiel springen. Unser Ziel ist es, zu minimieren, wie weit wir von beiden Zielen entfernt sind.

Hier ist die mathematische Formulierung für dieses Ziel:

Mit unserer Zielfunktion müssen wir unsere Einschränkungen definieren. Wir haben zwei Arten von Einschränkungen (1) zielbezogene Einschränkungen und (2) regelmäßige lineare Programmierbeschränkungen (dieselben Einschränkungen, die Sie in der einfachen Vanille -LP finden würden). Sprechen wir zuerst über die zielbezogenen Einschränkungen.

Wir müssen zwei Dinge erstellen, um unsere zielbezogenen Einschränkungen zu errichten, (1) Gewinn- und Abfallfunktionen und (2) A number of Slack Variablen. Lassen Sie uns diese jeweils durchlaufen.

Die Gewinn- und Abfallfunktionen sind sehr einfach. Sie kombinieren unsere Entscheidungsvariablen miteinander, um den Gesamtgewinn zu berechnen, und die Gesamtabfälle ergeben eine bestimmte Lösung. Im Folgenden finden Sie die Formeln, die Gewinn und Verschwendung an die Anzahl der Hosen, Hemden und Kleider, die wir produzieren:

Lassen Sie uns mit unseren Gewinn- und Abfallfunktionen über unsere Slack -Variablen sprechen. Bei der Zielprogrammierung werden Slack -Variablen verwendet, um zu messen, wie weit eine Lösung aus einem Ziel ist. In unserem Beispiel die Variablen P Und W sind beide Slack -Variablen – sie repräsentieren, wie viel niedriger unser Gewinn mit unserem Gewinnziel ist und wie viel höher unsere Abfälle mit unserem Abfallziel sind. Slack -Variablen sind in Einschränkungen eingebettet. Im Folgenden finden Sie die Einschränkungen für unsere Gewinn- und Abfallziele – wieder die P’s und die W’s sind unsere lockeren Variablen:

Beachten Sie, dass wir Plus- und Minus -Slack -Variablen haben – dies ermöglicht es uns, das Ziel an beiden Enden zu verpassen. Wir wollen nur die Slack -Variable bestrafen, die in die entgegengesetzte Richtung unseres Ziels geht (z. B. wir wollen nicht bestrafen mehr Gewinn als unser Ziel wollen wir nur bestrafen weniger Gewinn) – Deshalb befindet sich nur eine Slack -Variable professional Ziel in der objektiven Funktion. Schreiben wir mit dieser neuen Notation unsere objektive Funktion um:

Wir haben jetzt die gesamte besondere Arbeit für die Zielprogrammierung geleistet. Das Letzte, was wir tun müssen, ist schnell unsere Einschränkung des einfachen Vanille -Budgets hinzuzufügen. Wir verwenden eine regelmäßige Einschränkung für unser Funds, da dies in unserem Beispiel eine harte Einschränkung darstellt. Im Gegensatz zu Gewinn und Abfall können wir das Funds nicht verletzen.

Jetzt haben wir ein vollständig spezifiziertes Zielprogrammierungsproblem. Lassen Sie es uns in Python einrichten und lösen!

# $150,000 in revenue
drawback += revenue + profit_deviation_neg - profit_deviation_pos == 150000, "Profit_Goal"

# Waste purpose: Not more than 20,000 yards of waste
drawback += waste + waste_deviation_neg - waste_deviation_pos == 20000, "Cost_Goal"

# Funds constraint
drawback += price <= 50000

# Resolve the issue
drawback.clear up()

# Show the outcomes
print("Standing:", pulp.LpStatus(drawback.standing))
print("Pants produced:", pulp.worth(pants))
print("Shirts produced:", pulp.worth(shirts))
print("Clothes produced:", pulp.worth(attire))
print("Value :", pulp.worth(price))
print("Revenue :", pulp.worth(revenue))
print("Revenue deviation (optimistic):", pulp.worth(profit_deviation_pos))
print("Revenue deviation (destructive):", pulp.worth(profit_deviation_neg))
print("Waste :", pulp.worth(waste))
print("Waste deviation (optimistic):", pulp.worth(waste_deviation_pos))
print("Waste deviation (destructive):", pulp.worth(waste_deviation_neg))

Diese Optimierung empfiehlt, dass wir 0 Hosen, 5.000 Hemden und 0 Kleider herstellen. Wir machen 150.000 US -Greenback in Gewinn, was genau zu unserem Ziel entspricht, und wir verschwenden 50 km Stoff, was unseren maximalen Abfall um 30.000 Yards übersteigt. Die vollständigen Ergebnisse werden vom Code gedruckt und unten gezeigt:

Jetzt, da wir die Grundstruktur des Gewichtsansatzes nach unten haben, sprechen wir tatsächlich darüber Gewichte! In unserem ersten Beispiel gaben wir einem Greenback Gewinn und einem Hof ​​Abfall gleich. Dies macht wahrscheinlich nicht viel Sinn, weil sie unterschiedliche Einheiten sind. Das Festlegen der Gewichte ist eine subjektive Entscheidung, die der Praktizierende getroffen wird. In unserem Beispiel werden wir entscheiden, dass die Verschwendung von 1,5 Metern Stoff genauso schlecht ist, wie es intestine ist, 1 US -Greenback für Gewinn zu erzielen. Mit anderen Worten, wir erhöhen das Gewicht von Stoffabfällen in unserer objektiven Funktion auf 1,5.

drawback += profit_deviation_neg + 1.5*waste_deviation_pos

Die Optimierung mit den aktualisierten Preisen empfiehlt, dass wir ungefähr 8.572 Hosen, 7.143 Hemden und 0 Kleider herstellen. Mit dieser Lösung generieren wir Gewinn in Höhe von 107.000 US -Greenback (was ein Ziel -Fehlschlag von 43.000 US -Greenback ist) und verschwenden 20.000 Meter Stoff, das genau zu unserem Ziel passt. Die vollständigen Ergebnisse werden vom Code gedruckt und unten gezeigt:

Das Verschieben der Gewichte der Ziele kann eindeutig einen großen Einfluss auf die Optimierungsergebnisse haben. Wir müssen unsere Gewichte sorgfältig festlegen, um die relative Bedeutung unserer Ziele angemessen auszugleichen!

Jetzt, da wir ein solides Verständnis dafür haben, wie der gewichtete Ansatz funktioniert, wechseln wir auf die Zielprogrammierung mit dem präventiven Ansatz.

Präventivansatz

Während die Gewichtsmethode Ziele mit Gewichten in der objektiven Funktion ausgleichen, bietet die präventive Methode den Zielen durch iterative Optimierungen hierarchischer Priorität. Das sind viele Worte, mach dir keine Sorgen, wir werden es aufschlüsseln!

Hier sind die Schritte zum präventiven Ansatz:

1. Führen Sie eine regelmäßige lineare Programmieroptimierung für Ihr erstes Ziel durch – z. B. den Gewinn maximieren
2. Speichern Sie den objektiven Wert vor diesem Lauf
3. Führen Sie eine weitere reguläre lineare Programmierung beim nächsten wichtigsten Ziel durch – z. B. Abfall minimieren -, fügen Sie jedoch den objektiven Wert aus dem letzten Lauf als Einschränkung hinzu
4. Wiederholen Sie den Vorgang, bis Sie alle Zielmetriken durchlaufen haben

Zwei wichtige Merkmale der präventiven Methode sind (1) die Ziele nach Rang und (2) der objektive Wert eines höheren Wichtigkeitsziels kann nicht verringert werden (aufgrund der harten Einschränkung), wenn die Ziele mit niedrigerer Priorität optimiert werden. Lassen Sie uns ein Beispiel durchgehen, um Instinct aufzubauen.

Nehmen wir für unser Beispiel an, dass Gewinn das wichtigste Ziel ist und die Minimierung von Abfällen das zweite ist. Wir werden mit einer einfachen Vanilleoptimierung beginnen, die den Gewinn maximiert:

# Outline the issue
drawback = pulp.LpProblem("Clothing_Company_Goal_Programming", pulp.LpMaximize)

# Choice variables: variety of pants, shirts, and attire produced
pants = pulp.LpVariable('pants', lowBound=0, cat='Steady')
shirts = pulp.LpVariable('shirts', lowBound=0, cat='Steady')
attire = pulp.LpVariable('attire', lowBound=0, cat='Steady')

# Revenue and value coefficients
revenue = 10 * pants + 3 * shirts + 15 * attire
price = 5 * pants + 1 * shirts + 10 * attire
waste = 1.5 * pants + 1 * shirts + 3 * attire

# Goal perform: Maximize revenue
drawback += revenue

# Constraints
# Funds constraint
drawback += price <= 50000

# Resolve the issue
drawback.clear up()

# Show the outcomes
print("Standing:", pulp.LpStatus(drawback.standing))
print("Pants produced:", pulp.worth(pants))
print("Shirts produced:", pulp.worth(shirts))
print("Clothes produced:", pulp.worth(attire))
print("Value :", pulp.worth(price))
print("Revenue :", pulp.worth(revenue))

Die Ergebnisse des Revenue -Maximierungs -LP -Issues sind unten:

Unsere objektive Funktion besagt additionally, dass sie 50.000 Hemden machen und einen Gewinn von 150.000 US -Greenback sammeln. Dies battle nur die erste Optimierung, die wir jedoch laufen werden! Nach dem oben beschriebenen Algorithmus werden wir nun eine weitere LP durchführen, die Abfall minimiert. Wir werden jedoch eine Gewinnbeschränkung von ≥ 150.000 US -Greenback hinzufügen, um sicherzustellen, dass wir keinen schlechteren Gewinn erzielen.

# Outline the issue
drawback = pulp.LpProblem("Clothing_Company_Goal_Programming", pulp.LpMinimize)

# Choice variables: variety of pants, shirts, and attire produced
pants = pulp.LpVariable('pants', lowBound=0, cat='Steady')
shirts = pulp.LpVariable('shirts', lowBound=0, cat='Steady')
attire = pulp.LpVariable('attire', lowBound=0, cat='Steady')

# Revenue and value coefficients
revenue = 10 * pants + 3 * shirts + 15 * attire
price = 5 * pants + 1 * shirts + 10 * attire
waste = 1.5 * pants + 1 * shirts + 3 * attire

# Goal perform: Decrease the material waste
drawback += waste

# Funds constraint
drawback += price <= 50000

drawback += revenue >= 150000

# Resolve the issue
drawback.clear up()

# Show the outcomes
print("Standing:", pulp.LpStatus(drawback.standing))
print("Pants produced:", pulp.worth(pants))
print("Shirts produced:", pulp.worth(shirts))
print("Clothes produced:", pulp.worth(attire))
print("Value :", pulp.worth(price))
print("Revenue :", pulp.worth(revenue))

Und hier sind die Ergebnisse dieser endgültigen Optimierung:

Der kluge Beobachter wird feststellen, dass die Optimierung genau das gleiche ist . Dies kann häufig bei der präventiven Methode der Fall sein. Die Einschränkung zuvor optimierter Ziele kann sehr restriktiv sein. Die einzige Zeit, in der iterative Optimierungen unterschiedlich sind, ist, wenn es mehrere Möglichkeiten gibt, die optimalen Werte für frühere Ziele zu erhalten. Zum Beispiel, wenn es zwei Möglichkeiten gab, 150.000 US -Greenback Gewinn zu erzielen; Einer hatte mehr Abfall und der andere hatte weniger, unsere zweite Iteration würde die Ergebnisse der Lösung mit dem niedrigeren Abfall zurückgeben. Bei der präventiven Methode gibt es keinen Kompromiss zwischen den Zielen. Selbst wenn es eine Lösung gäbe, die mit 0 Meter Abfall einen Gewinn in Höhe von 149.000 USD erzielte, würde die präventive Methode immer 150.000 US -Greenback mit Gewinn mit 50.000 Methoden Abfall wählen. Der zusätzliche Gewinn in Höhe von 1000 US -Greenback ist unendlich wichtiger als jede Menge verschwendeter Stoff.

Die präventive Methode sollte angewendet werden, wenn die Ziele eindeutig priorisiert werden, und es besteht keine Substitution zwischen ihnen. Dies bedeutet, dass kein Erfolg bei niedrigeren Prioritätszielen eine verringerte Optimierung bei höheren Priorität kompensieren kann. Bei korrekter Anwendung kann die präventive Methode dazu beitragen, ein Hauptziel zu optimieren und gleichzeitig zu versuchen, gute Lösungen für die Ziele niedrigerer Priorität sehr effektiv zu finden.

Abschluss

Die Zielprogrammierung bietet einen Framework, der die herkömmliche lineare Programmierung erweitert, um mehrere Metriken gleichzeitig zu optimieren. Der gewichtete Ansatz bilt die Prioritäten durch Gewichte in der objektiven Funktion und ist angemessen, wenn objektive Metriken eine relative Bedeutung haben, die quantifiziert werden kann. Die präventive Methode ist ein iterativer Ansatz, der den auf Hierarchie basierenden Metriken Priorität hat. Es ist angemessen, wenn einige Ziele ganz wichtiger sind als andere. Beide Ansätze können leistungsstarke Optimierungstechniken sein, wenn sie im richtigen Kontext angewendet werden!

Viel Spaß beim Optimieren!

Frühere Artikel in dieser Serie:

So wie Herr Miyagi dem jungen Daniel LaRusso Karate durch sich wiederholende einfache Aufgaben beibrachte, die ihn schließlich in das Karate Child verwandelten, legt die Beherrschung grundlegender Algorithmen wie der linearen Regression den Grundstein für das Verständnis der komplexesten KI-Architekturen wie Deep Neural Networks und LLMs.

Durch diesen tiefen Einblick in die einfache, aber leistungsstarke lineare Regression lernen Sie viele der grundlegenden Teile kennen, die die fortschrittlichsten Modelle ausmachen, die heute von Milliardenunternehmen entwickelt werden.

Die lineare Regression ist eine einfache mathematische Methode, mit der die Beziehung zwischen zwei Variablen verstanden und Vorhersagen getroffen werden können. Bei einigen Datenpunkten, wie dem folgenden, versucht die lineare Regression, die zu zeichnen Linie der besten Passform durch diese Punkte. Es ist das „Wachs an, Wachs weg“ der Datenwissenschaft.

Sobald diese Linie gezogen ist, verfügen wir über ein Modell, mit dem wir neue Werte vorhersagen können. Im obigen Beispiel könnten wir bei einer gegebenen neuen Hausgröße versuchen, den Preis mit dem linearen Regressionsmodell vorherzusagen.

Die lineare Regressionsformel

Y ist die abhängige Variable, additionally das, was Sie berechnen möchten – der Hauspreis im vorherigen Beispiel. Sein Wert hängt von anderen Variablen ab, daher der Title.

X sind die unabhängigen Variablen. Dies sind die Faktoren, die den Wert von beeinflussen Y. Bei der Modellierung sind die unabhängigen Variablen die Eingaben für das Modell, und das, was das Modell ausspuckt, ist die Vorhersage oder Ŷ.

β sind Parameter. Den Namen Parameter geben wir den Werten, die das Modell anpasst (oder lernt), um die Beziehung zwischen den unabhängigen Variablen zu erfassen X und die abhängige Variable Y. Während das Modell trainiert wird, bleibt die Eingabe des Modells dieselbe, die Parameter werden jedoch angepasst, um die gewünschte Ausgabe besser vorherzusagen.

Parameterlernen

Wir benötigen einige Dinge, um die Parameter anpassen und genaue Vorhersagen erzielen zu können.

1. Trainingsdaten – diese Daten bestehen aus Eingabe- und Ausgabepaaren. Die Eingaben werden in das Modell eingespeist und während des Trainings werden die Parameter angepasst, um zu versuchen, den Zielwert auszugeben.
2. Die Kostenfunktion – auch Verlustfunktion genannt – ist eine mathematische Funktion, die misst, wie intestine die Vorhersage eines Modells mit dem Zielwert übereinstimmt.
3. Trainingsalgorithmus – ist eine Methode, mit der die Parameter des Modells angepasst werden, um den durch die Kostenfunktion gemessenen Fehler zu minimieren.

Sehen wir uns eine Kostenfunktion und einen Trainingsalgorithmus an, die in der linearen Regression verwendet werden können.

MSE ist eine häufig verwendete Kostenfunktion bei Regressionsproblemen, bei denen das Ziel darin besteht, einen kontinuierlichen Wert vorherzusagen. Dies unterscheidet sich von Klassifizierungsaufgaben, beispielsweise der Vorhersage des nächsten Tokens in einem Vokabular, wie in großen Sprachmodellen. MSE konzentriert sich auf numerische Unterschiede und wird bei einer Vielzahl von Regressions- und neuronalen Netzwerkproblemen verwendet. So berechnen Sie es:

1. Berechnen Sie die Differenz zwischen dem vorhergesagten Wert, Ŷund der Zielwert, Y.
2. Quadrieren Sie diesen Unterschied – stellen Sie sicher, dass alle Fehler positiv sind, und bestrafen Sie große Fehler stärker.
3. Summieren Sie die quadrierten Differenzen für alle Datenproben
4. Teilen Sie die Summe durch die Anzahl der Proben, Num den durchschnittlichen quadratischen Fehler zu erhalten

Sie werden feststellen, dass der MSE kleiner wird, je näher unsere Vorhersage dem Zielwert kommt, und dass er umso größer wird, je weiter er davon entfernt ist. Beide Wege verlaufen quadratisch, da die Differenz quadriert wird.

Das Konzept des Gradientenabstiegs besteht darin, dass wir uns in kleinen Schritten durch den „Kostenraum“ bewegen können, mit dem Ziel, das globale Minimal zu erreichen – den niedrigsten Wert im Raum. Die Kostenfunktion bewertet, wie intestine die aktuellen Modellparameter das Ziel vorhersagen, indem sie uns den Verlustwert liefert. Eine zufällige Änderung der Parameter garantiert keine Verbesserungen. Wenn wir jedoch den Gradienten der Verlustfunktion in Bezug auf jeden Parameter untersuchen, d. h. die Richtung des Verlusts nach einer Aktualisierung des Parameters, können wir die Parameter so anpassen, dass sie sich in Richtung eines geringeren Verlusts bewegen, was darauf hindeutet, dass sich unsere Vorhersagen annähern die Zielwerte.

Die Stufen beim Gefälleabstieg müssen sorgfältig dimensioniert werden, um Fortschritt und Präzision in Einklang zu bringen. Bei zu großen Schritten besteht die Gefahr, dass wir über das globale Minimal hinausschießen und es ganz verfehlen. Sind die Schritte hingegen zu klein, werden die Aktualisierungen ineffizient und zeitaufwändig, wodurch die Wahrscheinlichkeit steigt, dass man in einem lokalen Minimal stecken bleibt, anstatt das gewünschte globale Minimal zu erreichen.

Gradientenabstiegsformel

Im Kontext der linearen Regression könnte θ sein β0 oder β1. Der Gradient ist die partielle Ableitung der Kostenfunktion nach θ, oder einfacher ausgedrückt, er ist ein Maß dafür, wie stark sich die Kostenfunktion ändert, wenn der Parameter θ leicht angepasst wird.

Ein großer Gradient zeigt an, dass der Parameter einen signifikanten Einfluss auf die Kostenfunktion hat, während ein kleiner Gradient auf einen geringen Effekt hindeutet. Das Vorzeichen des Gradienten gibt die Richtung der Änderung der Kostenfunktion an. Ein negativer Gradient bedeutet, dass die Kostenfunktion mit zunehmendem Parameter abnimmt, während ein positiver Gradient bedeutet, dass sie zunimmt.

Was passiert additionally mit dem Parameter, wenn ein großer negativer Gradient vorliegt? Nun, das adverse Vorzeichen vor der Lernrate wird mit dem negativen Vorzeichen des Gradienten aufgehoben, was zu einer Addition des Parameters führt. Und da der Farbverlauf groß ist, werden wir eine große Zahl hinzufügen. Daher wird der Parameter erheblich angepasst, um seinen größeren Einfluss auf die Reduzierung der Kostenfunktion widerzuspiegeln.

Werfen wir einen Blick auf die Preise der Schwämme, mit denen Karate Child Mr. Miyagis Auto gewaschen hat. Wenn wir ihren Preis (abhängige Variable) basierend auf ihrer Höhe und Breite (unabhängige Variablen) vorhersagen wollten, könnten wir ihn mithilfe einer linearen Regression modellieren.

Wir können mit diesen drei Trainingsdatenbeispielen beginnen.

Lassen Sie uns nun den mittleren quadratischen Fehler (MSE) als Kostenfunktion verwenden Jund lineare Regression als unser Modell.

Die lineare Regressionsformel verwendet X1 und X2 für die Breite bzw. Höhe. Beachten Sie, dass es keine unabhängigen Variablen mehr gibt, da unsere Trainingsdaten keine weiteren enthalten. In diesem Beispiel gehen wir davon aus, dass Breite und Höhe des Schwamms ausreichen, um seinen Preis vorherzusagen.

Der erste Schritt besteht nun darin, die Parameter zu initialisieren, in diesem Fall auf 0. Anschließend können wir die unabhängigen Variablen in das Modell einspeisen, um unsere Vorhersagen zu erhalten. Ŷund prüfen Sie, wie weit diese von unserem Ziel entfernt sind Y.

Wie Sie sich vorstellen können, sind die Parameter im Second nicht sehr hilfreich. Aber wir sind jetzt bereit, den Gradient Descent-Algorithmus zu verwenden, um die Parameter in nützlichere zu aktualisieren. Zuerst müssen wir die partiellen Ableitungen jedes Parameters berechnen, was einige Berechnungen erfordert, aber glücklicherweise müssen wir dies im gesamten Prozess nur einmal tun.

Mit den partiellen Ableitungen können wir die Werte unserer Fehler einsetzen, um den Gradienten jedes Parameters zu berechnen.

Beachten Sie, dass die MSE nicht berechnet werden musste, da sie nicht direkt bei der Parameteraktualisierung verwendet wird, sondern nur ihre Ableitung. Es ist auch sofort ersichtlich, dass alle Steigungen negativ sind, was bedeutet, dass alle erhöht werden können, um die Kostenfunktion zu verringern. Der nächste Schritt besteht darin, die Parameter mit einer Lernrate zu aktualisieren, bei der es sich um einen Hyperparameter handelt, additionally um eine Konfigurationseinstellung in einem maschinellen Lernmodell, die vor Beginn des Trainingsprozesses angegeben wird. Im Gegensatz zu Modellparametern, die während des Trainings erlernt werden, werden Hyperparameter manuell eingestellt und steuern Aspekte des Lernprozesses. Hier verwenden wir willkürlich 0,01.

Dies struggle der letzte Schritt unserer ersten Iteration im Prozess des Gradientenabstiegs. Wir können diese neuen Parameterwerte verwenden, um neue Vorhersagen zu treffen und den MSE unseres Modells neu zu berechnen.

Die neuen Parameter nähern sich den tatsächlichen Schwammpreisen an und haben zu einem viel niedrigeren MSE geführt, aber es gibt noch viel zu trainieren. Wenn wir den Gradientenabstiegsalgorithmus 50 Mal durchlaufen, dieses Mal mit Python statt von Hand – da Herr Miyagi nie etwas über Codierung gesagt hat – erreichen wir die folgenden Werte.

Schließlich kamen wir zu einem ziemlich guten Modell. Die wahren Werte, die ich zum Generieren dieser Zahlen verwendet habe, waren (1, 2, 3) und nach nur 50 Iterationen kamen die Parameter des Modells beeindruckend nahe. Durch die Erweiterung des Trainings auf 200 Schritte, was einen weiteren Hyperparameter darstellt, konnte das lineare Regressionsmodell bei gleicher Lernrate nahezu perfekt an die wahren Parameter konvergieren, was die Leistungsfähigkeit des Gradientenabstiegs demonstrierte.

Viele der grundlegenden Konzepte, die die komplizierte Kampfkunst der künstlichen Intelligenz ausmachen, wie Kostenfunktionen und Gradientenabstieg, können vollständig verstanden werden, wenn man einfach das einfache „Wachs an, Wachs weg“-Werkzeug der linearen Regression studiert.

Künstliche Intelligenz ist ein weites und komplexes Gebiet, das auf vielen Ideen und Methoden aufbaut. Obwohl es noch viel mehr zu entdecken gibt, ist die Beherrschung dieser Grundlagen ein wichtiger erster Schritt. Hoffentlich hat Sie dieser Artikel diesem Ziel näher gebracht, ein „Wachs auf, Wachs ab“ nach dem anderen.

Vor einigen Wochen habe ich veröffentlicht ein Beitrag auf LinkedIn.

Der Beitrag basierte auf der folgenden Abbildung und verglich die Vorhersagen zweier Modelle: Lineare Regression und CatBoost.

Der Kern des Beitrags warfare, dass ein Gradientenverstärkungsmodell wie CatBoost eine „vernünftigere“ Interpretation der Beziehung zwischen einem Prädiktor und der Zielvariablen (nämlich Hauszustand und Hauspreis) zu liefern scheint.

Tatsächlich sind viele Beziehungen in der Natur nichtlinear.

Der Beitrag erhielt einige Einwände, unter denen der folgende Kommentar durch die große Anzahl von Likes hervorstach:

Dies löste eine Diskussion aus und ich fand den folgenden Kommentar (vom selben Autor verfasst …)

Hinweis: Schauen Sie sich meine vorherigen Artikel für eine praktische Diskussion darüber, warum die Bayes’sche Modellierung für Ihre Aufgabe die richtige Wahl sein könnte.

Dieses Tutorial konzentriert sich auf einen Workflow + Code-Walkthrough zum Erstellen eines Bayesianischen Regressionsmodells in STANeine probabilistische Programmiersprache. STAN ist weit verbreitet und lässt sich mit der Sprache Ihrer Wahl verbinden (R, Python, Shell, MATLAB, Julia, Stata). Siehe die Set up führen und Dokumentation.

Ich werde verwenden Pystan für dieses Tutorial, einfach weil ich in Python programmiere. Selbst wenn Sie eine andere Sprache verwenden, unterscheiden sich die allgemeinen Bayes-Praktiken und die STAN-Sprachsyntax, die ich hier bespreche, nicht sehr.

Für den praxisorientierteren Leser gibt es hier einen Hyperlink zum Notizbuch für dieses Tutorial, Teil meines Workshops zur Bayesschen Modellierung an der Northwestern College (April 2024).

Lasst uns eintauchen!

Lernen wir, wie man ein einfaches lineares Regressionsmodell erstellt, das A und O eines jeden Statistikers, und zwar auf Bayes’sche Artwork und Weise. Unter der Annahme einer abhängigen Variable Y und Kovariate Xschlage ich das folgende einfache Modell vor:

Y = α + β * X + ϵ

Dabei ist ⍺ der Achsenabschnitt, β die Steigung und ϵ ein zufälliger Fehler. Unter der Annahme, dass

ϵ ~ Regular(0, σ)

Wir können zeigen, dass

Y ~ Regular(α + β * X, σ)

Wir lernen, wie dieses Modellformular in STAN codiert wird.

Daten generieren

Lassen Sie uns zunächst einige gefälschte Daten generieren.

#Mannequin Parameters
alpha = 4.0  #intercept
beta = 0.5 #slope
sigma = 1.0 #error-scale

#Generate pretend knowledge
x =  8 * np.random.rand(100)
y = alpha + beta * x
y = np.random.regular(y, scale=sigma) #noise
#visualize generated knowledge
plt.scatter(x, y, alpha = 0.8)

Da wir nun einige Daten zum Modellieren haben, wollen wir uns damit befassen, wie wir diese strukturieren und zusammen mit den Modellierungsanweisungen an STAN übergeben. Dies geschieht über die Modell Zeichenfolge, die normalerweise 4 (manchmal mehr) Blöcke enthält. Daten, Parameter, ModellUnd generiert MengenLassen Sie uns jeden dieser Blöcke im Element besprechen.

DATA-Block

knowledge {                    //enter the information to STAN
int<decrease=0> N;
vector(N) x;
vector(N) y;
}

Der Daten Block ist vielleicht der einfachste, er teilt STAN intern mit, welche Daten es erwarten soll und in welchem ​​Format. Hier übergeben wir beispielsweise:

N: die Größe unseres Datensatzes als Typ int. Der Teil erklärt, dass N≥0. (Auch wenn es hier offensichtlich ist, dass die Datenlänge nicht negativ sein kann, ist die Angabe dieser Grenzen eine gute Standardpraxis, die STANs Arbeit erleichtern kann.)

X: die Kovariate als Vektor der Länge N.

j: das abhängige Aspect als Vektor der Länge N.

Sehen Dokumente hier für eine vollständige Palette unterstützter Datentypen. STAN bietet Unterstützung für eine breite Palette von Typen wie Arrays, Vektoren, Matrizen usw. Wie wir oben gesehen haben, unterstützt STAN auch die Kodierung Grenzen auf Variablen. Die Kodierung von Grenzen wird empfohlen! Dies führt zu besser spezifizierten Modellen und vereinfacht die probabilistischen Sampling-Prozesse, die im Hintergrund ablaufen.

Modellblock

Als nächstes kommt der Modell Block, in dem wir STAN die Struktur unseres Modells mitteilen.

//easy mannequin block 
mannequin {                   
//priors
alpha ~ regular(0,10);
beta ~ regular(0,1); 
//mannequin
y ~ regular(alpha + beta * x, sigma);
}

Der Modellblock enthält außerdem ein wichtiges und oft verwirrendes Aspect: vor Spezifikation. Prioren sind eine Quintessenz Teil der Bayes’schen Modellierung und muss für die Stichprobenaufgabe entsprechend spezifiziert werden.

Siehe meine vorherige Artikel für eine Einführung in die Rolle und Instinct hinter Vorannahmen. Zusammenfassend lässt sich sagen, vor ist eine vorausgesetzte Funktionsform für die Verteilung von Parameterwerten – oft einfach bezeichnet als vorheriger Glaube. Auch wenn Vorstrafen nicht muss genau übereinstimmen die endgültige Lösung, sie müssen es uns ermöglichen, Probe davon.

In unserem Beispiel verwenden wir Normalverteilungen mit Mittelwert 0 und unterschiedlichen Varianzen, je nachdem, wie sicher wir uns des angegebenen Mittelwerts sind: 10 für Alpha (sehr unsicher), 1 für Beta (ziemlich sicher). Hier habe ich den allgemeinen Glauben dass Alpha zwar einen weiten Bereich unterschiedlicher Werte annehmen kann, die Steigung jedoch im Allgemeinen eingeschränkter ist und keinen großen Betrag aufweist.

Daher ist im obigen Beispiel die Vorhersage für Alpha „schwächer“ als für Beta.

Wenn Modelle komplizierter werden, erweitert sich der Lösungsraum für Stichproben, und die Bereitstellung von Überzeugungen gewinnt an Bedeutung. Andernfalls ist es eine gute Praxis, wenn keine starke Instinct vorhanden ist, einfach weniger Überzeugungen in das Modell einzubringen, d. h. eine schwach informativ im Voraus und bleiben Sie flexibel gegenüber eingehenden Daten.

Die Type für y, die Sie vielleicht bereits erkannt haben, ist die Standardgleichung für lineare Regression.

Erzeugte Mengen

Zuletzt haben wir unseren Block für erzeugte Mengen. Hier teilen wir STAN mit, welche Mengen wir berechnen und als Ausgabe erhalten möchten.

generated portions {    //get portions of curiosity from fitted mannequin
vector(N) yhat;
vector(N) log_lik;
for (n in 1:N) alpha + x(n) * beta, sigma); 
//chance of knowledge given the mannequin and parameters

}

Hinweis: STAN unterstützt die direkte Übergabe von Vektoren in Gleichungen oder als Iterationen 1:N für jedes Aspect n. In der Praxis habe ich festgestellt, dass sich diese Unterstützung mit verschiedenen Versionen von STAN ändert. Daher ist es intestine, die iterative Deklaration auszuprobieren, wenn die vektorisierte Model nicht kompiliert werden kann.

Im obigen Beispiel-

ja: generiert Samples für y aus den angepassten Parameterwerten.

log_lik: generiert die Wahrscheinlichkeit von Daten anhand des Modells und des angepassten Parameterwerts.

Der Zweck dieser Werte wird klarer, wenn wir über die Modellbewertung sprechen.

Insgesamt haben wir nun unser erstes einfaches Bayes-Regressionsmodell vollständig spezifiziert:

mannequin = """
knowledge {                    //enter the information to STAN
int<decrease=0> N;
vector(N) x;
vector(N) y;
}

parameters {              
actual alpha;
actual beta;
actual<decrease=0> sigma;
}mannequin {                   
alpha ~ regular(0,10);
beta ~ regular(0,1);   
y ~ regular(alpha + beta * x, sigma);
}generated portions {    
vector(N) yhat;
vector(N) log_lik;
for (n in 1:N) alpha + x(n) * beta, sigma);        
}
"""

Jetzt muss nur noch das Modell kompiliert und die Stichprobennahme durchgeführt werden.

#STAN takes knowledge as a dict
knowledge = {'N': len(x), 'x': x, 'y': y}

STAN nimmt Eingabedaten in Type eines Wörterbuchs entgegen. Es ist wichtig, dass dieses Wörterbuch alle Variablen enthält, die STAN laut unserer Anweisung im Modelldatenblock erwarten soll, da das Modell sonst nicht kompiliert werden kann.

#parameters for STAN becoming
chains = 2
samples = 1000
warmup = 10
# set seed

# Compile the mannequin
posterior = stan.construct(mannequin, knowledge=knowledge, random_seed = 42)
# Practice the mannequin and generate samples
match = posterior.pattern(num_chains=chains, num_samples=samples)The .pattern() technique parameters management the Hamiltonian Monte Carlo (HMC) sampling course of, the place —

• Anzahl Ketten: ist die Anzahl der Wiederholungen des Sampling-Prozesses.
• Anzahl_Beispiele: ist die Anzahl der in jeder Kette zu ziehenden Stichproben.
• sich heat laufen: ist die Anzahl der Anfangsproben, die wir verwerfen (da es einige Zeit dauert, bis die allgemeine Nähe des Lösungsraums erreicht ist).

Die Kenntnis der richtigen Werte für diese Parameter hängt sowohl von der Komplexität unseres Modells als auch von den verfügbaren Ressourcen ab.

Höhere Stichprobengrößen sind natürlich excellent, aber für ein schlecht spezifiziertes Modell erweisen sie sich als reine Zeit- und Rechenverschwendung. Ich habe schon einmal große Datenmodelle gehabt, bei denen ich eine Woche warten musste, bis sie fertig waren, nur um dann festzustellen, dass das Modell nicht konvergierte. Es ist wichtig, langsam anzufangen und Ihr Modell auf Plausibilität zu prüfen, bevor Sie eine vollwertige Stichprobennahme durchführen.

Modellbewertung

Die erzeugten Mengen werden genutzt für

• Bewertung der Anpassungsgüte, d. h. der Konvergenz,
• Vorhersagen
• Modellvergleich

Konvergenz

Der erste Schritt zur Bewertung des Modells im Bayes-Rahmen ist visuell. Wir beobachten die Stichprobenziehungen der Hamiltonsches Monte Carlo (HMC) Probenahmeverfahren.

Vereinfacht ausgedrückt, zieht STAN iterativ Stichproben für unsere Parameterwerte und wertet diese aus (HMC Weg mehr, aber das liegt außerhalb unseres derzeitigen Rahmens). Für eine gute Anpassung müssen die Stichprobenziehungen konvergieren auf einen gemeinsamen allgemeinen Bereich, der im Idealfall die globale optima.

Die obige Abbildung zeigt die Stichprobenziehungen für unser Modell über zwei unabhängige Ketten (rot und blau).

• Auf der linken Seite stellen wir die Gesamtverteilung des angepassten Parameterwertes dar, d. h. die HinterteileWir erwarten eine Regular Verteilung, wenn das Modell und seine Parameter intestine spezifiziert. (Warum ist das? Nun, eine Normalverteilung impliziert lediglich, dass es einen bestimmten Bereich von am besten passenden Werten für den Parameter gibt, was für unsere gewählte Modellform spricht). Darüber hinaus sollten wir eine beträchtliche überlappen über Ketten hinweg WENN Das Modell konvergiert zu einem Optimum.
• Auf der rechten Seite stellen wir die tatsächlichen Stichproben dar, die in jeder Iteration gezogen wurden (nur um sicherzugehen Additional sicher). Auch hier möchten wir nicht nur eine eng sondern auch eine Menge überlappen zwischen den Ziehungen.

Nicht alle Bewertungsmaßstäbe sind visuell. Gelman et al. (1) schlagen auch vor, Rhat Diagnose, die im Wesentlichen ein mathematisches Maß für die Ähnlichkeit der Stichproben zwischen den Ketten ist. Mithilfe von Rhat kann man einen Grenzwert definieren, ab dem die beiden Ketten als zu unterschiedlich beurteilt werden, um zu konvergieren. Der Grenzwert ist jedoch aufgrund der iterativen Natur des Prozesses und der variablen Aufwärmphasen schwer zu definieren.

Der visuelle Vergleich ist daher eine entscheidende Komponente, unabhängig von diagnostischen Checks

Ein häufig vorkommender Gedanke, den Sie hier haben könnten, ist: „Nun, wenn wir nur Ketten und Verteilungen haben, was ist dann der tatsächliche Parameterwert?“ Genau darum geht es. Die Bayes-Formulierung befasst sich nur mit VerteilungenNICHT Punkt Schätzungen mit ihren schwer zu interpretierenden Teststatistiken.

Dennoch kann die Posterior-Model wie folgt zusammengefasst werden: glaubwürdig Intervalle wie die Hohe Dichte Intervall (HDI), das alle x % Punkte mit der höchsten Wahrscheinlichkeitsdichte umfasst.

Es ist wichtig, Bayesianismus gegenüberzustellen glaubwürdig Intervalle mit Frequentisten Vertrauen Intervallen.

• Das glaubwürdige Intervall gibt eine Wahrscheinlichkeit Verteilung auf dem mögliche Werte für die Parameter d. h. die Wahrscheinlichkeit, dass der Parameter bei gegebenen Daten jeden Wert in einem bestimmten Intervall annimmt.
• Das Konfidenzintervall betrifft die Parameter Wert als behobenund schätzt stattdessen das Vertrauen, dass wiederholt zufällig Proben der Daten würden übereinstimmen.

Daher die

Der Bayes-Ansatz lässt die Parameterwerte fließend sein und nimmt die Daten für naked Münze, während der frequentistische Ansatz verlangt, dass es den einen wahren Parameterwert gibt … wenn wir doch nur Zugriff auf alle Daten hätten, die jemals

Puh. Lassen Sie das sacken und lesen Sie es noch einmal, bis es sackt.

Eine weitere wichtige Folge der Verwendung glaubwürdiger Intervalle, oder anders gesagt, der Möglichkeit, den Parameter Variableist, dass die Vorhersagen, die wir machen, dies erfassen Unsicherheit mit Transparenzwobei ein bestimmter HDI-Prozentsatz die am besten passende Linie angibt.

Modellvergleich

Im Bayes’schen Rahmen wird die Watanabe-Akaike-Informationsmetrik (WAIC) Rating ist die allgemein akzeptierte Wahl für den Modellvergleich. Eine einfache Erklärung des WAIC-Scores ist, dass er das Modell schätzt Wahrscheinlichkeit während regulierend für die Anzahl der Modellparameter. Einfach ausgedrückt kann es Überanpassungen berücksichtigen. Dies ist auch ein großer Vorteil des Bayes-Frameworks – man nicht unbedingt brauchen ein Modell vorführen Validierung Datensatz. Daher

Bei knappen Daten bietet die Bayes’sche Modellierung einen entscheidenden Vorteil.

Der WAIC-Rating ist ein Vergleichend Maß, d. h. es ist nur dann von Bedeutung, wenn es zwischen verschiedenen Modellen verglichen wird, die versuchen, dieselben zugrunde liegenden Daten zu erklären. In der Praxis kann man dem Modell additionally immer mehr Komplexität hinzufügen, solange der WAIC zunimmt. Wenn der WAIC an einem Punkt in diesem Prozess der manischen Komplexitätssteigerung zu sinken beginnt, kann man Schluss machen – mehr Komplexität bietet keinen Informationsvorteil bei der Beschreibung der zugrunde liegenden Datenverteilung.

Abschluss

Zusammenfassend lässt sich sagen, dass der STAN-Modellblock einfach eine Zeichenfolge ist. Er erklärt STAN, was Sie ihm geben (Modell), was gefunden werden soll (Parameter), was Ihrer Meinung nach vor sich geht (Modell) und was es Ihnen zurückgeben soll (generierte Mengen).

Beim Einschalten dreht STAN einfach die Kurbel und gibt seine Ausgabe aus.

Die wirkliche Herausforderung besteht darin, ein geeignetes Modell zu definieren (siehe vorherige Daten), die Daten entsprechend zu strukturieren, STAN genau zu fragen, was Sie von ihm benötigen, und die Plausibilität seiner Ergebnisse zu bewerten.

Sobald wir diesen Teil verstanden haben, können wir uns mit der wahren Leistungsfähigkeit von STAN befassen, wo die Spezifikation zunehmend komplizierter Modelle zu einer einfachen syntaktischen Aufgabe wird. Tatsächlich werden wir in unserem nächsten Tutorial genau dies tun. Wir werden auf diesem einfachen Regressionsbeispiel aufbauen, um Bayesian Hierarchisch Modelle: ein Industriestandard, auf dem neuesten Stand der Technik, de facto … was auch immer. Wir werden sehen, wie wir Radom oder feste Effekte auf Gruppenebene in unsere Modelle einbauen und uns darüber wundern, wie einfach es ist, Komplexität hinzuzufügen und gleichzeitig die Vergleichbarkeit im Bayes-Rahmen aufrechtzuerhalten.

Abonnieren Sie, wenn dieser Artikel hilfreich battle, und bleiben Sie auf dem Laufenden, um mehr zu erfahren!

Verweise

(1) Andrew Gelman, John B. Carlin, Hal S. Stern, David B. Dunson, Aki Vehtari und Donald B. Rubin (2013). Bayesianische Datenanalyse, dritte Ausgabe. Chapman und Corridor/CRC.

Bisher hat diese Serie die Grundlagen der linearen Programmierung behandelt. In diesem Artikel werden wir von den grundlegenden Konzepten zu den Particulars hinter der Oberfläche übergehen! Dieser Artikel behandelt die Simplex-Methode, den Algorithmus, der häufig zur Lösung linearer Programmierprobleme verwendet wird. Während wir ein einfaches Beispiel der linearen Programmierung mit der Simplex-Methode von Hand lösen, liegt unser Fokus eher auf der Instinct des Algorithmus als auf dem Auswendiglernen der algorithmischen Schritte (für solche Dinge haben wir Pc!).

Wir werden folgende Themen behandeln:

1. Warum die Simplex-Methode notwendig ist
2. Übergang von grafischen Lösungen zu algebraischen
3. Demonstration der Funktionsweise der Simplex-Methode anhand eines einfachen Beispiels

Im ersten Artikel dieser Reihe haben wir uns damit befasst, wie die Eigenschaften der linearen Programmierung es ermöglichen, nur die Eckpunkte von Einschränkungen als mögliche optimale Lösungen zu betrachten. Dies ist eine sehr leistungsstarke Funktion, die einen unendlichen Lösungsraum auf einen endlichen Lösungsraum verengt. In den Beispielen, die wir überprüft haben, hatten wir nur wenige Einschränkungen und wenige Variablen – einige davon haben wir sogar von Hand gelöst! Nachdem wir uns das angesehen haben …

Das ist etwas, was jeder, der viel Zeit mit Transformatoren und Selbstaufmerksamkeit verbracht hat, schon hundertmal gehört hat. Beides ist absolut wahr, wir haben das alle schon erlebt: Wenn man versucht, die Kontextgröße seines Modells zu erhöhen, kommt plötzlich alles zum Stillstand. Doch gleichzeitig gibt es, so scheint es, praktisch jede Woche ein neues hochmodernes Modell mit einer neuen rekordverdächtigen Kontextlänge. (Gemini hat eine Kontextlänge von 2 Millionen Token!)

Es gibt viele ausgefeilte Methoden wie RingAttention, die das Coaching unglaublich langer Kontextlängen in großen verteilten Systemen ermöglichen, aber was mich heute interessiert, ist eine einfachere Frage.

Wie weit kommen wir allein mit linearer Aufmerksamkeit?

Dies wird eine Artwork Blitztour, aber haben Sie etwas Geduld, denn wir werden ein paar wichtige Punkte ansprechen, bevor wir uns mit den Ergebnissen befassen.

Wir können den traditionellen Aufmerksamkeitsmechanismus im Wesentlichen mit zwei Kernpunkten zusammenfassen:

• Zunächst nimmt der typische Softmax-Aufmerksamkeitsausdruck das Produkt aus Abfrage- und Schlüsselmatrizen, normalisiert es zur Gewährleistung der Stabilität und nimmt dann das Softmax (zeilenweise), um die Aufmerksamkeitswerte zwischen den einzelnen Elementen der Sequenz zu erhalten.
• Zweitens wird die Zeitkomplexität von den N² Skalarprodukten dominiert, und das Produkt innerhalb des Softmax ist der limitierende Faktor. Dort berechnen wir die Aufmerksamkeitswerte.

Dies wird in der traditionellen Type wie folgt ausgedrückt:

Es stellt sich heraus, dass wir etwas anders darüber nachdenken können, wenn wir unsere Mathematikerfreunde fragen. Man kann sich den Softmax als eine von vielen Möglichkeiten vorstellen, die Wahrscheinlichkeitsverteilung zu beschreiben, die Token miteinander in Beziehung setzt. Wir können jedes beliebige Ähnlichkeitsmaß verwenden (das Skalarprodukt ist eines der einfachsten), und solange wir es normalisieren, ist alles in Ordnung.

Es ist ein bisschen schlampig, das zu sagen Ist Aufmerksamkeit, denn tatsächlich ist es nur die Aufmerksamkeit, die wir kennen und lieben, wenn die Ähnlichkeitsfunktion die Exponentialfunktion des Skalarprodukts von Abfragen und Schlüsseln (siehe unten) ist, wie wir es im Softmax finden. Aber hier wird es interessant: Was wäre, wenn wir statt dieses Ausdrucks eine Näherung vornehmen könnten?

Wir können davon ausgehen, dass es eine Characteristic-Map gibt.phi” was uns ein Ergebnis gibt quick das gleiche wie die Exponentialfunktion des Skalarprodukts. Und entscheidend ist, dass wir den Ausdruck auf diese Weise schreiben können, um mit der Reihenfolge der Matrixmultiplikationsoperationen zu spielen.

Im Papier Sie schlagen die Exponential Linear Unit (ELU) aufgrund einer Reihe nützlicher Eigenschaften als Merkmalskarte vor:

1. Für Werte über 0 liefert ELU(x) ein lineares Ergebnis, das zwar nicht mit der Exponentialfunktion identisch ist, aber die relative Reihenfolge zwischen den Wertungen beibehält.
2. Bei Werten kleiner oder gleich 0 bleibt der Exponentialterm der kontinuierliche Charakter der Funktion erhalten und stellt sicher, dass die Gradienten nicht einfach verschwinden.

Wir werden hier nicht allzu viel Zeit darauf verwenden, aber es ist empirisch ziemlich intestine bestätigt, dass dies eine gute Annäherung an die Softmax-Funktion ist.

Dadurch können wir die Reihenfolge der Operationen ändern. Wir können zuerst das Produkt unserer Characteristic-Map von Okay mit V nehmen, um einen KV-Block zu erstellen, und dann das Produkt mit Q. Das quadratische Produkt wird über die Modelldimensionsgröße und nicht über die Sequenzlänge bestimmt.

Wenn wir dies alles in den linearen Aufmerksamkeitsausdruck einfügen, erhalten wir:

Wobei wir die Begriffe in den Klammern nur einmal professional Abfragezeile berechnen müssen.

(Wenn Sie wissen möchten, wie die gelegentliche Maskierung hier hineinpasst und wie die Farbverläufe berechnet werden, werfen Sie einen Blick in das Dokument. Oder schauen Sie in diesem Bereich nach einem zukünftigen Weblog.)

Die mathematischen Argumente sind überzeugend, aber persönlich bin ich immer etwas misstrauisch, bis ich einige Benchmarks gesehen habe.

Sehen wir uns zunächst die Codeausschnitte an, die jeden dieser Begriffe beschreiben. Die Softmax-Aufmerksamkeit wird Ihnen sehr vertraut vorkommen, wir machen hier nichts Ausgefallenes.

class TraditionalAttention(nn.Module):
def __init__(self, d_k):
tremendous(TraditionalAttention, self).__init__()
self.d_k = d_k
def ahead(self, Q, Okay, V):
Z = torch.sqrt(torch.tensor(self.d_k, machine=Q.machine, dtype=torch.float32))
scores = torch.matmul(Q, Okay.transpose(-2, -1)) / Z
attention_weights = F.softmax(scores, dim=-1)
output = torch.matmul(attention_weights, V)
return output

Dann beginnen wir für die lineare Aufmerksamkeit mit dem Abrufen der Abfrage-, Schlüssel- und Wertematrizen und wenden dann die ELU(x)-Funktionszuordnung auf die Abfrage und die Schlüssel an. Dann verwenden wir die Einsummennotation, um die Multiplikationen durchzuführen.

class LinearAttention(nn.Module):
def __init__(self):
tremendous(LinearAttention, self).__init__()
self.eps = 1e-6
def elu_feature_map(self, x):
return F.elu(x) + 1
def ahead(self, Q, Okay, V):
Q = self.elu_feature_map(Q)
Okay = self.elu_feature_map(Okay)
KV = torch.einsum("nsd,nsd->ns", Okay, V)
# Compute the normalizer
Z = 1/(torch.einsum("nld,nd->nl", Q, Okay.sum(dim=1))+self.eps)
# Lastly compute and return the brand new values
V = torch.einsum("nld,ns,nl->nd", Q, KV, Z)
return V.contiguous()

Dies in Code geschrieben zu sehen ist schön und intestine, aber was bedeutet es tatsächlich experimentell? Von welcher Leistungssteigerung sprechen wir hier? Es kann schwierig sein, den Grad der Beschleunigung zu erfassen, wenn man von einem quadratischen zu einem linearen Engpass wechselt, additionally habe ich das folgende Experiment durchgeführt.

Wir werden eine einzelne Aufmerksamkeitsebene mit einer festen d_k-Modelldimension von 64 verwenden und die Zeit für einen Vorwärtsdurchlauf eines Sequenzsatzes mit 32 Batchgrößen als Benchmark verwenden. Die einzige zu ändernde Variable ist die Sequenzlänge, die zwischen 128 und 6000 liegt (die GPT-3-Kontextlänge als Referenz beträgt 2048). Jeder Durchlauf wird 100 Mal durchgeführt, um einen Mittelwert und eine Standardabweichung zu erhalten, und die Experimente werden mit einer Nvidia T4 GPU durchgeführt.

Für ein so einfaches Experiment sind die Ergebnisse ziemlich bemerkenswert.

Die Ergebnisse zeigen, dass wir sogar bei einem unglaublich kleinen Spielzeugbeispiel eine bis zu 60-fache Beschleunigung erreichen.

Diskussion

Hieraus lassen sich einige offensichtliche Erkenntnisse gewinnen:

1. Der Vorteil der linearen Aufmerksamkeit ist enorm – entweder in Bezug auf die Geschwindigkeit, ein höherer Durchsatz ist immer eine gute Sache. Oder in Bezug auf den Speicherbedarf zur Verarbeitung langer Sequenzen. In Umgebungen mit wenig Speicher kann dies ein großer Vorteil sein.
2. Das Verhältnisdiagramm weist einen überraschenden Knick auf – was uns vermuten lässt, dass hier eine zusätzliche Optimierung auf niedrigerer Ebene stattfindet, was bedeutet, dass das erwartete Verhältnis nicht ganz eintritt. Wir müssen dieses Ergebnis additionally mit Vorsicht genießen.

Der Vollständigkeit halber sei hier nicht verwechselt mit „lineare Aufmerksamkeit ist bei kleinen Modellen 60-mal schneller“. In Wirklichkeit machen die Feedforward-Schichten oft einen größeren Teil der Parameter in einem Transformer aus, und die Kodierung/Dekodierung ist oft auch eine Komponente mit limitierender Größe. Aber bei diesem eng definierten Downside ist das ziemlich beeindruckend!