def cntk_device(device_id): ''' Converts the legacy device ID as it was used in CNTK 1 to a :class:`~cntk.device.DeviceDescriptor` instance. Args: device_id (int): device id, -1 for CPU, 0 or higher for GPU Returns: :class:`~cntk.device.DeviceDescriptor` ''' if device_id == -1: return cpu() else: return gpu(device_id)
def test_eval_one_hot_seq(one_hot_batch, device_id): dim = 10 multiplier = 2 from cntk.device import cpu, gpu, set_default_device set_default_device(gpu(0)) for var_is_sparse in [True, False]: in1 = input_variable(shape=(dim,), is_sparse=var_is_sparse) # Convert CNTK node value to dense so that we can compare it later z = times(in1, np.eye(dim)*multiplier) # Convert expectation to dense expected = [np.eye(dim)[seq]*multiplier for seq in one_hot_batch] batch = one_hot(one_hot_batch, num_classes=dim, device=cntk_device(device_id)) result = z.eval({in1: batch}, device=cntk_device(device_id)) assert np.all([np.allclose(a,b) for a,b in zip(result, expected)])
def decode_model(use_gpu=True, gpu_id=0): # use GPU or CPU according to parameters try_set_default_device(gpu(gpu_id) if use_gpu else cpu()) model_dnn = load_model("./model/speech_enhancement.model") features_file = "./test_normed.scp" feature_dim = 257 test_reader = MinibatchSource(HTKFeatureDeserializer(StreamDefs( amazing_features=StreamDef( shape=feature_dim, context=(3, 3), scp=features_file))), randomize=False, frame_mode=False) eval_input_map = {input: test_reader.streams.amazing_features} f = open(features_file) line = f.readline() while line: temp_input_path = line.split(']')[0] mb_size = temp_input_path.split(',')[-1] mb_size = int(mb_size) + 1 noisy_fea = test_reader.next_minibatch( mb_size, input_map=eval_input_map) real_noisy_fea = noisy_fea[input].data node_in_graph = model_dnn.find_by_name('irm') output_nodes = combine([node_in_graph.owner]) out_noisy_fea = output_nodes.eval(real_noisy_fea) # out_noisy_fea = as_composite(model_dnn.output1[0].owner).eval( # real_noisy_fea) out_SE_noisy_fea = np.concatenate((out_noisy_fea), axis=0) out_file_path = line.split('=')[0] out_file_name = os.path.join('./enhanced_norm_fea_mat', out_file_path) out_file_fullpath = os.path.split(out_file_name)[0] # print (out_file_fullpath) if not os.path.exists(out_file_fullpath): os.makedirs(out_file_fullpath) sio.savemat(out_file_name, {'SE': out_SE_noisy_fea}) line = f.readline() f.close()
parser.add_argument('-logdir', '--logdir', help='Log file', required=False, default=None) parser.add_argument('-e', '--epochs', help='Total number of epochs to train', type=int, required=False, default='90') parser.add_argument('-es', '--epoch_size', help='Size of epoch in samples', type=int, required=False, default='1281167') parser.add_argument('-q', '--quantized_bits', help='Number of quantized bits used for gradient aggregation', type=int, required=False, default='32') parser.add_argument('-b', '--block_samples', type=int, help="Number of samples per block for block momentum (BM) distributed learner (if 0 BM learner is not used)", required=False, default=None) parser.add_argument('-a', '--distributed_after', help='Number of samples to train with before running distributed', type=int, required=False, default='0') parser.add_argument('-r', '--restart', help='Indicating whether to restart from scratch (instead of restart from checkpoint file by default)', action='store_true', default=False) parser.add_argument('-device', '--device', type=int, help="Force to run the script on a specified device", required=False, default=None) parser.add_argument('-profile', '--profile', help="Turn on profiling", action='store_true', default=False) args = vars(parser.parse_args()) if args['outputdir'] != None: model_path = args['outputdir'] + "/models" if args['device'] != None: try_set_default_device(gpu(args['device'])) if args['epoch_size'] is not None: epoch_size = args['epoch_size'] data_path = args['datadir'] if not os.path.isdir(data_path): raise RuntimeError("Directory %s does not exist" % data_path) mean_data = os.path.join(abs_path, 'ImageNet1K_mean.xml') train_data = os.path.join(data_path, 'train_map.txt') test_data = os.path.join(data_path, 'val_map.txt') num_quantization_bits = args['quantized_bits'] epochs = args['epochs']
true_label = int(tokens[1 + column_offset]) predicted_label = np.argmax(probs) if predicted_label == true_label: correct_count += 1 np.savetxt(results_file, probs[np.newaxis], fmt="%.3f") if pred_count % 100 == 0: print("Processed {0} samples ({1} correct)".format(pred_count, (float(correct_count) / pred_count))) if pred_count >= num_images: break print ("{0} out of {1} predictions were correct {2}.".format(correct_count, pred_count, (float(correct_count) / pred_count))) if __name__ == '__main__': try_set_default_device(gpu(0)) # check for model and data existence if not (os.path.exists(_base_model_file) and os.path.exists(_train_map_file) and os.path.exists(_test_map_file)): print("Please run 'python install_data_and_model.py' first to get the required data and model.") exit(0) # You can use the following to inspect the base model and determine the desired node names # node_outputs = get_node_outputs(load_model(_base_model_file)) # for out in node_outputs: print("{0} {1}".format(out.name, out.shape)) # Train only if no model exists yet or if make_mode is set to False if os.path.exists(tl_model_file) and make_mode: print("Loading existing model from %s" % tl_model_file) trained_model = load_model(tl_model_file) else: trained_model = train_model(_base_model_file, _feature_node_name, _last_hidden_node_name,
# -*- coding:UTF-8 -*- import cntk as C import numpy as np from cntk.io import MinibatchSource, HTKFeatureDeserializer, StreamDef, StreamDefs from cntk import load_model, combine from cntk.device import gpu,try_set_default_device,cpu from cntk.ops import as_composite import scipy.io as sio import os import sys GPU_id = int(sys.argv[1]) try_set_default_device(gpu(GPU_id)) model_dnn= load_model("./model/speech_enhancement.model") features_file = "./test_normed.scp" feature_dim = 257 test_reader = MinibatchSource(HTKFeatureDeserializer(StreamDefs( amazing_features = StreamDef(shape=feature_dim,context=(3,3), scp=features_file))),randomize = False,frame_mode=False) eval_input_map = {input :test_reader.streams.amazing_features} f = open(features_file) line = f.readline() while line: temp_input_path = line.split(']')[0] mb_size = temp_input_path.split(',')[-1] mb_size = int(mb_size) + 1 noisy_fea=test_reader.next_minibatch(mb_size, input_map = eval_input_map) real_noisy_fea=noisy_fea[input].data node_in_graph = model_dnn.find_by_name('irm') output_nodes = combine([node_in_graph.owner])
except KeyError: base_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), *"../../../../Examples/Image/DataSets/CIFAR-10".split("/")) base_path = os.path.normpath(base_path) os.chdir(os.path.join(base_path, '..')) from _cntk_py import set_computation_network_trace_level, set_fixed_random_seed, force_deterministic_algorithms set_computation_network_trace_level(1) set_fixed_random_seed(1) # BUGBUG: has no effect at present # TODO: remove debugging facilities once this all works #force_deterministic_algorithms() # TODO: do the above; they lead to slightly different results, so not doing it for now create_train_reader = lambda data_size: create_reader(os.path.join(base_path, 'train_map.txt'), os.path.join(base_path, 'CIFAR-10_mean.xml'), True, data_size, 0) test_reader = create_reader(os.path.join(base_path, 'test_map.txt'), os.path.join(base_path, 'CIFAR-10_mean.xml'), False, FULL_DATA_SWEEP) distributed_after_samples = 0 num_quantization_bits = 32 create_dist_learner = lambda learner: distributed.data_parallel_distributed_learner( learner=learner, num_quantization_bits=num_quantization_bits, distributed_after=distributed_after_samples) return convnet_cifar10_dataaug(create_train_reader, test_reader, create_dist_learner, max_epochs=1, num_mbs_per_log=None) if __name__=='__main__': assert distributed.Communicator.rank() < distributed.Communicator.num_workers() set_default_device(gpu(0)) # force using GPU-0 in test for speed run_cifar_convnet_distributed() distributed.Communicator.finalize()
from __future__ import print_function import numpy as np import sys import os import cntk as C from cntk.io import MinibatchSource, CTFDeserializer, StreamDef, StreamDefs, INFINITELY_REPEAT, FULL_DATA_SWEEP from sklearn.metrics import precision_recall_fscore_support from sklearn.exceptions import UndefinedMetricWarning from cntk.device import try_set_default_device, gpu import warnings warnings.filterwarnings("ignore", category=UndefinedMetricWarning) try_set_default_device(gpu(1)) #Initialize Global variables validation_query_vectors = [] validation_passage_vectors = [] validation_labels = [] q_max_words = 15 p_max_words = 120 emb_dim = 50 #The following LoadValidationSet method reads ctf format validation file and creates query, passage feature vectors and also copies labels for each pair. #the created vectors will be useful to find metrics on validation set after training each epoch which will be useful to decide the best model def LoadValidationSet(validationfile): f = open(validationfile, 'r', encoding="utf-8") for line in f: tokens = line.strip().split("|") #tokens[0] will be empty token since the line is starting with | x1 = tokens[1].replace("qfeatures", "").strip() #Query Features