[PYTHON] Differenzierung der Sortierung und Verallgemeinerung der Sortierung

0. Einleitung

Dieser Artikel beschreibt, wie man eine "Sortierung" "differenziert" und die Sortierung verallgemeinert. Unter Berücksichtigung der Verallgemeinerung der Sortierung kann auch die "Differenzierung" der Quantilfunktion berechnet werden.

Darüber hinaus werden wir tatsächlich mit einer maschinellen Lernaufgabe experimentieren, die als Regression der kleinsten Quantile bezeichnet wird, wobei Differenzierung und Verallgemeinerung von Arten verwendet werden.

Dies ist eine Einführung in den Inhalt des nächsten Papiers, das kürzlich von Google angekündigt wurde und Aufmerksamkeit erregt.

Differentiable Ranks and Sorting using Optimal Transport

Da eine ähnliche Technik wie in Artikel zur Unterscheidung von Transportproblemen verwendet wird, werden einige Erklärungen gegeben.

Differenzierung sortieren?

Wenn wir sort verwenden, verwenden wir es häufig in Form der folgenden zwei Funktionen, der Sortierfunktion $ S (x) $ und der Rangfunktion $ R (x) $.

x=(x_1,\dots ,x_n) \in R^n \\
S(x)=(x_{\sigma _1},\dots ,x_{\sigma _n}) \ \ \ \ \ \ x_{\sigma _1}\leq x_{\sigma_2}\leq \dots \leq x_{\sigma _n} \\
R(x)=(rank(x_1),\dots ,rank(x_n)) \ \ (=\sigma^{-1})

Zum Beispiel ist $ S ((3.4, 2.3, -1)) = (-1,2,3,3,4) $, $ R ((3,4, 2,3, -1)) = (3,2,1) $.

In diesem Artikel als "Differenzierung" von "Art"

Lassen Sie uns darüber nachdenken (so etwas wie).

• $ S (x) und R (x) $ können nicht so unterschieden werden, wie sie sind.

Anwendung der Sortendifferenzierung

Was wäre schön, wenn man die Sorte "differenzieren" könnte?

Der Hauptvorteil besteht darin, dass Sie End-to-End-Aufgaben des Typs lernen können, die die Ausgabe des Neuronalen Netzes sortieren und etwas lösen, wie im obigen Dokument erwähnt.

Zum Beispiel

• Wenn mehrere Bilder mit Zahlen eingegeben werden, werden die IDs der Bilder in absteigender Reihenfolge der Zahlen zurückgegeben.
• Geben Sie einem Produkt eine Empfehlungsbewertung und lernen Sie ein Empfehlungsmodell, indem Sie den Ranking-Verlust direkt differenzieren.
• Verwenden Sie einen teilbaren Strahlensuchdecoder für NLP-Aufgaben

Ein solches Problem kann in Betracht gezogen werden. Wenn die Sortierung differenziert werden kann, kann die Quantilfunktion auch wie später beschrieben differenziert werden, so dass die Aufgabe "Minimieren des n% -Werts des Regressionsfehlers" der letzten Quantilregression die Zielfunktion direkt differenziert. Sie können es mit lösen.

Symbol

• O^n
  \\\{ x|x\in R_n,x_1 \leq x_2 \leq \dots \leq x_n \\\}
• R^n_+
  \\\{ x|x\in R_n,x_i \geq 0,i=1,\dots ,n \\\}
• R^n_{+,*}
  \\\{ x|x\in R_n,x_i > 0,i=1,\dots ,n \\\}
• 1_n
  (1,...,1) \in R^n
• \Sigma_n
  \\\{x|x \in R^n_+, \sum x_i=1 \\\}
• U(a,b)
  $a \in R^n_+, b \in R^m_+, U(a,b)= $ $\{ P|P\in R^{n\times m}_+, P1_m=a, P^T1 _n=b \} $
• \langle P,Q\rangle
  P\in R^{n\times m},Q\in R^{n\times m},\langle P,Q\rangle=\sum_{i,j}P_{i,j}Q_{i,j}
