Novembre 2017

Volume 33 Numero 11

Il presente articolo è stato tradotto automaticamente.

Esecuzione dei test - Regressione della logistica del kernel con C#

Da James McCaffrey

James McCaffrey

La regressione della logistica del kernel è una tecnica di Machine Learning che consente di ottenere previsioni binarie. Ad esempio, KLR possibile stimare se una persona verrà reintegrare un prestito (esito negativo a rimborsare = 0, correttamente rimborsare = 1) in base alle variabili predittive, ad esempio l'età, reddito e quantità di debito esistente. KLR è una variante avanzate della regressione logistica normale.

È un buon metodo per visualizzare in questo articolo è a due punte per dare un'occhiata il programma demo in figura 1 e i dati associati in figura 2. L'obiettivo del programma demo consiste nello stimare la classe, 0 o 1, di dati fittizi che ha solo due variabili predittive (talvolta denominate funzionalità), x0 e x1. Ad esempio, i dati di training primo elemento sono (2.0, 3.0, 0), vale a dire che se i valori predittive sono x0 = 2.0 e x1 = 3.0, la classe corretta è 0. KLR la gestione dei dati con un numero qualsiasi di variabili predittive, ma solo due consente di visualizzare facilmente la tecnica.

Il 21 punti dati di training hanno una geometria circolare, ovvero le tecniche di classificazione lineare semplice, come la regressione logistica normale, sono inefficaci. Tali dati vengono denominati separabili in modo non lineare.

Dietro le quinte, KLR utilizza una funzione chiamata di un kernel di funzione (RBF) radiale di base. La funzione kernel RBF ha un parametro denominato sigma. Il valore di sigma deve essere determinato dal prove ed errori e sigma è impostato su 1.0 nella demo. Training di un modello KLR è un processo iterativo e la dimostrazione imposta il numero massimo di iterazioni a 1.000 e imposta una velocità di apprendimento, greco, 0,001.

Training di un modello KLR crea un set di "valori alfa", uno per ogni elemento di dati di training, oltre a un altro valore di "distorsione". Il programma demo Visualizza i valori alfa per i primi tre elementi di training (-0.3071,-0.3043,-0.3071) e gli ultimi due elementi (0.8999, 0.6108) e la deviazione (-1.0722).

Dopo il training, il modello KLR stima correttamente tutti gli elementi 21 dati. Il modello viene quindi applicato agli elementi di dati di test quattro, visualizzati come neri puntini di sospensione figura 2. Il primo elemento di test con input (1.5, 4.5) e una classe corretta pari a 0. Il modello di stima correttamente consente di stimare l'elemento e gli altri elementi di tre test, troppo.

In questo articolo si presuppone che si dispone di intermedio o versioni successive delle competenze di programmazione, ma non che si conosce assolutamente KLR. Il programma demo è codificato tramite c#, ma è non necessario alcun problema di refactoring del codice in un altro linguaggio, ad esempio Java o Python, se si desidera. Il programma demo è troppo lungo per presentare nella sua interezza, ma il codice sorgente completo è disponibile nel download del file che accompagna questo articolo.

Il Kernel RBF

Una funzione kernel misura la somiglianza di due vettori o matrici. La funzione kernel RBF che già indicato in precedenza è più comune è il tipo utilizzato per il programma demo. Un valore RBF di 1,0 significa due vettori sono identici. I valori minori RBF indicano due vettori sono meno simili.

L'equazione per RBF è:

K (v1, v2) = exp (-| | v1, v2 | | ^ 2 / (2 * sigma ^ 2))

In questo caso, K è l'acronimo di kernel; V1 e v2 sono due vettori che hanno la stessa lunghezza. Sigma è un parametro con un valore come 1,0 o 1.5; il | | indica la distanza euclidea; e la funzione exp è il numero di Eulero (e = 2,71828) elevato a potenza.

La funzione RBF è meglio illustrata dall'esempio. Si supponga che v1 = (3.0, 1.0, 2.0) e v2 = (1.0, 0,0, 5.0), e sigma è 1,5. In primo luogo, si calcola la distanza euclidea quadratica:

|| V1, v2 | | ^ 2 (3.0 1.0) = ^ 2 + (1.0 - 0,0) ^ 2 + (2.0 5.0) ^ 2

                      = 4.0 + 1.0 + 9.0

                      = 14.0

Successivamente, si divide la distanza al quadrato per sigma 2 volte al quadrato:

14.0 / (2 * (1.5)^2) = 14.0 / 4.5 = 3.11

Infine, è possibile accettare un numero di Eulero e generarlo per il corrispondente negativo del risultato precedente:

K (v1, v2) = e^(-3.11) = 0.0446

