由於一些原因，視訊錄製要告一段落了。再寫一篇關於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,samples_per_class)
  Y0 = np.zeros(samples_per_class)

  for ci,d in enumerate(diff):
    X1 = np.random.multivariate_normal(mean+d,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,[[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,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,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,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,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,[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,c='green',marker='+') 



nb_of_xs = 100
xs1 = np.linspace(2,8,num=nb_of_xs)
xs2 = np.linspace(2,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]]})
    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]),[50]))

Dense: Input(‘Input456',[2]) -> Output(‘d1',[50])

(Input(‘Input456',)

Dense: Input(‘Input456',[50])

()

(Parameter(‘W',[50]))

Dense

Tensor[50]

Output(‘d1',[50])

(Output(‘Block577_Output_0',)

error rate on an unseen minibatch: 0.6

————-分割—————–

fea=[[ 2.74521399 3.6318233 ]

[ 3.45750308 3.8683207 ]

[ 3.49858737 4.31363964]

[ 9.01324368 1.75216711]

[ 9.15447521 7.21175623]]

average since average since examples

loss last metric last

error rate on an unseen minibatch: 0.2

[[ 0.57505184 0.42494816]

[ 0.70583773 0.29416227]

[ 0.67773896 0.32226101]

[ 0.04568771 0.95431226]

[ 0.95059013 0.04940984]]

Label : [0,1,1]

Predicted : [0,0]

[[ 2. 2. ]

[ 2.06060606 2. ]

[ 2.12121212 2. ]

…,

[ 7.87878788 8. ]

[ 7.93939394 8. ]

[ 8. 8. ]]

Train2-noLiner_cntk_text 部分資料：

|features 1.480778 -1.265981 |labels 1 0

|features -0.592276 3.097171 |labels 0 1

|features 4.654565 1.054850 |labels 0 1

|features 6.124534 0.265861 |labels 0 1

|features 6.529863 1.347884 |labels 0 1

|features 2.330881 4.995633 |labels 0 1

|features 1.690045 0.171233 |labels 1 0

|features 2.101682 3.911253 |labels 0 1

|features 1.907487 0.201574 |labels 1 0

|features 5.141490 1.246433 |labels 0 1

|features 0.696826 0.481824 |labels 1 0

|features 3.305343 4.792150 |labels 1 0

|features 3.496849 -0.408635 |labels 1 0

|features 3.911750 0.205660 |labels 0 1

|features 5.154604 0.453434 |labels 0 1

|features 4.084166 2.718320 |labels 0 1

|features 5.544332 1.617196 |labels 0 1

|features -0.050979 0.466522 |labels 1 0

|features 5.168221 4.647089 |labels 1 0

|features 3.051973 0.864701 |labels 1 0

|features 5.989367 4.118536 |labels 1 0

|features 1.251041 -0.505563 |labels 1 0

|features 3.528092 0.319297 |labels 0 1

|features 6.907406 6.122889 |labels 1 0

|features 2.168320 0.546091 |labels 1 0

以上這篇用python生成與呼叫cntk模型程式碼演示方法就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支援我們。