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