Il valore di kernel piccolo indica che le versioni v1 e v2 non sono molto simili. Il programma demo definisce la funzione kernel RBF come:

static double Kernel(double[] v1, double[] v2,
  double sigma)
{
  double num = 0.0;
  for (int i = 0; i < v1.Length - 1; ++i)
    num += (v1[i] - v2[i]) * (v1[i] - v2[i]);
  double denom = 2.0 * sigma * sigma;
  double z = num / denom;
  return Math.Exp(-z);
}

La funzione presuppone che l'ultima cella di ogni matrice contiene l'etichetta di classe (0 o 1) e pertanto all'ultima cella non è incluso nel calcolo. KLR utilizza la funzione kernel per confrontare un elemento di dati specificato con tutti gli elementi di training e le informazioni vengono utilizzate per determinare un'etichetta di classe stimate.

Regressione logistica normale

La regressione logistica normale (LR) è meglio illustrata dall'esempio. Si supponga di avere tre variabili predittive: x0 = 2.5, x1 = 1.7 e x2 = 3.4. Un modello LR regolare crea un set di costanti numeriche chiamato pesi (elemento di lavoro), uno per ogni variabile predittiva e una costante numerica aggiuntiva chiamato distorsione (b). La differenza espressa in regolare LR non è lo stesso come la deviazione KLR illustrata nella figura 1

Demo di regressione logistica del kernel

Figura 1 Kernel regressione logistica Demo

Si supponga che /W0 = 0.11, w1 = 0,33, w2 = 0,22, b = 0,44. Per stimare l'etichetta di classe, 0 o 1, per i dati di input (2.5, 1.7, 3,4) di innanzitutto calcolare la somma dei prodotti per ogni x e il relativo w associato e aggiungere la distorsione:

z = (2.5)(0.11) (1.7)(0.33) (3.4)(0.22) + 0,44

   = 2.024

Successivamente, si calcola p = 1.0 / (1.0 + exp(-z)):

p = 1.0 / (1.0 + exp(-2.024))

   = 0.8833

Il valore di p è la probabilità che l'elemento di dati è l'etichetta di classe = 1, pertanto se p è minore di 0,5, la stima è 0 e se p è maggiore di 0,5 (come avviene in questo esempio), la stima è 1.

Nel caso in cui eseguire i pesi e i valori di compensazione di provengono da regolare LR? L'idea è determinare i pesi e i valori di compensazione utilizzando un set di dati che dispongono di valori di input e le etichette di classe corretto noto di training, quindi utilizzare un algoritmo di ottimizzazione di trovare i valori per i pesi e i pregiudizi in modo che la classe stimata etichette strettamente corrispondono ai valori di etichetta noti, corretto. Sono disponibili molti algoritmi che possono essere usati per individuare il peso e i valori di compensazione per regolare LR, tra cui ascent sfumatura con probabilità in forma logaritmica, valori descent con sfumatura con errore quadratico, iterato Newton Raphson, ottimizzazione simplex, L-BFGS e particella sciame ottimizzazione.

Lo svantaggio principale dei regolari LR è che può gestire solo i dati che sono separabili in modo lineare. Regolare LR non può gestire i dati non separabili in modo lineare, ad esempio i dati demo illustrati figura 2.

Dati di Training kernel regressione logistica

Figura 2 i dati di Training Kernel regressione logistica

Informazioni sulla regressione logistica del Kernel

KLR è meglio illustrato dall'esempio. Consenti stati in anticipo che a prima vista KLR non sembrano molto strettamente correlate a LR normale. Tuttavia, le due tecniche sono strettamente correlate matematicamente.

Si supponga che esistono solo quattro elementi di dati di training:

td [0] = (2.0, 4.0, 0)

td [1] = (4.0, 1.0, 1)

td [2] = (5.0, 3.0, 0)

td [3] = (6.0, 7.0, 1)

L'obiettivo consiste nello stimare l'etichetta di classe per x = (3.0, 5.0). Si supponga che il modello con training KLR ha fornito i valori alfa e una distorsione del: alfa [0] =-0.3, alpha [1] = 0,4, alpha [2] =-0.2, alpha [3] = 0,6, b = 0,1.

Il primo passaggio consiste nel calcolare la somiglianza RBF tra l'elemento di dati per la stima di tutti gli elementi training:

K (td [0], x) = 0.3679

K (td [1], x) = 0.0002

K (td [2], x) = 0.0183

K (td [3], x) = 0,0015

Si noti che a questo punto, x è più simile a td [0] e [2], td che dispone di etichetta di classe 0. Successivamente, calcolare la somma dei prodotti di ogni valore di K e valore alfa associato e aggiungere il valore della distorsione:

