def assert_cntk_ngraph_array_equal(cntk_op): cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.array_equal(cntk_ret, ng_ret)
def assert_cntk_ngraph_flat_isclose(cntk_op): cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.isclose(cntk_ret.flatten(), ng_ret.flatten()).all()
def test_element_times_2(): cntk_op = C.element_times([[1, 2, 3], [4, 5, 6]], [7, 8, 9]) cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.array_equal(cntk_ret, ng_ret)
def test_minus_3(): cntk_op = C.minus([1, 2, 3], [[4, 5, 6], [7, 8, 9]]) cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.array_equal(cntk_ret, ng_ret)
def test_times_6(): cntk_op = C.times([[1, 2], [3, 4], [5, 6]], [[7, 8, 9], [10, 11, 12]]) cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.array_equiv(cntk_ret, ng_ret)
def test_times_4(): cntk_op = C.times([[1, 2, 3], [4, 5, 6]], [[7], [8], [9]]) cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.array_equiv(cntk_ret, ng_ret)
def test_tanh_2(): cntk_op = C.tanh([0.]) cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.isclose(cntk_ret, ng_ret).all()
def test_exp_1(): cntk_op = C.exp([-2, -1., 0., 1., 2.]) cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.isclose(cntk_ret, ng_ret).all()
def test_exp_3(): cntk_op = C.exp([-0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.]) cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.isclose(cntk_ret, ng_ret).all()
def test_relu_1(): cntk_op = C.relu([-2, -1., 0., 1., 2.]) cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.array_equal(cntk_ret, ng_ret)
def test_relu_5(): cntk_op = C.relu([[-3, -2, -1], [1, 2, 3]]) cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.array_equal(cntk_ret, ng_ret)
def test_relu_3(): cntk_op = C.relu( [-0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.]) cntk_ret = cntk_op.eval() ng_op, _ = CNTKImporter().import_model(cntk_op) ng_ret = ng.transformers.make_transformer().computation(ng_op)() assert np.array_equal(cntk_ret, ng_ret)
def _create_model_and_execute_test(params): # Create CNTK model input_var = C.input_variable(params['input_dim'], np.float32) params['input_var'] = input_var params['act_fun'] = C.layers.blocks.identity params['init_fun'] = C.glorot_uniform() model = params['create_model'](params) label_var = C.input_variable((params['label_dim']), np.float32) loss = C.cross_entropy_with_softmax(model, label_var) eval_error = C.classification_error(model, label_var) lr_schedule = C.learning_rate_schedule(0.05, C.UnitType.minibatch) learner = C.sgd(model.parameters, lr_schedule) trainer = C.Trainer(model, (loss, eval_error), [learner]) input_value, label_value = _generate_random_sample( params['batch_size'], params['input_dim'], params['label_dim'] ) # Import to ngraph ng_loss, placeholders = CNTKImporter(batch_size=params['batch_size']).import_model(loss) parallel_update = CommonSGDOptimizer(0.05).minimize(ng_loss, ng_loss.variables()) transformer = ng.transformers.make_transformer() update_fun = transformer.computation([ng_loss, parallel_update], *placeholders) # Execute on CNTK trainer.train_minibatch({input_var: input_value, label_var: label_value}) cntk_ret = trainer.previous_minibatch_loss_average # Execute on ngraph input_value = np.moveaxis(input_value, 0, -1) label_value = np.moveaxis(label_value, 0, -1) ng_ret = update_fun(input_value, label_value)[0] return cntk_ret, ng_ret
def load_and_score(cifar_dir, model_file): map_file = os.path.join(cifar_dir, 'test_map.txt') if not os.path.exists(map_file): raise RuntimeError("This example require prepared dataset. \ Please run cifar_prepare.py example.") trained_network = os.path.join(cifar_dir, model_file) if not os.path.exists(trained_network): raise RuntimeError("This example require trained network. \ Please run cifar_training.py example.") cntk_model = C.ops.functions.load_model(trained_network) ng_model, ng_placeholders = CNTKImporter().import_model(cntk_model) eval_fun = ng.transformers.make_transformer().computation( ng_model, *ng_placeholders) cntk_results = [] ng_results = [] same_predictions = [] for line in open(map_file): image_file, label = line.split() rgb_image = np.asarray(Image.open(image_file), dtype="float32") pic = np.ascontiguousarray(np.moveaxis(rgb_image, 2, 0)) cntk_predictions = np.squeeze( cntk_model.eval({cntk_model.arguments[0]: [pic]})) cntk_results.append(int(np.argmax(cntk_predictions)) == int(label)) ng_predictions = eval_fun(pic) ng_results.append(int(np.argmax(ng_predictions)) == int(label)) same_predictions.append(np.allclose(cntk_predictions, ng_predictions)) test_size = len(ng_results) if np.all(same_predictions): print( 'CNTK and ngraph predictions identical. Prediction correctness - {0:.2f}%.' .format(np.count_nonzero(ng_results) * 100 / test_size)) else: print('CNTK prediction correctness - {0:.2f}%'.format( np.count_nonzero(cntk_results) * 100 / test_size)) print('ngraph prediction correctness - {0:.2f}%'.format( np.count_nonzero(cntk_results) * 100 / test_size)) print("")
def load_and_score(mnist_dir): jpg_files = glob.glob(os.path.join(mnist_dir, 'jpg/*.jpg')) if not jpg_files: raise RuntimeError( "This example require a dataset. Please download and extract the MNIST jpg files." ) trained_network = os.path.join(mnist_dir, "MNIST.dnn") if not os.path.exists(trained_network): raise RuntimeError( "This example require trained network. Please run mnist_training.py example." ) cntk_model = C.ops.functions.load_model(trained_network) ng_model, ng_placeholders = CNTKImporter().import_model(cntk_model) eval_fun = ng.transformers.make_transformer().computation(ng_model, *ng_placeholders) cntk_results = [] ng_results = [] for filename in jpg_files: label = int(os.path.basename(filename).split("_")[1]) rgb_image = np.asarray(Image.open(filename), dtype="float32") pic = np.ascontiguousarray(rgb_image).flatten() cntk_predictions = np.squeeze( cntk_model.eval({cntk_model.arguments[0]: [pic]}) ) cntk_results.append(int(np.argmax(cntk_predictions) == label)) ng_predictions = eval_fun(pic) ng_results.append(int(np.argmax(ng_predictions) == label)) test_size = len(jpg_files) print('CNTK prediction correctness - {0:.2f}%'.format( np.count_nonzero(cntk_results) * 100 / test_size )) print('ngraph prediction correctness - {0:.2f}%'.format( np.count_nonzero(ng_results) * 100 / test_size ))
def load_and_score(mnist_jpg_dir): cntk_model = C.ops.functions.load_model("/tmp/data/MNIST/MNIST.dnn") ng_model, ng_placeholders = CNTKImporter().import_model(cntk_model) eval_fun = ng.transformers.make_transformer().computation( ng_model, *ng_placeholders) for filename in glob.glob(os.path.join(mnist_jpg_dir, '*.jpg')): rgb_image = np.asarray(Image.open(filename), dtype="float32") pic = np.ascontiguousarray(rgb_image).flatten() cntk_predictions = np.squeeze( cntk_model.eval({cntk_model.arguments[0]: [pic]})) cntk_top_class = np.argmax(cntk_predictions) ng_predictions = eval_fun(pic) ng_top_class = np.argmax(ng_predictions) actual_number = os.path.basename(filename).split("_")[1] print("Digit in jpg file: " + actual_number) print("\tCNTK prediction: " + str(cntk_top_class)) print("\tngraph prediction: " + str(ng_top_class)) print("")
label = C.blocks.Input(num_output_classes) z = fully_connected_classifier_net(input, num_output_classes, hidden_layers_dim, num_hidden_layers, C.sigmoid) loss = C.cross_entropy_with_softmax(z, label) eval_error = C.ops.classification_error(z, label) learning_rate = 0.5 lr_schedule = C.learning_rate_schedule(learning_rate, C.UnitType.sample) learner = C.learner.sgd(z.parameters, lr_schedule) trainer = C.Trainer(z, (loss, eval_error), [learner]) # ngraph L, placeholders = CNTKImporter().import_model(loss) parallel_update = CommonSGDOptimizer(learning_rate).minimize(L, L.variables()) transformer = ng.transformers.make_transformer() update_fun = transformer.computation([L, parallel_update], *placeholders) # CNTK training for i in range(0, number_of_iterations): for xs, ys in zip(features, labels): trainer.train_minibatch({input: [xs], label: [ys]}) training_loss = C.utils.get_train_loss(trainer) print("cntk iteration {0} -> loss: {1}".format(i, training_loss)) # ngraph training for i in range(0, number_of_iterations): for xs, ys in zip(features, labels):
output_dim = num_output_classes z = linear_layer(input, output_dim) label = C.input_variable((num_output_classes), np.float32) loss = C.cross_entropy_with_softmax(z, label) eval_error = C.classification_error(z, label) learning_rate = 0.05 lr_schedule = C.learning_rate_schedule(learning_rate, C.UnitType.sample) learner = C.sgd(z.parameters, lr_schedule) trainer = C.Trainer(z, (loss, eval_error), [learner]) # ngraph L, placeholders = CNTKImporter().import_model(loss) parallel_update = CommonSGDOptimizer(learning_rate).minimize( L, L.variables()) transformer = ng.transformers.make_transformer() update_fun = transformer.computation([L, parallel_update], *placeholders) # CNTK training for i in range(0, number_of_iterations): for xs, ys in zip(features, labels): trainer.train_minibatch({input: [xs], label: [ys]}) training_loss = trainer.previous_minibatch_loss_average print("cntk iteration {0} -> loss: {1}".format(i, training_loss)) # ngraph training for i in range(0, number_of_iterations):
def train_and_evaluate(reader_train, reader_test, max_epochs, model_func): # ====================================================================================== # Creating # ====================================================================================== input_var = C.input((num_channels, image_height, image_width)) feature_scale = 1.0 / 256.0 input_var_norm = C.element_times(feature_scale, input_var) cntk_model = model_func(input_var_norm, num_classes) label_var = C.input((num_classes)) loss = C.cross_entropy_with_softmax(cntk_model, label_var) error = C.classification_error(cntk_model, label_var) minibatch_size = 64 learning_rate = 0.01 momentum = 0.9 lr_schedule = C.learning_rate_schedule(learning_rate, C.UnitType.minibatch) learner = C.momentum_sgd(cntk_model.parameters, lr_schedule, C.momentum_schedule(momentum)) trainer = C.Trainer(cntk_model, (loss, error), [learner]) ng_model, ng_placeholders = CNTKImporter( batch_size=minibatch_size).import_model(cntk_model) ng_labels = ng.placeholder( [ng.make_axis(num_classes), ng.make_axis(minibatch_size, 'N')]) ng_placeholders.append(ng_labels) transformer = ng.transformers.make_transformer() ng_loss = create_loss_and_learner(ng_model, ng_labels, learning_rate, momentum) training_fun = transformer.computation(ng_loss, *ng_placeholders) ng_error = classification_error(ng_model, ng_labels) test_fun = transformer.computation(ng_error, *ng_placeholders) # ====================================================================================== # Training # ====================================================================================== epoch_size = 50000 input_map = { input_var: reader_train.streams.features, label_var: reader_train.streams.labels } num_minibatches_to_train = (epoch_size * max_epochs) / minibatch_size for _ in range(0, int(num_minibatches_to_train)): data = reader_train.next_minibatch(minibatch_size, input_map=input_map) trainer.train_minibatch(data) features_batch = np.moveaxis(np.squeeze(data[input_var].asarray()), 0, -1) labels_batch = np.moveaxis( data[label_var].data.data.slice_view( [0, 0, 0], [minibatch_size, num_classes]).asarray().todense(), 0, -1) training_fun(features_batch, labels_batch) # ====================================================================================== # Evaluation # ====================================================================================== cntk_results = 0.0 ng_results = 0.0 epoch_size = 10000 input_map = { input_var: reader_test.streams.features, label_var: reader_test.streams.labels } num_minibatches_to_test = epoch_size // minibatch_size for _ in range(num_minibatches_to_test): data = reader_test.next_minibatch(minibatch_size, input_map=input_map) cntk_results += trainer.test_minibatch(data) features_batch = np.moveaxis(np.squeeze(data[input_var].asarray()), 0, -1) labels_batch = np.moveaxis( data[label_var].data.data.slice_view([0, 0, 0], [64, 10]).asarray().todense(), 0, -1) ng_results += test_fun(features_batch, labels_batch) print("CNTK results: {0:.2f}%".format( (cntk_results * 100.0) / num_minibatches_to_test)) print("ngraph results: {0:.2f}%".format( (ng_results * 100.0) / num_minibatches_to_test)) print("") return C.softmax(cntk_model)
def train_and_test(data_dir): train_file = os.path.join(data_dir, "Train-28x28_cntk_text.txt") test_file = os.path.join(data_dir, "Test-28x28_cntk_text.txt") input_dim = 784 output_dim = 10 input_var = C.input(input_dim) label_var = C.input(output_dim) cntk_model = create_model(input_var / 256.0, 2, 400, output_dim) cntk_loss = C.cross_entropy_with_softmax(cntk_model, label_var) cntk_error = C.classification_error(cntk_model, label_var) learning_rate = 0.2 lr_schedule = C.learning_rate_schedule(learning_rate, C.UnitType.minibatch) learner = C.sgd(cntk_model.parameters, lr_schedule) trainer = C.Trainer(cntk_model, (cntk_loss, cntk_error), [learner]) batch_size = 64 # ngraph import begin ================================================================== ng_model, ng_placeholders = CNTKImporter(batch_size=batch_size).import_model(cntk_model) ng_labels = ng.placeholder([ng.make_axis(output_dim), ng.make_axis(batch_size, 'N')]) ng_placeholders.append(ng_labels) transformer = ng.transformers.make_transformer() ng_loss = cross_entropy_with_softmax(ng_model, ng_labels) parallel_update = CommonSGDOptimizer(learning_rate).minimize(ng_loss, ng_loss.variables()) training_fun = transformer.computation([ng_loss, parallel_update], *ng_placeholders) ng_error = classification_error(ng_model, ng_labels) test_fun = transformer.computation(ng_error, *ng_placeholders) # ngraph import end ==================================================================== reader_train = create_reader(train_file, True, input_dim, output_dim) train_input_map = { input_var: reader_train.streams.features, label_var: reader_train.streams.labels } num_samples = 60000 num_epochs = 10 num_minibatches_to_train = (num_samples * num_epochs) / batch_size for _ in range(0, int(num_minibatches_to_train)): data = reader_train.next_minibatch(batch_size, input_map=train_input_map) trainer.train_minibatch(data) # ngraph train features_batch = np.moveaxis(np.squeeze(data[input_var].asarray()), 0, -1) labels_batch = np.moveaxis(np.squeeze(data[label_var].asarray()), 0, -1) training_fun(features_batch, labels_batch) reader_test = create_reader(test_file, False, input_dim, output_dim) test_input_map = { input_var: reader_test.streams.features, label_var: reader_test.streams.labels } cntk_result = 0.0 ng_error = 0.0 num_samples = 10000 num_minibatches_to_test = num_samples // batch_size for _ in range(num_minibatches_to_test): data = reader_test.next_minibatch(batch_size, input_map=test_input_map) cntk_result += trainer.test_minibatch(data) # ngraph test features_batch = np.moveaxis(np.squeeze(data[input_var].asarray()), 0, -1) labels_batch = np.moveaxis(np.squeeze(data[label_var].asarray()), 0, -1) ng_error += test_fun(features_batch, labels_batch) print("Average CNTK test error: {0:.2f}%".format(cntk_result * 100 / num_minibatches_to_test)) print("Average ngraph test error: {0:.2f}%".format(ng_error * 100 / num_minibatches_to_test)) C.softmax(cntk_model).save(os.path.join(MNIST, "MNIST.dnn"))
# ****************************************************************************** # Copyright 2017-2018 Intel Corporation # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ****************************************************************************** from __future__ import print_function import cntk as C import ngraph as ng from ngraph.frontends.cntk.cntk_importer.importer import CNTKImporter cntk_op = C.minus([1, 2, 3], [4, 5, 6]) ng_op, ng_placeholders = CNTKImporter().import_model(cntk_op) results = ng.transformers.make_transformer().computation(ng_op) print(results())