• diag(a)
  $ a \ in R ^ n, diag (a): $ Diagonale Matrix von $ n \ mal n $, deren diagonale Komponente $ a $ ist

1. Sortierung, Transportprobleme und Differenzierung

Übrigens sind $ S (x) und R (x) $ nicht so differenzierbar wie sie sind. Wenn beispielsweise $ x $ zufällig aus $ R ^ n $ ausgewählt wird, sollte sich $ rank (x_1) $ nicht durch leichtes Erhöhen oder Verringern von $ x_1 $ ändern. Mit anderen Worten, selbst wenn "so etwas wie Differenzierung" definiert werden kann, ist es immer 0.

Führen Sie die folgenden Schritte aus, um diese Probleme zu lösen und das Differential der Art zu berechnen:

1. Betrachten Sie das Sortieren als eine Art Transportproblem.
2. Betrachten Sie das Problem, diesem Transportproblem einen Regularisierungsbegriff hinzuzufügen. (Es gibt nur eine optimale Lösung.)
3. Für Transportprobleme mit Regularisierungstermen gibt es einen Approximationsalgorithmus (Shinkhorn-Algorithmus), der die optimale Lösung in differenzierbarer Form findet.
4. Lösen Sie 2 mit dem Shinkhorn-Algorithmus, um die Ausgabe zu differenzieren.

Die Erklärungen sind unten in der Reihenfolge angegeben.

Sortier- und Versandprobleme

Transportprobleme

Wie der Name schon sagt, besteht das Transportproblem darin, die optimale Art des Transports von Produkten von mehreren Fabriken zu mehreren Filialen zu bestimmen. Die Lieferung zwischen den einzelnen Fabrik- und Lagerkosten richtet sich nach der Versandgebühr, und jedes Transportvolumen wird so festgelegt, dass die Gesamtversandkosten minimiert werden.

In mathematischen Begriffen gegeben $ a \ in R ^ n_ +, b \ in R ^ m_ +, C \ in R ^ {n \ mal m} _ + $, $ \ langle P, C \ rangle Finden von $ P \ in U (a, b) $, das $ minimiert. In diesem Artikel

L_C(a,b)=min_{P\in U(a,b)}\langle P,C\rangle

Schreiben.

$ a $ ist das Angebot der Fabrik, $ b $ ist die Nachfrage des Geschäfts, $ C_ {i, j} $ sind die Transportkosten pro Betrag zwischen der Fabrik $ i $ und dem Geschäft $ j $, $ P_ {i, j } $ Ist die Transportmenge zwischen der Fabrik $ i $ store $ j $ und $ \ angle P, C \ rangle $ sind die Gesamttransportkosten. Die Gesamtkosten für einen optimalen Transport betragen $ L_C (a, b) $.

Umgang mit speziellen Versandproblemen und Sortieren

Betrachten Sie nun das folgende einfache Transportproblem.

• Die Anzahl der Fabriken und Geschäfte ist gleich, $ n $ Stück
• Fabrik und Laden sind in einer geraden Linie angeordnet
• Setzen Sie $ x, y \ in R _n $ als Koordinaten der Fabrik bzw. des Geschäfts.
• Angenommen, der Standort jedes Geschäfts erfüllt die Beziehung $ y _1 <y _2 <\ dots <y _n . ( y \ in O ^ n $)
• Die Lieferkosten steigen mit zunehmendem Abstand zwischen den Fabriklagern. Multiplizieren Sie $ C _ {i, j} = h (y _j -x _i) $ mit der differenzierbaren nicht negativen schmalen konvexen Funktion $ h $.
• Das Angebot der Fabrik und die Nachfrage des Geschäfts sind alle gleich, $ 1 / n $, dh $ a = b = 1 _n / n $

Zu diesem Zeitpunkt gilt der folgende Vorschlag, der Sortier- und Transportprobleme miteinander verbindet.