z = (0.3679)(-0.3) (0.0002)(0.4) (0.0183)(-0.2) + (0.0015)(0.6) + 0,1

   = -0.1120

Ora è calcolare p = 1.0 / (1.0 + exp(-z)):

p = 1.0 / (1.0 + exp(0.1120))

   = 0.4720

Se il valore di p è maggiore di 0,5 e la classe stimata è 1 se il valore di p è minore di 0,5, la classe stimata è 0, perché è (appena) per questo esempio.

Training di un modello KLR

Training di un modello KLR è il processo di utilizzo di dati di training per trovare i valori alfa e il valore della distorsione. Espressa in pseudocodice livello generale, l'algoritmo di training KLR è:

compute K(td[i], td[j]) for all i, j
loop maxIter times
  for-each curr training item, i
    for-each j: sum += alphas[j] * K(i j)
    sum += bias
    y = 1.0 / (1.0 + exp(-sum))
    t = target class (0 or 1)
    for-each j:
      alpha[j] += eta * (t - y) * K(i, j)
    bias += eta * (t - y) * 1.0
end-loop

L'istruzione chiave nel codice demo è greco + = alfa [j#] * (t - y) * kernelMatrix [i] [j#], che aggiorna il valore alfa per l'elemento di dati di training in corrispondenza dell'indice [j#] in base all'elemento di dati di training corrente in corrispondenza dell'indice [i]. In questo caso, t è la destinazione nota, corretta classe 0 o 1, e y è la probabilità calcolata che l'elemento in corrispondenza di [i] con la classe 1.

Ad esempio, si supponga che un valore alfa per un elemento di training è attualmente 0,1234 e destinazione classe 1 e alla probabilità calcolata 0.60. La stima corrente sarebbe corretta, ma si desidera che il valore di p sia ancora più vicina a 1. Si supponga che la somiglianza tra i due elementi sia K (i, j) = l'apprendimento e 0.70 greco frequenza è 0,10. Il nuovo valore alfa sarebbe:

Alpha = 0,1234 + 0,10 * (1 - 0.60) * 0.70

          = 0.1234 + 0.0280

          = 0.1514

Poiché alfa è un valore del moltiplicatore per il calcolo delle probabilità, il nuovo valore alfa leggermente superiore aumenterà p un po', una stima più accurata.

Il programma Demo

Per codificare il programma demo, avviato Visual Studio e creato un nuovo programma dell'applicazione di console in c# e denominato KernelLogistic. Si usa Visual Studio 2015, ma il programma demo non ha significative dipendenze di .NET Framework, pertanto funzionerà qualsiasi versione recente di Visual Studio.

Dopo che il codice del modello caricato nella finestra dell'editor, I pulsante destro del mouse sul file Program.cs nella finestra Esplora soluzioni, il file è stato rinominato KernelLogisticProgram.cs e quindi consentito Visual Studio rinominare automaticamente classe Program per me. Nella parte superiore del codice modello generato, è stato eliminato tutti non necessari tramite istruzioni lasciando solo quella che fa riferimento il livello superiore dello spazio dei nomi System. Quindi creata un'istanza di un oggetto casuale:

