CNTK - लॉजिस्टिक रिग्रेशन मॉडल

यह अध्याय CNTK में एक लॉजिस्टिक रिग्रेशन मॉडल के निर्माण से संबंधित है।

लॉजिस्टिक रिग्रेशन मॉडल की मूल बातें

लॉजिस्टिक रिग्रेशन, सबसे सरल एमएल तकनीकों में से एक, विशेष रूप से बाइनरी वर्गीकरण के लिए एक तकनीक है। दूसरे शब्दों में, उन स्थितियों में एक भविष्यवाणी मॉडल बनाना जहां भविष्यवाणी करने के लिए चर का मूल्य सिर्फ दो स्पष्ट मूल्यों में से एक हो सकता है। लॉजिस्टिक रिग्रेशन का सबसे सरल उदाहरण यह अनुमान लगाना है कि व्यक्ति पुरुष या महिला है, जो व्यक्ति की उम्र, आवाज, बालों और इसी तरह के आधार पर है।

उदाहरण

आइए एक और उदाहरण की मदद से गणितीय रूप से लॉजिस्टिक रिग्रेशन की अवधारणा को समझते हैं -

मान लीजिए, हम एक ऋण आवेदन की क्रेडिट योग्यता की भविष्यवाणी करना चाहते हैं; आवेदक के आधार पर 0 का अर्थ है अस्वीकार, और 1 का अर्थ है अनुमोदनdebt , income तथा credit rating। हम एक्स 1 के साथ ऋण, एक्स 2 के साथ आय और एक्स 3 के साथ क्रेडिट रेटिंग का प्रतिनिधित्व करते हैं।

लॉजिस्टिक रिग्रेशन में, हम एक वेट वैल्यू निर्धारित करते हैं, जिसका प्रतिनिधित्व करते हैं wप्रत्येक सुविधा के लिए और एक एकल पूर्वाग्रह मूल्य, द्वारा प्रस्तुत किया गया b।

अब मान लीजिए,

X1 = 3.0
X2 = -2.0
X3 = 1.0

और मान लें कि हम वजन और पूर्वाग्रह निर्धारित करते हैं -

W1 = 0.65, W2 = 1.75, W3 = 2.05 and b = 0.33

अब, कक्षा की भविष्यवाणी करने के लिए, हमें निम्नलिखित सूत्र को लागू करने की आवश्यकता है -

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.83

अगला, हमें गणना करने की आवश्यकता है P = 1.0/(1.0 + exp(-Z))। यहां, एक्सप () फ़ंक्शन यूलर का नंबर है।

P = 1.0/(1.0 + exp(-0.83)
= 0.6963

P मान की व्याख्या इस संभावना के रूप में की जा सकती है कि वर्ग १ है। यदि P <०.५, पूर्वानुमान वर्ग है = ० अन्य की भविष्यवाणी (P> = ०.५) वर्ग = १ है।

वजन और पूर्वाग्रह के मूल्यों का निर्धारण करने के लिए, हमें ज्ञात इनपुट भविष्यवक्ता मूल्यों और ज्ञात सही वर्ग लेबल मूल्यों वाले प्रशिक्षण डेटा का एक सेट प्राप्त करना होगा। उसके बाद, हम एक एल्गोरिथ्म का उपयोग कर सकते हैं, आमतौर पर ग्रेडिएंट डिसेंट, वजन और पूर्वाग्रह के मूल्यों को खोजने के लिए।

LR मॉडल कार्यान्वयन उदाहरण

इस LR मॉडल के लिए, हम निम्नलिखित डेटा सेट का उपयोग करने जा रहे हैं -

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, 1

CNTK में इस LR मॉडल कार्यान्वयन को शुरू करने के लिए, हमें पहले निम्नलिखित पैकेजों को आयात करना होगा -

import numpy as np
import cntk as C

कार्यक्रम मुख्य () फ़ंक्शन के साथ संरचित है -

def main():
print("Using CNTK version = " + str(C.__version__) + "\n")

अब, हमें प्रशिक्षण डेटा को मेमोरी में लोड करने की आवश्यकता है -

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)

अब, हम एक प्रशिक्षण कार्यक्रम बनाएंगे जो लॉजिस्टिक रिग्रेशन मॉडल बनाएगा जो प्रशिक्षण डेटा के साथ संगत है -

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

अब, हमें Lerner और ट्रेनर बनाने की आवश्यकता इस प्रकार है -

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

LR मॉडल प्रशिक्षण

एक बार, हमने LR मॉडल बनाया है, अगला, प्रशिक्षण प्रक्रिया शुरू करने का समय है -

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)
print("")
if __name__ == "__main__":
main()

लॉजिस्टिक रिग्रेशन मॉडल का प्रशिक्षण - पूरा उदाहरण

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()

उत्पादन

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]

प्रशिक्षित LR मॉडल का उपयोग कर भविष्यवाणी

एक बार जब एलआर मॉडल को प्रशिक्षित किया गया है, तो हम इसे निम्नानुसार भविष्यवाणी के लिए उपयोग कर सकते हैं -

सबसे पहले, हमारा मूल्यांकन कार्यक्रम खस्ता पैकेज को आयात करता है और प्रशिक्षण डेटा को एक फीचर मैट्रिक्स और एक क्लास लेबल मैट्रिक्स में उसी तरह लोड करता है जिस तरह से प्रशिक्षण कार्यक्रम हम ऊपर लागू करते हैं -

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")

पूर्ण मूल्यांकन मूल्यांकन कार्यक्रम

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()

उत्पादन

वजन और पूर्वाग्रह मान सेट करना।

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