二进制神经网络_CNTK-神经网络二进制分类

水深无声 2022-12-10 01:27 227阅读 0赞

![二进制 神经网络][f8bcc1e41b70e29637b93ccd93406d2c.png]

二进制 神经网络

# CNTK-神经网络二进制分类 **(**CNTK - Neural Network Binary Classification**)** #

Let us understand, what is neural network binary classification using CNTK, in this chapter.

在本章中，让我们了解什么是使用CNTK的神经网络二进制分类。

Binary classification using NN is like multi-class classification, the only thing is that there are just two output nodes instead of three or more. Here, we are going to perform binary classification using a neural network by using two techniques namely one-node and two-node technique. One-node technique is more common than two-node technique.

使用NN的二进制分类就像多类分类，唯一的事情是只有两个输出节点，而不是三个或更多。 在这里，我们将通过使用两种技术，即一节点和两节点技术，使用神经网络执行二进制分类。 单节点技术比两节点技术更为普遍。

## 加载数据集 **(**Loading Dataset**)** ##

For both these techniques to implement using NN, we will be using banknote dataset. The dataset can be downloaded from UCI Machine Learning Repository which is available at [https://archive.ics.uci.edu/ml/datasets/banknote+authentication.][https_archive.ics.uci.edu_ml_datasets_banknote_authentication.]

对于这两种使用NN实现的技术，我们将使用钞票数据集。 该数据集可以从UCI机器学习存储库中下载，该存储库可从[https://archive.ics.uci.edu/ml/datasets/banknote+authentication获得。][https_archive.ics.uci.edu_ml_datasets_banknote_authentication.]

For our example, we will be using 50 authentic data items having class forgery = 0, and the first 50 fake items having class forgery = 1.

对于我们的示例，我们将使用50个伪造类别为0的真实数据项，以及前50个伪造类别为1的假数据项。

## 准备培训和测试文件 **(**Preparing training & test files**)** ##

There are 1372 data items in the full dataset. The raw dataset looks as follows −

完整数据集中有1372个数据项。 原始数据集如下所示-

3.6216, 8.6661, -2.8076, -0.44699, 0
    4.5459, 8.1674, -2.4586, -1.4621, 0
    …
    -1.3971, 3.3191, -1.3927, -1.9948, 1
    0.39012, -0.14279, -0.031994, 0.35084, 1

Now, first we need to convert this raw data into two-node CNTK format, which would be as follows −

现在，首先我们需要将该原始数据转换为两节点的CNTK格式，如下所示-

You can use the following python program to create CNTK-format data from Raw data −

您可以使用以下python程序从Raw数据创建CNTK格式的数据-

fin = open(".\\...", "r") #provide the location of saved dataset text file.
    for line in fin:
       line = line.strip()
       tokens = line.split(",")
       if tokens[4] == "0":
        print("|stats %12.8f %12.8f %12.8f %12.8f |forgery 0 1 |# authentic" % \
    (float(tokens[0]), float(tokens[1]), float(tokens[2]), float(tokens[3])) )
       else:
        print("|stats %12.8f %12.8f %12.8f %12.8f |forgery 1 0 |# fake" % \
    (float(tokens[0]), float(tokens[1]), float(tokens[2]), float(tokens[3])) )
    fin.close()

## 两节点二进制分类模型 **(**Two-node binary Classification model**)** ##

There is very little difference between two-node classification and multi-class classification. Here we first, need to process the data files in CNTK format and for that we are going to use the helper function named **create\_reader** as follows −

两节点分类和多分类之间几乎没有什么区别。 在这里，我们首先需要处理CNTK格式的数据文件，为此，我们将使用名为**create\_reader**的帮助器函数，如下所示-

Now, we need to set the architecture arguments for our NN and also provide the location of the data files. It can be done with the help of following python code −

现在，我们需要为NN设置架构参数，并提供数据文件的位置。 可以在以下python代码的帮助下完成-

def main():
    print("Using CNTK version = " + str(C.__version__) + "\n")
    input_dim = 4
    hidden_dim = 10
    output_dim = 2
    train_file = ".\\...\\" #provide the name of the training file
    test_file = ".\\...\\" #provide the name of the test file

Now, with the help of following code line our program will create the untrained NN −

现在，在以下代码行的帮助下，我们的程序将创建未经训练的NN-

X = C.ops.input_variable(input_dim, np.float32)
    Y = C.ops.input_variable(output_dim, np.float32)
    with C.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
    hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
    oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
    nnet = oLayer
    model = C.ops.softmax(nnet)

Now, once we created the dual untrained model, we need to set up a Learner algorithm object and afterwards use it to create a Trainer training object. We are going to use SGD learner and cross\_entropy\_with\_softmax loss function −

现在，一旦我们创建了双重未经训练的模型，就需要建立一个Learner算法对象，然后使用它来创建一个Trainer训练对象。 我们将使用SGD学习器和cross\_entropy\_with\_softmax损失函数-

tr_loss = C.cross_entropy_with_softmax(nnet, Y)
    tr_clas = C.classification_error(nnet, Y)
    max_iter = 500
    batch_size = 10
    learn_rate = 0.01
    learner = C.sgd(nnet.parameters, learn_rate)
    trainer = C.Trainer(nnet, (tr_loss, tr_clas), [learner])

Now, once we finished with Trainer object, we need to create a reader function to read the training data −

现在，一旦完成了Trainer对象，我们需要创建一个reader函数来读取训练数据-

rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
    banknote_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }

Now, it is time to train our NN model −

现在是时候训练我们的NN模型了-

for i in range(0, max_iter):
    curr_batch = rdr.next_minibatch(batch_size, input_map=iris_input_map) trainer.train_minibatch(curr_batch)
    if i % 500 == 0:
    mcee = trainer.previous_minibatch_loss_average
    macc = (1.0 - trainer.previous_minibatch_evaluation_average) * 100
    print("batch %4d: mean loss = %0.4f, accuracy = %0.2f%% " \ % (i, mcee, macc))

Once training is completed, let us evaluate the model using test data items −

训练完成后，让我们使用测试数据项评估模型-

print("\nEvaluating test data \n")
    rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
    banknote_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
    num_test = 20
    all_test = rdr.next_minibatch(num_test, input_map=iris_input_map) acc = (1.0 - trainer.test_minibatch(all_test)) * 100
    print("Classification accuracy = %0.2f%%" % acc)

After evaluating the accuracy of our trained NN model, we will be using it for making a prediction on unseen data −

在评估了训练有素的NN模型的准确性之后，我们将使用它来对看不见的数据进行预测-

np.set_printoptions(precision = 1, suppress=True)
    unknown = np.array([[0.6, 1.9, -3.3, -0.3]], dtype=np.float32)
    print("\nPredicting Banknote authenticity for input features: ")
    print(unknown[0])
    pred_prob = model.eval(unknown)
    np.set_printoptions(precision = 4, suppress=True)
    print("Prediction probabilities are: ")
    print(pred_prob[0])
    if pred_prob[0,0] < pred_prob[0,1]:
      print(“Prediction: authentic”)
    else:
      print(“Prediction: fake”)

### 完整的两节点分类模型 **(**Complete Two-node Classification Model**)** ###

def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
    x_strm = C.io.StreamDef(field='stats', shape=input_dim, is_sparse=False)
    y_strm = C.io.StreamDef(field='forgery', shape=output_dim, is_sparse=False)
    streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
    deserial = C.io.CTFDeserializer(path, streams)
    mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
    return mb_src
    def main():
    print("Using CNTK version = " + str(C.__version__) + "\n")
    input_dim = 4
    hidden_dim = 10
    output_dim = 2
    train_file = ".\\...\\" #provide the name of the training file
    test_file = ".\\...\\" #provide the name of the test file
    X = C.ops.input_variable(input_dim, np.float32)
    Y = C.ops.input_variable(output_dim, np.float32)
    withC.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
    hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
    oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
    nnet = oLayer
    model = C.ops.softmax(nnet)
    tr_loss = C.cross_entropy_with_softmax(nnet, Y)
    tr_clas = C.classification_error(nnet, Y)
    max_iter = 500
    batch_size = 10
    learn_rate = 0.01
    learner = C.sgd(nnet.parameters, learn_rate)
    trainer = C.Trainer(nnet, (tr_loss, tr_clas), [learner])
    rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
    banknote_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
    for i in range(0, max_iter):
    curr_batch = rdr.next_minibatch(batch_size, input_map=iris_input_map) trainer.train_minibatch(curr_batch)
    if i % 500 == 0:
    mcee = trainer.previous_minibatch_loss_average
    macc = (1.0 - trainer.previous_minibatch_evaluation_average) * 100
    print("batch %4d: mean loss = %0.4f, accuracy = %0.2f%% " \ % (i, mcee, macc))
    print("\nEvaluating test data \n")
    rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
    banknote_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
    num_test = 20
    all_test = rdr.next_minibatch(num_test, input_map=iris_input_map) acc = (1.0 - trainer.test_minibatch(all_test)) * 100
    print("Classification accuracy = %0.2f%%" % acc)
    np.set_printoptions(precision = 1, suppress=True)
    unknown = np.array([[0.6, 1.9, -3.3, -0.3]], dtype=np.float32)
    print("\nPredicting Banknote authenticity for input features: ")
    print(unknown[0])
    pred_prob = model.eval(unknown)
    np.set_printoptions(precision = 4, suppress=True)
    print("Prediction probabilities are: ")
    print(pred_prob[0])
    if pred_prob[0,0] < pred_prob[0,1]:
    print(“Prediction: authentic”)
    else:
    print(“Prediction: fake”)
    if __name__== ”__main__”:
    main()

### 输出量 **(**Output**)** ###

Using CNTK version = 2.7
    batch 0: mean loss = 0.6928, accuracy = 80.00%
    batch 50: mean loss = 0.6877, accuracy = 70.00%
    batch 100: mean loss = 0.6432, accuracy = 80.00%
    batch 150: mean loss = 0.4978, accuracy = 80.00%
    batch 200: mean loss = 0.4551, accuracy = 90.00%
    batch 250: mean loss = 0.3755, accuracy = 90.00%
    batch 300: mean loss = 0.2295, accuracy = 100.00%
    batch 350: mean loss = 0.1542, accuracy = 100.00%
    batch 400: mean loss = 0.1581, accuracy = 100.00%
    batch 450: mean loss = 0.1499, accuracy = 100.00%
    Evaluating test data
    Classification accuracy = 84.58%
    Predicting banknote authenticity for input features:
    [0.6 1.9 -3.3 -0.3]
    Prediction probabilities are:
    [0.7847 0.2536]
    Prediction: fake

## 一节点二进制分类模型 **(**One-node binary Classification model**)** ##

The implementation program is almost like we have done above for two-node classification. The main change is that when using the two-node classification technique.

实现程序几乎就像我们上面为两节点分类所做的那样。 主要的变化是使用两节点分类技术时。

We can use the CNTK built-in classification\_error() function, but in case of one-node classification CNTK doesn’t support classification\_error() function. That’s the reason we need to implement a program-defined function as follows −

我们可以使用CNTK内置的category\_error()函数，但是在单节点分类的情况下，CNTK不支持classification\_error()函数。 这就是我们需要实现如下程序定义函数的原因-

def class_acc(mb, x_var, y_var, model):
    num_correct = 0; num_wrong = 0
    x_mat = mb[x_var].asarray()
    y_mat = mb[y_var].asarray()
    for i in range(mb[x_var].shape[0]):
       p = model.eval(x_mat[i]
       y = y_mat[i]
       if p[0,0] < 0.5 and y[0,0] == 0.0 or p[0,0] >= 0.5 and y[0,0] == 1.0:
    num_correct += 1
     else:
      num_wrong += 1
    return (num_correct * 100.0)/(num_correct + num_wrong)

With that change let’s see the complete one-node classification example −

有了这一更改，让我们看完整的一节点分类示例-

### 完整的一节点分类模型 **(**Complete one-node Classification Model**)** ###

import numpy as np
    import cntk as C
    def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
    x_strm = C.io.StreamDef(field='stats', shape=input_dim, is_sparse=False)
    y_strm = C.io.StreamDef(field='forgery', shape=output_dim, is_sparse=False)
    streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
    deserial = C.io.CTFDeserializer(path, streams)
    mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
    return mb_src
    def class_acc(mb, x_var, y_var, model):
    num_correct = 0; num_wrong = 0
    x_mat = mb[x_var].asarray()
    y_mat = mb[y_var].asarray()
    for i in range(mb[x_var].shape[0]):
      p = model.eval(x_mat[i]
      y = y_mat[i]
      if p[0,0] < 0.5 and y[0,0] == 0.0 or p[0,0] >= 0.5 and y[0,0] == 1.0:
      num_correct += 1
     else:
      num_wrong += 1
    return (num_correct * 100.0)/(num_correct + num_wrong)
    def main():
    print("Using CNTK version = " + str(C.__version__) + "\n")
    input_dim = 4
    hidden_dim = 10
    output_dim = 1
    train_file = ".\\...\\" #provide the name of the training file
    test_file = ".\\...\\" #provide the name of the test file
    X = C.ops.input_variable(input_dim, np.float32)
    Y = C.ops.input_variable(output_dim, np.float32)
    with C.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
    hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
    oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
    model = oLayer
    tr_loss = C.cross_entropy_with_softmax(model, Y)
    max_iter = 1000
    batch_size = 10
    learn_rate = 0.01
    learner = C.sgd(model.parameters, learn_rate)
    trainer = C.Trainer(model, (tr_loss), [learner])
    rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
    banknote_input_map = {X : rdr.streams.x_src, Y : rdr.streams.y_src }
    for i in range(0, max_iter):
    curr_batch = rdr.next_minibatch(batch_size, input_map=iris_input_map) trainer.train_minibatch(curr_batch)
    if i % 100 == 0:
    mcee=trainer.previous_minibatch_loss_average
    ca = class_acc(curr_batch, X,Y, model)
    print("batch %4d: mean loss = %0.4f, accuracy = %0.2f%% " \ % (i, mcee, ca))
    print("\nEvaluating test data \n")
    rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
    banknote_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
    num_test = 20
    all_test = rdr.next_minibatch(num_test, input_map=iris_input_map)
    acc = class_acc(all_test, X,Y, model)
    print("Classification accuracy = %0.2f%%" % acc)
    np.set_printoptions(precision = 1, suppress=True)
    unknown = np.array([[0.6, 1.9, -3.3, -0.3]], dtype=np.float32)
    print("\nPredicting Banknote authenticity for input features: ")
    print(unknown[0])
    pred_prob = model.eval({X:unknown})
    print("Prediction probability: ")
    print(“%0.4f” % pred_prob[0,0])
    if pred_prob[0,0] < 0.5:
      print(“Prediction: authentic”)
    else:
      print(“Prediction: fake”)
    if __name__== ”__main__”:
       main()

### 输出量 **(**Output**)** ###

Using CNTK version = 2.7
    batch 0: mean loss = 0.6936, accuracy = 10.00%
    batch 100: mean loss = 0.6882, accuracy = 70.00%
    batch 200: mean loss = 0.6597, accuracy = 50.00%
    batch 300: mean loss = 0.5298, accuracy = 70.00%
    batch 400: mean loss = 0.4090, accuracy = 100.00%
    batch 500: mean loss = 0.3790, accuracy = 90.00%
    batch 600: mean loss = 0.1852, accuracy = 100.00%
    batch 700: mean loss = 0.1135, accuracy = 100.00%
    batch 800: mean loss = 0.1285, accuracy = 100.00%
    batch 900: mean loss = 0.1054, accuracy = 100.00%
    Evaluating test data
    Classification accuracy = 84.00%
    Predicting banknote authenticity for input features:
    [0.6 1.9 -3.3 -0.3]
    Prediction probability:
    0.8846
    Prediction: fake

> 翻译自: [https://www.tutorialspoint.com/microsoft\_cognitive\_toolkit/microsoft\_cognitive\_toolkit\_neural\_network\_binary\_classification.htm][https_www.tutorialspoint.com_microsoft_cognitive_toolkit_microsoft_cognitive_toolkit_neural_network_binary_classification.htm]

二进制 神经网络

[f8bcc1e41b70e29637b93ccd93406d2c.png]: /images/20221123/1452f0bed0a040d0a554130d1be85b5e.png
[https_archive.ics.uci.edu_ml_datasets_banknote_authentication.]: https://archive.ics.uci.edu/ml/datasets/banknote+authentication
[https_www.tutorialspoint.com_microsoft_cognitive_toolkit_microsoft_cognitive_toolkit_neural_network_binary_classification.htm]: https://www.tutorialspoint.com/microsoft_cognitive_toolkit/microsoft_cognitive_toolkit_neural_network_binary_classification.htm