using System;
namespace KernelLogistic
{
  class KernelLogisticProgram
  {
    static Random rnd = new Random(0);
    static void Main(string[] args)
    {
      Console.WriteLine(“Begin KLR demo”);
      int numFeatures = 2;
...

Per semplicità, codificato demo utilizzando un approccio di metodo statico anziché orientata agli oggetti di programmazione e rimuovere tutti i normali errori. Il metodo Main imposta gli elementi di training 21 e gli elementi di 4 test nel modo seguente:

double[][] trainData = new double[21][];
trainData[0] = new double[] { 2.0, 3.0, 0 };
...
trainData[20] = new double[] { 5.0, 6.0, 1 };
double[][] testData = new double[4][];
testData[0] = new double[] { 1.5, 4.5, 0 };
...
testData[3] = new double[] { 5.5, 5.5, 1 };

In uno scenario non demo, è probabile che verrebbe leggere dati da un file di testo. Successivamente, vengono inizializzati i valori alfa:

int numTrain = trainData.Length;
int numTest = testData.Length;
double[] alphas = new double[numTrain + 1];
for (int i = 0; i < alphas.Length; ++i)
  alphas[i] = 0.0;

Quando si codifica sistemi di machine learning, esistono diversi modi per gestire i valori di compensazione. In questo caso, memorizzare la distorsione KLR nell'ultima cella della matrice alfa. Un progetto alternativo consiste nel creare una variabile autonomo. Successivamente, vengono calcolate le analogie kernel tra tutte le coppie di elementi di training:

double[][] kernelMatrix = new double[numTrain][];
for (int i = 0; i < kernelMatrix.Length; ++i)
  kernelMatrix[i] = new double[numTrain];
double sigma = 1.0;
for (int i = 0; i < numTrain; ++i) {
  for (int j = 0; j < numTrain; ++j) {
    double k = Kernel(trainData[i], trainData[j], sigma);
    kernelMatrix[i][j] = kernelMatrix[j][i] = k;
  }
}

Poiché sono presenti solo gli elementi di 21 dati, abbassano efficienza per motivi di semplicità. Potrebbe aver ridotto il numero di calcoli kernel mediante i fatti tale K (v1, v2) = K (v2, v1) e K (v, v) = 1. Successivamente, il programma demo viene preparata per il training:

double eta = 0.001;
int iter = 0;
int maxIter = 1000;
int[] indices = new int[numTrain];
for (int i = 0; i < indices.Length; ++i)
  indices[i] = i;

I valori di greco e maxIter sono determinati da prove ed errori. L'idea alla base della matrice denominata indici è che, durante il training, è importante visitare gli elementi di training in un ordine casuale a ogni passaggio, per evitare di trovarsi in una situazione in cui training si blocca o oscilla avanti e indietro. Inizia il ciclo di formazione principale:

while (iter < maxIter) {
  Shuffle(indices); 
  for (int idx = 0; idx < indices.Length; ++idx) {
    int i = indices[idx];

Il metodo casuale è un helper che l'ordine degli elementi di training utilizzando l'algoritmo di Fisher-YATES per minima codificata. L'etichetta di classe di destinazione e la probabilità stimata dell'elemento corrente di training vengono calcolate come segue:

double sum = 0.0;
for (int j = 0; j < alphas.Length-1; ++j)
  sum += alphas[j] * kernelMatrix[i][j];
sum += alphas[alphas.Length - 1]; 
double y = 1.0 / (1.0 + Math.Exp(-sum));
double t = trainData[i][numFeatures];

Si noti che questa soluzione si presuppone che l'etichetta di classe nell'ultima cella di una matrice di dati di training. Successivamente, vengono aggiornati l'alfa e i valori beta:

for (int j = 0; j < alphas.Length - 1; ++j)
      alphas[j] = alphas[j] +
        (eta * (t - y) * kernelMatrix[i][j]);
    alphas[alphas.Length-1] = alphas[alphas.Length - 1] +
      (eta * (t - y)) * 1; 
  }
  ++iter;
} // While (train)

Aggiornare il valore della distorsione utilizza un valore fittizio 1 al posto del valore di somiglianza del kernel, in modo da rendere la simmetria della relazione non crittografata. Naturalmente, è possibile rimuovere la moltiplicazione di 1, perché non ha alcun effetto. Dopo il training, alcuni dei valori dell'alfa e il valore della distorsione, vengono visualizzate, come illustrato figura 1.

Il programma demo conclude calcolando l'accuratezza della classificazione del modello con training KLR ai dati di training e test:

double accTrain = Accuracy(trainData, trainData,
  alphas, sigma, false);
Console.WriteLine(“accuracy = “ +
  accTrain.ToString(“F4”) + “\n”);
double accTest = Accuracy(testData, trainData,
  alphas, sigma, true); // Verbose

L'argomento booleano passato al metodo accuratezza indica se calcolare in modalità dettagliata (con messaggi di diagnostica) o in modalità invisibile all'utente.

Conclusioni

La regressione logistica kernel non verrà usata molto spesso, almeno tra colleghi. Il vantaggio principale è la semplicità. Lo svantaggio principale di KLR è che non supporta la scalabilità per grandi set di dati perché è necessario Pre-calcola tutti i valori di somiglianza del kernel di elemento per elemento e li salvano oppure è necessario mantenere tutti i dati di training e per calcolare tutti i valori di somiglianza in tempo reale per ogni stima.

KLR è progettato per la classificazione binaria. È possibile estendere KLR per gestire i problemi di classificazione con tre o più valori di classe, ma in Me, sono disponibili alternative migliori da utilizzare, in particolare un singolo livello nascosto feedforward rete neurale. KLR presenta alcune analogie con KB più vicino di algoritmo di classificazione router adiacenti (K-NN), nonché per supportare la classificazione di vettore macchina (SVM).


Ripristino di emergenza. James McCaffrey* funziona per Microsoft Research Redmond, WA Ha lavorato su diversi prodotti Microsoft, tra cui Internet Explorer e Bing. Dr. McCaffrey può essere raggiunto al jamccaff@microsoft.com.*

Grazie per i seguenti esperti Microsoft che ha revisionato in questo articolo: Chris Lee e Adith Swaminathan


Viene illustrato in questo articolo nel forum di MSDN Magazine