用python生成与调用cntk模型代码演示方法
由于一些原因，视频录制要告一段落了。再写一篇关于cntk的文章分享出来吧。我也很想将这个事情进行下去。以后如果条件允许还会接着做。
cntk2.0框架生成的模型才可以支持python。1.0不支持。
python可以导入cntk.exe生成的框架，也可以导入python调用cntk生成的框架。举两个例子：
1 、导入cntk.exe生成的框架。
from cntk.ops.functions import load_model
from PIL import Image
import numpy as np
from sklearn.utils import shuffle
np.random.seed(0)
def generate(N, mean, cov, diff):
#import ipdb;ipdb.set_trace()
samples_per_class = int(N/2)
X0 = np.random.multivariate_normal(mean, cov, samples_per_class)
Y0 = np.zeros(samples_per_class)
for ci, d in enumerate(diff):
X1 = np.random.multivariate_normal(mean+d, cov, samples_per_class)
Y1 = (ci+1)*np.ones(samples_per_class)
X0 = np.concatenate((X0,X1))
Y0 = np.concatenate((Y0,Y1))
X, Y = shuffle(X0, Y0)
return X,Y
mean = np.random.randn(2)
cov = np.eye(2)
features, labels = generate(6, mean, cov, [[3.0], [3.0, 0.0]])
features= features.astype(np.float32)
labels= labels.astype(np.int)
print(features)
print(labels)
z = load_model("MC.dnn")
print(z.parameters[0].value)
print(z.parameters[0])
print(z)
print(z.uid)
#print(z.signature)
#print(z.layers[0].E.shape)
#print(z.layers[2].b.value)
for index in range(len(z.inputs)):
print("Index {} for input: {}.".format(index, z.inputs[index]))
for index in range(len(z.outputs)):
print("Index {} for output: {}.".format(index, z.outputs[index].name))
import cntk as ct
z_out = ct.combine([z.outputs[2].owner])
predictions = np.squeeze(z_out.eval({z_out.arguments[0]:[features]}))
ret = list()
for t in predictions:
ret.append(np.argmax(t))
top_class = np.argmax(predictions)
print(ret)
print("predictions{}.top_class{}".format(predictions,top_class))
上述的代码生成一个.py文件。放到3分类例子中，跟模型一个文件夹下（需要预先用cntk.exe生成模型）。CNTK-2.0.beta15.0\CNTK-2.0.beta15.0\Tutorials\HelloWorld-
LogisticRegression\Models
2 、python生成模型和使用自己的模型：
代码如下：
# -*- coding: utf-8 -*-
"""
Created on Mon Apr 10 04:59:27 2017
@author: Administrator
"""
from __future__ import print_function
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import colorConverter, ListedColormap
from cntk.learners import sgd, learning_rate_schedule, UnitType #old in learner
from cntk.ops.functions import load_model
from cntk.ops import * #softmax
from cntk.io import CTFDeserializer, MinibatchSource, StreamDef, StreamDefs
from cntk import *
from cntk.layers import Dense, Sequential
from cntk.logging import ProgressPrinter
def generate_random_data(sample_size, feature_dim, num_classes):
# Create synthetic data using NumPy.
Y = np.random.randint(size=(sample_size, 1), low=0, high=num_classes)
# Make sure that the data is separable
X = (np.random.randn(sample_size, feature_dim) + 3) * (Y + 1)
X = X.astype(np.float32)
# converting class 0 into the vector "1 0 0",
# class 1 into vector "0 1 0", ...
class_ind = [Y == class_number for class_number in range(num_classes)]
Y = np.asarray(np.hstack(class_ind), dtype=np.float32)
return X, Y
# Read a CTF formatted text (as mentioned above) using the CTF deserializer from a file
def create_reader(path, is_training, input_dim, num_label_classes):
return MinibatchSource(CTFDeserializer(path, StreamDefs(
labels = StreamDef(field='labels', shape=num_label_classes, is_sparse=False),
features = StreamDef(field='features', shape=input_dim, is_sparse=False)
)), randomize = is_training, epoch_size = INFINITELY_REPEAT if is_training else FULL_DATA_SWEEP)
def ffnet():
inputs = 2
outputs = 2
layers = 2
hidden_dimension = 50
# input variables denoting the features and label data
features = input((inputs), np.float32)
label = input((outputs), np.float32)
# Instantiate the feedforward classification model
my_model = Sequential ([
Dense(hidden_dimension, activation=sigmoid,name='d1'),
Dense(outputs)])
z = my_model(features)
ce = cross_entropy_with_softmax(z, label)
pe = classification_error(z, label)
# Instantiate the trainer object to drive the model training
lr_per_minibatch = learning_rate_schedule(0.125, UnitType.minibatch)
# Initialize the parameters for the reader
input_dim=2
num_output_classes=2
num_samples_per_sweep = 6000
# Get minibatches of training data and perform model training
minibatch_size = 25
num_minibatches_to_train = 1024
num_sweeps_to_train_with = 2#10
num_minibatches_to_train = (num_samples_per_sweep * num_sweeps_to_train_with) / minibatch_size
# progress_printer = ProgressPrinter(0)
progress_printer = ProgressPrinter(tag='Training',num_epochs=num_sweeps_to_train_with)
trainer = Trainer(z, (ce, pe), [sgd(z.parameters, lr=lr_per_minibatch)], [progress_printer])
#trainer = Trainer(z, (ce, pe), [sgd(z.parameters, lr=lr_per_minibatch)])
train_file = "Train2-noLiner_cntk_text.txt"
# Create the reader to training data set
reader_train = create_reader(train_file, True, input_dim, num_output_classes)
# Map the data streams to the input and labels.
input_map = {
label : reader_train.streams.labels,
features : reader_train.streams.features
}
print(reader_train.streams.keys())
aggregate_loss = 0.0
#for i in range(num_minibatches_to_train):
for i in range(0, int(num_minibatches_to_train)):
#train_features, labels = generate_random_data(minibatch_size, inputs, outputs)
# Specify the mapping of input variables in the model to actual minibatch data to be trained with
#trainer.train_minibatch({features : train_features, label : labels})
# Read a mini batch from the training data file
data = reader_train.next_minibatch(minibatch_size, input_map = input_map)
trainer.train_minibatch(data)
sample_count = trainer.previous_minibatch_sample_count
aggregate_loss += trainer.previous_minibatch_loss_average * sample_count
#
last_avg_error = aggregate_loss / trainer.total_number_of_samples_seen
trainer.summarize_training_progress()
z.save_model("myfirstmod.dnn")
print(z)
print(z.parameters)
print(z.d1)
print(z.d1.signature)
print(z.d1.root_function)
print(z.d1.placeholders)
print(z.d1.parameters)
print(z.d1.op_name)
print(z.d1.type)
print(z.d1.output)
print(z.outputs)
test_features, test_labels = generate_random_data(minibatch_size, inputs, outputs)
avg_error = trainer.test_minibatch({features : test_features, label : test_labels})
print(' error rate on an unseen minibatch: {}'.format(avg_error))
return last_avg_error, avg_error
np.random.seed(98052)
ffnet()
print("-------------分割-----------------")
inputs = 2
outputs = 2
minibatch_size = 5
features = input((inputs), np.float32)
label = input((outputs), np.float32)
test_features, test_labels = generate_random_data(minibatch_size, inputs, outputs)
print('fea={}'.format(test_features))
z = load_model("myfirstmod.dnn")
ce = cross_entropy_with_softmax(z, label)
pe = classification_error(z, label)
lr_per_minibatch = learning_rate_schedule(0.125, UnitType.minibatch)
progress_printer = ProgressPrinter(0)
trainer = Trainer(z, (ce, pe), [sgd(z.parameters, lr=lr_per_minibatch)], [progress_printer])
avg_error = trainer.test_minibatch({z.arguments[0] : test_features, label : test_labels})
print(' error rate on an unseen minibatch: {}'.format(avg_error))
result1 = z.eval({z.arguments[0] : test_features})
#print("r={} ".format(result1))
out = softmax(z)
result = out.eval({z.arguments[0] : test_features})
print(result)
print("Label :", [np.argmax(label) for label in test_labels])
print("Predicted :", [np.argmax(label) for label in result])
#print("Predicted:", [np.argmax(result[i,:,:]) for i in range(result.shape[0])])
type1_x=[]
type1_y=[]
type2_x=[]
type2_y=[]
for i in range(len(test_labels)):
#for i in range(6):
if np.argmax(test_labels[i]) == 0:
type1_x.append( test_features[i][0] )
type1_y.append( test_features[i][1] )
if np.argmax(test_labels[i]) == 1:
type2_x.append( test_features[i][0] )
type2_y.append( test_features[i][1] )
type1 = plt.scatter(type1_x, type1_y,s=40, c='red',marker='+' )
type2 = plt.scatter(type2_x, type2_y, s=40, c='green',marker='+')
nb_of_xs = 100
xs1 = np.linspace(2, 8, num=nb_of_xs)
xs2 = np.linspace(2, 8, num=nb_of_xs)
xx, yy = np.meshgrid(xs1, xs2) # create the grid
featureLine = np.vstack((np.array(xx).reshape(1,nb_of_xs*nb_of_xs),np.array(yy).reshape(1,yy.size)))
print(featureLine.T)
r = out.eval({z.arguments[0] : featureLine.T})
print(r)
# Initialize and fill the classification plane
classification_plane = np.zeros((nb_of_xs, nb_of_xs))
for i in range(nb_of_xs):
for j in range(nb_of_xs):
#classification_plane[i,j] = nn_predict(xx[i,j], yy[i,j])
#r = out.eval({z.arguments[0] : [xx[i,j], yy[i,j]]})
classification_plane[i,j] = np.argmax(r[i*nb_of_xs+j] )
print(classification_plane)
# Create a color map to show the classification colors of each grid point
cmap = ListedColormap([
colorConverter.to_rgba('r', alpha=0.30),
colorConverter.to_rgba('b', alpha=0.30)])
# Plot the classification plane with decision boundary and input samples
plt.contourf(xx, yy, classification_plane, cmap=cmap)
plt.xlabel('x1')
plt.ylabel('x2')
#axes.legend((type1, type2,type3), ('0', '1','2'),loc=1)
plt.show()
代码内容：
1先生成模型。并打印出模型里面的参数
2调用模型，测试下模型错误率
3调用模型，输出结果
4将数据可视化
输出：dict_keys([‘features', ‘labels'])
Finished Epoch[1 of 2]: [Training] loss = 0.485836 * 12000, metric = 20.36% *
12000 0.377s (31830.2 samples/s);
Composite(Dense): Input(‘Input456', [#], [2]) -> Output(‘Block577_Output_0',
[#], [2])
(Parameter(‘W', [], [50 x 2]), Parameter(‘b', [], [2]), Parameter(‘W', [], [2
x 50]), Parameter(‘b', [], [50]))
Dense: Input(‘Input456', [#], [2]) -> Output(‘d1', [#], [50])
(Input(‘Input456', [#], [2]),)
Dense: Input(‘Input456', [#], [2]) -> Output(‘d1', [#], [50])
()
(Parameter(‘W', [], [2 x 50]), Parameter(‘b', [], [50]))
Dense
Tensor[50]
Output(‘d1', [#], [50])
(Output(‘Block577_Output_0', [#], [2]),)
error rate on an unseen minibatch: 0.6
