CNTK - Modello di regressione logistica
Questo capitolo tratta della costruzione di un modello di regressione logistica in CNTK.
Nozioni di base sul modello di regressione logistica
La regressione logistica, una delle tecniche ML più semplici, è una tecnica specifica per la classificazione binaria. In altre parole, per creare un modello di previsione in situazioni in cui il valore della variabile da prevedere può essere uno dei due soli valori categoriali. Uno degli esempi più semplici di regressione logistica è prevedere se la persona è maschio o femmina, in base all'età, alla voce, ai capelli e così via della persona.
Esempio
Comprendiamo matematicamente il concetto di regressione logistica con l'aiuto di un altro esempio:
Supponiamo di voler prevedere l'affidabilità creditizia di una richiesta di prestito; 0 significa rifiutare e 1 significa approvare, in base al richiedentedebt , income e credit rating. Rappresentiamo debito con X1, reddito con X2 e rating del credito con X3.
In Regressione logistica, determiniamo un valore di peso, rappresentato da w, per ogni caratteristica e un singolo valore di polarizzazione, rappresentato da b.
Ora supponiamo,
X1 = 3.0
X2 = -2.0
X3 = 1.0E supponiamo di determinare il peso e il bias come segue:
W1 = 0.65, W2 = 1.75, W3 = 2.05 and b = 0.33Ora, per prevedere la classe, dobbiamo applicare la seguente formula:
Z = (X1*W1)+(X2*W2)+(X3+W3)+b
i.e. Z = (3.0)*(0.65) + (-2.0)*(1.75) + (1.0)*(2.05) + 0.33
= 0.83Successivamente, dobbiamo calcolare P = 1.0/(1.0 + exp(-Z)). Qui, la funzione exp () è il numero di Eulero.
P = 1.0/(1.0 + exp(-0.83)
= 0.6963Il valore P può essere interpretato come la probabilità che la classe sia 1. Se P <0,5, la previsione è classe = 0 altrimenti la previsione (P> = 0,5) è classe = 1.
Per determinare i valori di peso e bias, dobbiamo ottenere una serie di dati di addestramento con i valori predittori di input noti e i valori delle etichette di classe corretti noti. Successivamente, possiamo usare un algoritmo, generalmente Gradient Descent, per trovare i valori di peso e bias.
Esempio di implementazione del modello LR
Per questo modello LR, utilizzeremo il seguente set di dati:
1.0, 2.0, 0
3.0, 4.0, 0
5.0, 2.0, 0
6.0, 3.0, 0
8.0, 1.0, 0
9.0, 2.0, 0
1.0, 4.0, 1
2.0, 5.0, 1
4.0, 6.0, 1
6.0, 5.0, 1
7.0, 3.0, 1
8.0, 5.0, 1Per avviare l'implementazione del modello LR in CNTK, dobbiamo prima importare i seguenti pacchetti:
import numpy as np
import cntk as CIl programma è strutturato con la funzione main () come segue:
def main():
print("Using CNTK version = " + str(C.__version__) + "\n")Ora, dobbiamo caricare i dati di allenamento in memoria come segue:
data_file = ".\\dataLRmodel.txt"
print("Loading data from " + data_file + "\n")
features_mat = np.loadtxt(data_file, dtype=np.float32, delimiter=",", skiprows=0, usecols=[0,1])
labels_mat = np.loadtxt(data_file, dtype=np.float32, delimiter=",", skiprows=0, usecols=[2], ndmin=2)Ora creeremo un programma di addestramento che crei un modello di regressione logistica compatibile con i dati di addestramento -
features_dim = 2
labels_dim = 1
X = C.ops.input_variable(features_dim, np.float32)
y = C.input_variable(labels_dim, np.float32)
W = C.parameter(shape=(features_dim, 1)) # trainable cntk.Parameter
b = C.parameter(shape=(labels_dim))
z = C.times(X, W) + b
p = 1.0 / (1.0 + C.exp(-z))
model = pOra, dobbiamo creare Lerner e il trainer come segue:
ce_error = C.binary_cross_entropy(model, y) # CE a bit more principled for LR
fixed_lr = 0.010
learner = C.sgd(model.parameters, fixed_lr)
trainer = C.Trainer(model, (ce_error), [learner])
max_iterations = 4000Formazione modello LR
Dopo aver creato il modello LR, è ora di iniziare il processo di formazione:
np.random.seed(4)
N = len(features_mat)
for i in range(0, max_iterations):
row = np.random.choice(N,1) # pick a random row from training items
trainer.train_minibatch({ X: features_mat[row], y: labels_mat[row] })
if i % 1000 == 0 and i > 0:
mcee = trainer.previous_minibatch_loss_average
print(str(i) + " Cross-entropy error on curr item = %0.4f " % mcee)Ora, con l'aiuto del codice seguente, possiamo stampare i pesi e il bias del modello:
np.set_printoptions(precision=4, suppress=True)
print("Model weights: ")
print(W.value)
print("Model bias:")
print(b.value)
print("")
if __name__ == "__main__":
main()Addestramento di un modello di regressione logistica - Esempio completo
import numpy as np
import cntk as C
def main():
print("Using CNTK version = " + str(C.__version__) + "\n")
data_file = ".\\dataLRmodel.txt" # provide the name and the location of data file
print("Loading data from " + data_file + "\n")
features_mat = np.loadtxt(data_file, dtype=np.float32, delimiter=",", skiprows=0, usecols=[0,1])
labels_mat = np.loadtxt(data_file, dtype=np.float32, delimiter=",", skiprows=0, usecols=[2], ndmin=2)
features_dim = 2
labels_dim = 1
X = C.ops.input_variable(features_dim, np.float32)
y = C.input_variable(labels_dim, np.float32)
W = C.parameter(shape=(features_dim, 1)) # trainable cntk.Parameter
b = C.parameter(shape=(labels_dim))
z = C.times(X, W) + b
p = 1.0 / (1.0 + C.exp(-z))
model = p
ce_error = C.binary_cross_entropy(model, y) # CE a bit more principled for LR
fixed_lr = 0.010
learner = C.sgd(model.parameters, fixed_lr)
trainer = C.Trainer(model, (ce_error), [learner])
max_iterations = 4000
np.random.seed(4)
N = len(features_mat)
for i in range(0, max_iterations):
row = np.random.choice(N,1) # pick a random row from training items
trainer.train_minibatch({ X: features_mat[row], y: labels_mat[row] })
if i % 1000 == 0 and i > 0:
mcee = trainer.previous_minibatch_loss_average
print(str(i) + " Cross-entropy error on curr item = %0.4f " % mcee)
np.set_printoptions(precision=4, suppress=True)
print("Model weights: ")
print(W.value)
print("Model bias:")
print(b.value)
if __name__ == "__main__":
main()Produzione
Using CNTK version = 2.7
1000 cross entropy error on curr item = 0.1941
2000 cross entropy error on curr item = 0.1746
3000 cross entropy error on curr item = 0.0563
Model weights:
[-0.2049]
[0.9666]]
Model bias:
[-2.2846]Previsione utilizzando il modello LR addestrato
Una volta che il modello LR è stato addestrato, possiamo usarlo per la previsione come segue:
Prima di tutto, il nostro programma di valutazione importa il pacchetto numpy e carica i dati di addestramento in una matrice di caratteristiche e una matrice di etichette di classe nello stesso modo del programma di addestramento che implementiamo sopra -
import numpy as np
def main():
data_file = ".\\dataLRmodel.txt" # provide the name and the location of data file
features_mat = np.loadtxt(data_file, dtype=np.float32, delimiter=",",
skiprows=0, usecols=(0,1))
labels_mat = np.loadtxt(data_file, dtype=np.float32, delimiter=",",
skiprows=0, usecols=[2], ndmin=2)Successivamente, è il momento di impostare i valori dei pesi e il bias che sono stati determinati dal nostro programma di allenamento -
print("Setting weights and bias values \n")
weights = np.array([0.0925, 1.1722], dtype=np.float32)
bias = np.array([-4.5400], dtype=np.float32)
N = len(features_mat)
features_dim = 2Successivamente il nostro programma di valutazione calcolerà la probabilità di regressione logistica esaminando ogni elemento di formazione come segue:
print("item pred_prob pred_label act_label result")
for i in range(0, N): # each item
x = features_mat[i]
z = 0.0
for j in range(0, features_dim):
z += x[j] * weights[j]
z += bias[0]
pred_prob = 1.0 / (1.0 + np.exp(-z))
pred_label = 0 if pred_prob < 0.5 else 1
act_label = labels_mat[i]
pred_str = ‘correct’ if np.absolute(pred_label - act_label) < 1.0e-5 \
else ‘WRONG’
print("%2d %0.4f %0.0f %0.0f %s" % \ (i, pred_prob, pred_label, act_label, pred_str))Ora dimostriamo come eseguire la previsione -
x = np.array([9.5, 4.5], dtype=np.float32)
print("\nPredicting class for age, education = ")
print(x)
z = 0.0
for j in range(0, features_dim):
z += x[j] * weights[j]
z += bias[0]
p = 1.0 / (1.0 + np.exp(-z))
print("Predicted p = " + str(p))
if p < 0.5: print("Predicted class = 0")
else: print("Predicted class = 1")Programma completo di valutazione delle previsioni
import numpy as np
def main():
data_file = ".\\dataLRmodel.txt" # provide the name and the location of data file
features_mat = np.loadtxt(data_file, dtype=np.float32, delimiter=",",
skiprows=0, usecols=(0,1))
labels_mat = np.loadtxt(data_file, dtype=np.float32, delimiter=",",
skiprows=0, usecols=[2], ndmin=2)
print("Setting weights and bias values \n")
weights = np.array([0.0925, 1.1722], dtype=np.float32)
bias = np.array([-4.5400], dtype=np.float32)
N = len(features_mat)
features_dim = 2
print("item pred_prob pred_label act_label result")
for i in range(0, N): # each item
x = features_mat[i]
z = 0.0
for j in range(0, features_dim):
z += x[j] * weights[j]
z += bias[0]
pred_prob = 1.0 / (1.0 + np.exp(-z))
pred_label = 0 if pred_prob < 0.5 else 1
act_label = labels_mat[i]
pred_str = ‘correct’ if np.absolute(pred_label - act_label) < 1.0e-5 \
else ‘WRONG’
print("%2d %0.4f %0.0f %0.0f %s" % \ (i, pred_prob, pred_label, act_label, pred_str))
x = np.array([9.5, 4.5], dtype=np.float32)
print("\nPredicting class for age, education = ")
print(x)
z = 0.0
for j in range(0, features_dim):
z += x[j] * weights[j]
z += bias[0]
p = 1.0 / (1.0 + np.exp(-z))
print("Predicted p = " + str(p))
if p < 0.5: print("Predicted class = 0")
else: print("Predicted class = 1")
if __name__ == "__main__":
main()Produzione
Impostazione di pesi e valori di bias.
Item pred_prob pred_label act_label result
0 0.3640 0 0 correct
1 0.7254 1 0 WRONG
2 0.2019 0 0 correct
3 0.3562 0 0 correct
4 0.0493 0 0 correct
5 0.1005 0 0 correct
6 0.7892 1 1 correct
7 0.8564 1 1 correct
8 0.9654 1 1 correct
9 0.7587 1 1 correct
10 0.3040 0 1 WRONG
11 0.7129 1 1 correct
Predicting class for age, education =
[9.5 4.5]
Predicting p = 0.526487952
Predicting class = 1