Page 30 - MSDN Magazine, July 2017

Figure 4 Complete Demo Program
# iris_demo.py
# Anaconda 4.1.1 (Python 3.5, NumPy 1.11.1) # CNTK 2.0 RC1
# Use a one-hidden layer simple NN with 2 hidden nodes # to classify the Iris Dataset.
# This version uses the built-in Reader functions and # data files that use the CTF format.
# trainData_cntk.txt - 120 items (40 each class) # testData_cntk.txt - remaining 30 items
import numpy as np
import cntk as C
from cntk import Trainer # to train the NN
from cntk.learners import sgd, learning_rate_schedule, \\
UnitType
from cntk.ops import * # input_variable() def
from cntk.logging import ProgressPrinter
from cntk.initializer import glorot_uniform
from cntk.layers import default_options, Dense
from cntk.io import CTFDeserializer, MinibatchSource, \\
StreamDef, StreamDefs, INFINITELY_REPEAT # =====
def my_print(arr, dec):
# print an array of float/double with dec decimals fmt = "%." + str(dec) + "f" # like %.4f
for i in range(0, len(arr)):
print(fmt % arr[i] + ' ', end='') print("\
")
def create_reader(path, is_training, input_dim, output_dim): return MinibatchSource(CTFDeserializer(path, StreamDefs( features = StreamDef(field='attribs', shape=input_dim,
is_sparse=False),
labels = StreamDef(field='species', shape=output_dim,
is_sparse=False)
)), randomize = is_training,
max_sweeps = INFINITELY_REPEAT if is_training else 1)
def save_weights(fn, ihWeights, hBiases, hoWeights, oBiases):
f = open(fn, 'w')
for vals in ihWeights:
for v in vals: f.write("%s\
" % v)
for v in hBiases: f.write("%s\
" % v)
for vals in hoWeights: for v in vals:
f.write("%s\
" % v) for v in oBiases:
f.write("%s\
" % v) f.close()
def do_demo():
# create NN, train, test, predict input_dim = 4
hidden_dim = 2
output_dim = 3
train_file = "trainData_cntk.txt" test_file = "testData_cntk.txt"
input_Var = C.ops.input(input_dim, np.float32) label_Var = C.ops.input(output_dim, np.float32)
print("Creating a 4-2-3 tanh softmax NN for Iris data ") with default_options(init = glorot_uniform()):
hLayer = Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(input_Var)
oLayer = Dense(output_dim, activation=C.ops.softmax, name='outLayer')(hLayer)
nnet = oLayer
# ----------------------------------
print("Creating a cross entropy mini-batch Trainer \
") ce = C.cross_entropy_with_softmax(nnet, label_Var)
pe = C.classification_error(nnet, label_Var)
fixed_lr = 0.05
lr_per_batch = learning_rate_schedule(fixed_lr,
UnitType.minibatch)
learner = C.sgd(nnet.parameters, lr_per_batch) trainer = C.Trainer(nnet, (ce, pe), [learner])
max_iter = 5000 # 5000 maximum training iterations batch_size = 5 # mini-batch size 5
progress_freq = 1000 # print error every n minibatches
reader_train = create_reader(train_file, True, input_dim, output_dim)
my_input_map = {
input_Var : reader_train.streams.features, label_Var : reader_train.streams.labels
}
pp = ProgressPrinter(progress_freq)
print("Starting training \
") for i in range(0, max_iter):
currBatch = reader_train.next_minibatch(batch_size, input_map = my_input_map)
trainer.train_minibatch(currBatch)
pp.update_with_trainer(trainer) print("\
Training complete")
# ----------------------------------
print("\
Evaluating test data \
")
reader_test = create_reader(test_file, False, input_dim,
output_dim)
numTestItems = 30
allTest = reader_test.next_minibatch(numTestItems,
input_map = my_input_map)
test_error = trainer.test_minibatch(allTest) print("Classification error on the 30 test items = %f"
% test_error)
# ----------------------------------
# make a prediction for an unknown flower
# first train versicolor = 7.0,3.2,4.7,1.4,0,1,0 unknown = np.array([[6.9, 3.1, 4.6, 1.3]],
dtype=np.float32)
print("\
Predicting Iris species for input features: ") my_print(unknown[0], 1) # 1 decimal
predicted = nnet.eval( {input_Var: unknown} ) print("Prediction is: ") my_print(predicted[0], 3) # 3 decimals
# ---------------------------------
print("\
Trained model input-to-hidden weights: \
") print(hLayer.hidLayer.W.value)
print("\
Trained model hidden node biases: \
") print(hLayer.hidLayer.b.value)
print("\
Trained model hidden-to-output weights: \
") print(oLayer.outLayer.W.value)
print("\
Trained model output node biases: \
") print(oLayer.outLayer.b.value)
save_weights("weights.txt", hLayer.hidLayer.W.value, hLayer.hidLayer.b.value, oLayer.outLayer.W.value, oLayer.outLayer.b.value)
return 0 # success
def main():
print("\
Begin Iris demo (CNTK 2.0) \
") np.random.seed(0)
do_demo() # all the work is done in do_demo()
if __name__ == "__main__": main()
# end script -------------------------------------------------------------------
26 msdn magazine Machine Learning