Satz 1.

Unter den obigen Umständen ist eine der optimalen Lösungen für das Transportproblem $ L_C (a, b) = min_ {P \ in U (a, b)} \ Winkel P, C \ rangle $ $ P _ * $. Machen. Zu diesem Zeitpunkt gilt Folgendes.

R(x)=n^2 P_* \hat{b} \\
S(x)=n P_*^T x \\

Wobei $ \ hat {b} = (b_1, b_1 + b_2, \ Punkte, \ Summe b) ^ T = (1 / n, 2 / n, \ Punkte, 1) ^ T $

Berücksichtigen Sie in der Tat das folgende Transportproblem:

Transportkosten (= Quadrat der Entfernung)

Das optimale Transportvolumen sollte sein:

Setzen wir diese in die Satzgleichung ein.

3^2 \left(
    \begin{array}{ccc}
      0 & 0 & 1/3 \\
      0 & 1/3 & 0 \\
      1/3 & 0 & 0
    \end{array}
  \right)
  \left(
    \begin{array}{ccc}
      1/3   \\
      2/3   \\
      1 
    \end{array}
  \right) = 
  \left(
    \begin{array}{ccc}
      3   \\
      2   \\
      1 
    \end{array}
  \right) = R(
\left(
    \begin{array}{ccc}
      2   \\
      1   \\
      0 
    \end{array}
  \right)
  )

3 \left(
    \begin{array}{ccc}
      0 & 0 & 1/3 \\
      0 & 1/3 & 0 \\
      1/3 & 0 & 0
    \end{array}
  \right)
  \left(
    \begin{array}{ccc}
      2   \\
      1   \\
      0 
    \end{array}
  \right) = 
  \left(
    \begin{array}{ccc}
      0   \\
      1   \\
      2 
    \end{array}
  \right) = S(
\left(
    \begin{array}{ccc}
      2   \\
      1   \\
      0 
    \end{array}
  \right)
  )

Sie können sehen, dass die Formel des Satzes gilt.

Transportprobleme und Differenzierung

Im vorherigen Kapitel haben wir bestätigt, dass $ S (x) und R (x) $ mithilfe der Lösung eines speziellen Transportproblems notiert werden können. Wenn daher die Differenzierung der Lösung des Transportproblems ($ P _ \ * $ von Satz 1) durch $ C _ {i, j} $ berechnet werden kann, hängt dies von $ x _i $ von $ S (x), R (x) $ ab. Das Differential kann auch berechnet werden. Dieses $ P _ \ * $ selbst ist nicht teilbar, aber es gibt eine Möglichkeit, eine ungefähre Lösung von $ P _ \ * $ in teilbarer Form zu finden.

Das heißt, betrachten Sie zuerst das folgende Transportproblem mit einem "Regularisierungsbegriff". Mit anderen Worten, die Entropie des Transportvolumens

H(P)=-\sum_{i,j}P_{i,j}(log(P_{i,j})-1)

Wie anstelle des ursprünglichen Problems

L_C^{\epsilon}(a,b)=min_{P\in U(a,b)}\langle P,C\rangle - \epsilon H(P)　★

Nachdenken über. Bei $ \ epsilon \ bis 0 $ konvergiert die Lösung dieses regulierten Transportproblems zur Lösung des ursprünglichen Transportproblems.

Darüber hinaus kann der folgende Shinkhorn-Algorithmus verwendet werden, um eine ungefähre Lösung in teilbarer Form zu finden.

Shinkhorn-Algorithmus

init u=u^0,v=v^0,l=0, calc K;

while l < MAX_ITER: \ \ \ \ u=a/(Kv) \ \ \ \ v=b/(K^Tu) \ \ \ \ l++

P=diag(u)Kdiag(v)

return P

MAX_ITER $ \ to \ infty $ bewirkt, dass die Ausgabe des Shinkhorn-Algorithmus zur optimalen Lösung von ★ konvergiert. In Bezug auf diesen Shinkhorn-Algorithmus

Transportprobleme unterscheiden

Ich erklärte im Detail in.

Implementierung durch PyTorch

Lassen Sie uns den Shinkhorn-Algorithmus in PyTorch implementieren und damit das Differential der Sortierung berechnen.

import torch
from torch import nn

#Shinkhorn-Algorithmus
class OTLayer(nn.Module):
    def __init__(self, epsilon):
        super(OTLayer,self).__init__()
        self.epsilon = epsilon

    def forward(self, C, a, b, L):
        K = torch.exp(-C/self.epsilon)
        u = torch.ones_like(a)
        v = torch.ones_like(b)
        l = 0
        while l < L:
            u = a / torch.mv(K,v)
            v = b / torch.mv(torch.t(K),u)
            l += 1
                
        return u, v, u.view(-1,1)*(K * v.view(1,-1))

# sort & rank
class SortLayer(nn.Module):
    def __init__(self, epsilon):
        super(SortLayer,self).__init__()
        self.ot = OTLayer(epsilon)
        
    def forward(self, x, L):
        l = x.shape[0]
        y = (x.min() + (torch.arange(l, dtype=torch.float) * x.max() / l)).detach()
        C = ( y.repeat((l,1)) - torch.t(x.repeat((l,1))) ) **2
        a = torch.ones_like(x) / l
        b = torch.ones_like(y) / l
        _, _, P = self.ot(C, a, b, L)
        
        b_hat = torch.cumsum(b, dim=0)
        
        return l**2 * torch.mv(P, b_hat), l * torch.mv(torch.t(P), x)

sl = SortLayer(0.1)
x = torch.tensor([2., 8., 1.], requires_grad=True)
r, s = sl(x, 10)
print(r,s)

tensor([2.0500, 3.0000, 0.9500], grad_fn=<MulBackward0>) tensor([1.0500, 2.0000, 8.0000], grad_fn=<MulBackward0>)

(Berechnung der Differenzierung)

r[0].backward()
print(x.grad)

tensor([ 6.5792e-06,  0.0000e+00, -1.1853e-20])

2. Sortieren Sie die Generalisierung und die Quantilfunktion

Generalisierung sortieren

Im vorherigen Kapitel haben wir gesehen, dass die Sortier- und Rangfunktionen $ S (x) und R (x) $ mithilfe der Lösung eines speziellen Transportproblems notiert werden können. Das spezielle Versandproblem, das dieser Art entspricht, ist

• Die Anzahl der Fabriken und die Anzahl der Geschäfte sind gleich ――Die Angebotsmenge der Fabrik und die Nachfragemenge des Geschäfts sind alle gleich

Ich habe gesagt. Im Allgemeinen können Transportprobleme jedoch auch dann berücksichtigt werden, wenn die Anzahl der Fabriken und Geschäfte unterschiedlich ist oder wenn Angebot und Nachfrage je nach Fabriken und Geschäften unterschiedlich sind. Unter Berücksichtigung von $ S (x), R (x) $, die den Lösungen dieser allgemeinen Transportprobleme entsprechen, sollten wir in der Lage sein, Ränge zu sortieren und zu verallgemeinern.

Basierend auf dieser Idee ist K (Kantorovich) in Differenzierbare Ränge und Sortieren mit optimalem Transport eine verallgemeinerte Sortierfunktion und Rangfunktion wie folgt. ) Sortierung und K-Rang wurden eingeführt.

Definition 1. K-Sortierung und K-Rang

Transportprobleme für $ x \ in R ^ n, y \ in O ^ n, a \ in \ Sigma_n, b \ in \ Sigma_m $ und die eng konvexe Funktion $ h $

Sei $ P _ * $ eine der optimalen Lösungen für. Zu diesem Zeitpunkt sind die K-Sortierung und der K-Rang von $ x $ wie folgt definiert.

\hat{S} (a,x,b,y)=diag(b^{-1})P^T _* x \\
\hat{R} (a,x,b,y)=n* diag(a^{-1})P_* \hat{b}

Hier repräsentieren $ a ^ {-1} und b ^ {-1} $ die Umkehrung jedes Elements des Vektors.

$ P_ * \ in U (a, b) $

P_* 1_n = a \\
P^T_* 1_m = b

Treffen. Daher sind $ diag (b ^ {-1}) P ^ T _ \ * $ und $ diag (a ^ {-1}) P von $ \ hat S, \ hat R $ Der _ \ * $ Teil kann als normalisiert angesehen werden, so dass die Summe der Zeilen von $ P ^ T _ \ *, P _ \ * $ alle 1 ist. Wenn $ a = b = 1 _n / n $ ist, wird das ursprüngliche $ S, R $ erhalten, was eine natürliche Erweiterung der Sortierfunktion und der Rangfunktion ist.

Beachten Sie auch, dass bei $ b = 1_n / n $ $ n \ hat b $ $ (1,2, \ dots, n) $ in der Reihenfolge "Rang" ist. Daher kann $ \ hat b $, das dem allgemeinen $ b $ entspricht, als Verallgemeinerung des "Ranges" angesehen werden und nimmt einen realen Wert an. Berücksichtigt man dies

• $ \ hat S _i $ ist eine lineare Kombination von $ x _i $, die dem $ i $ -ten Rang zugeordnet ist.
• $ \ hat R _j $ ist eine lineare Kombination von verallgemeinerten Rängen (Rang = $ \ hat b $), denen $ x _j $ zugeordnet ist

Sie können dies auch bestätigen.

Ich habe versucht, den Unterschied zwischen normaler Sortierung, Rang und K-Sortierung und K-Rang in der folgenden schematischen Darstellung zu zeigen. K sort und K rank repräsentieren den Fall von $ a = 1 _5 / 5, b = (0,48, 0,16, 0,36) $.

Quantilfunktion

Was ist die Quantilfunktion?

Ist die Funktion $ q $. Tatsächlich können Sie die K-Sortierung $ \ hat S $ verwenden, um die Quantilfunktion effizient zu berechnen. Zum Beispiel ist $ x \ in R ^ n $ eine Menge von Datenpunkten und K sortiert in der Situation, in der $ a = 1_n / n, y = (0,1 / 2,1), b = (0,29,0,02,0,69) $ Betrachten Sie $ \ hat S (a, x, b, y) $.

Wie in der obigen Abbildung gezeigt, können Sie sich vorstellen, dass die unteren 30% von x mit $ y_1 $ verknüpft sind, die oberen 60% mit $ y_3 $ verknüpft sind und nur die Punkte in der Nähe des 30% -Punkts von x mit $ y_2 $ verknüpft sind. ..

Daher verwendet die Quantilfunktion die K-Sortierung und einen vernünftig kleinen Wert t,

Sie können erwarten, anzurufen. Wie im vorherigen Kapitel erläutert, kann der Shinkhorn-Algorithmus verwendet werden, um eine teilbare Näherung von $ \ hat S $ zu erhalten, sodass auch die Differenzierung der Quantilfunktion berechnet werden kann.

Beachten Sie auch, dass die obige K-Sortierung in der Reihenfolge $ O (nl) $ durchgeführt werden kann ($ l $ ist die Anzahl der Iterationen des Shinkhorn-Algorithmus).

Implementierung durch PyTorch

Lassen Sie uns die K-Sortierung in PyTorch implementieren und die Quantilfunktion berechnen. Verwenden Sie den OTLyer aus dem vorherigen Kapitel.

class QuantileLayer(nn.Module):
    def __init__(self, epsilon):
        super(QuantileLayer,self).__init__()
        self.ot = OTLayer(epsilon)
        self.y = torch.Tensor([0.,0.5,1.])
        
    def forward(self, x, tau, t, L):
        l = x.shape[0]
       
        C = ( self.y.repeat((l,1)) - torch.t(x.repeat((3,1))) ) **2
        a = torch.ones_like(x) / l
        b = torch.Tensor([tau-t/2, t, 1-tau-t/2])
        
        _, _, P = self.ot(C, a, b, L)
        
        b_hat = torch.cumsum(b, dim=0)
        
        return (torch.mv(torch.t(P), x) / b)[1]

(Fragen Sie nach 30% Punkten)

import numpy as np

np.random.seed(47)

x = np.random.rand(1000)

quantile = QuantileLayer(0.1)
print(quantile(torch.tensor(x,dtype=torch.float), 0.3, 0.1, 10))

tensor(0.3338)

3. Anwendung der Sortierdifferenzierung und Verallgemeinerung

Als einfache Anwendung der Sortendifferenzierung und Verallgemeinerung auf maschinelles Lernen werden wir die Aufgabe der Regression der kleinsten Quantile lösen, indem wir die Zielfunktion direkt unter Verwendung der Quantilfunktion differenzieren und die Gradientenmethode ausführen.

least quantile regression Während die gewöhnliche lineare Regression das Modell optimiert, um den "Mittelwert" des Vorhersagefehlers zu minimieren, trainiert die Regression mit dem geringsten Quantil das Modell, um den "n% -Wert" des Fehlers zu minimieren. Dies beinhaltet die Aufgabe, den Medianwert zu minimieren, der der "50% -Wert" des Fehlers ist. Zum Beispiel

• Das Rauschen der Daten ist keine Gaußsche Verteilung, und der Lehrerwert verschiebt sich erheblich in eine bestimmte Richtung.

Dies ist nützlich, wenn Sie den "Mittelpunkt" des Fehlers minimieren möchten, indem Sie die Ausreißerdaten ignorieren.

In diesem Artikel werden wir mit der Regression des geringsten Quantils unter Verwendung von jährlichen Einkommensdaten experimentieren, die häufig verwendet werden, um den Unterschied zwischen "Mittelwert" und "Median" zu erklären. Erstellen wir ein Modell, das das jährliche Einkommen aus dem Alter anhand von Daten zum Durchschnittsalter und zum durchschnittlichen Jahreseinkommen börsennotierter Unternehmen vorhersagt. Das Modell wird trainiert, indem der "Medianfehler" direkt differenziert und die Gradientenabstiegsmethode unter Verwendung der in diesem Artikel beschriebenen Methode ausgeführt wird.

Für die Daten habe ich veröffentlicht von yutakikuchi auf github verwendet.

Experiment

Unternehmen mit einem Durchschnittsalter von 45 Jahren oder jünger werden aus den Daten extrahiert und verwendet. (Um es einfacher zu machen, den Unterschied zur normalen linearen Regression zu beobachten.)

Die Verteilung der Daten ist wie folgt.

Es scheint, dass Alter und Jahreseinkommen in etwa proportional sind, aber es kann bestätigt werden, dass der Lärm keine Normalverteilung ist und sich die Streuung in Richtung eines größeren Jahreseinkommens ausbreitet. Sie können erwarten, dass ein normales lineares Regressionsmodell von Ausreißern gezogen wird und den Gradienten überschätzt.

Der Code zum Lernen eines linearen Modells durch direktes Differenzieren des "Medianwerts" (= 50% Punkt) des Fehlers unter Verwendung der in diesem Artikel entwickelten Methode lautet wie folgt. (Der Datenformatierungsteil wird weggelassen.)

(Schicht, die den Sinkhorn-Algorithmus ausführt)

import torch
from torch import nn
import torch.optim as optim


class OTLayer(nn.Module):
    def __init__(self, epsilon):
        super(OTLayer,self).__init__()
        self.epsilon = epsilon

    def forward(self, 
                C, # batch_size, n, m 
                a, # batch_size, n
                b, # batch_size, m
                L):
        bs = C.shape[0]
        K = torch.exp(-C/self.epsilon) # batch_size, n, m
        u = torch.ones_like(a).view(bs,-1,1) # batch_size, n, 1
        v = torch.ones_like(b).view(bs,-1,1) # batch_size, m, 1
        l = 0
            u = a.view(bs,-1,1) / (torch.bmm(K,v) + 1e-8) # batch_size, n, 1
            v = b.view(bs,-1,1) / (torch.bmm(torch.transpose(K, 1, 2),u) + 1e-8)# batch_size, m, 1
            l += 1
                
        return u * K * v.view(bs,1,-1) # batch_size, n, m

(Schicht, die die Quantilfunktion berechnet)

class QuantileLayer(nn.Module):
    def __init__(self, epsilon, y):
        super(QuantileLayer,self).__init__()
        self.ot = OTLayer(epsilon)
        self.y = y.detach()
        
    def forward(self, x, # batch_size, seq_len
                tau, t, L):
        bs = x.shape[0]
        seq_len = x.shape[1]
        C = ( self.y.repeat((bs,seq_len,1)) - x.unsqueeze(-1).expand(bs,seq_len,3) ) **2 # batch_size, seq_len, 3
        
        a = torch.ones_like(x) / seq_len  # batch_size, seq_len
        b = torch.Tensor([tau-t/2, t, 1-tau-t/2]).expand([bs, 3]) # batch_size, 3
        
        P = self.ot(C, a, b, L) # batch_size, seq_len, 3
        
        k_sort =  torch.bmm(
            torch.transpose(P,1,2), # batch_size, 3, seq_len 
            x.unsqueeze(-1) # batch_size, seq_len, 1
        ).view(-1) / b.view(-1) # 3, 

        return k_sort[1]

(Datenaufbereitung von Alter = Alter und Jahreseinkommen = Einkommen)

import pandas as pd

data = pd.DataFrame({"age":ages, "income":incomes})
data_2 = data[data.age <= 45]
ppd_data = (data_2- data_2.mean(axis=0))/data_2.std(axis=0)

X = torch.Tensor(ppd_data.age.values.reshape(-1,1))
ans =  torch.Tensor(ppd_data.income.values.reshape(-1,1))

(Ausführung lernen)

model = nn.Linear(1,1)
loss = nn.MSELoss(reduction='none')

y = [0, ppd_data.income.max()/4., ppd_data.income.max()/2.]
quantile = QuantileLayer(0.1, torch.Tensor(y))

optimizer = optim.Adam(model.parameters(), lr=0.1)

MAX_ITER = 100
for i in range(MAX_ITER):
    optimizer.zero_grad()
    
    pred = model(X)
    loss_value = loss(pred, ans).view(1,-1) # 1, seq_len( = data size)
    
    #Medianfehler berechnen
    quantile_loss = quantile(loss_value, 0.5, 0.1, 10)
    print(quantile_loss)
    quantile_loss.backward()
    optimizer.step()

Hier ist ein Vergleich der Anpassungsergebnisse des trainierten Modells und des regulären Regressionsmodells, das den "Mittelwert" des Fehlers minimiert: Es kann bestätigt werden, dass das Modell mit dem minimierten Medianwert (= Quantil) weniger wahrscheinlich von den Ausreißerdaten gezogen wird.

4. Zusammenfassung

In diesem Artikel habe ich erklärt, wie man die Sortierung unterscheidet und wie man die Quantilfunktion in einer teilbaren Form als Verallgemeinerung der Sortierung berechnet. Als einfache Anwendung haben wir die Aufgabe der Regression der kleinsten Quantile mit der Gradientenmethode gelöst und den Unterschied zwischen dem Modell, das den "Mittelwert" minimiert, und dem Modell, das den "Medienwert" des Fehlers minimiert, beobachtet.

Wie zu Beginn eingeführt, wird erwartet, dass die Sortendifferenzierung ein breiteres Anwendungsspektrum wie die Strahlensuchdifferenzierung hat und in Zukunft in verschiedenen Veröffentlichungen zu sehen sein wird.