def create_model(base_model_file,
input_features,
num_classes,
dropout_rate=0.5,
freeze_weights=False):
# Load the pretrained classification net and find nodes
base_model = load_model(base_model_file)
feature_node = find_by_name(base_model, 'features')
beforePooling_node = find_by_name(base_model, "z.x.x.r")
#graph.plot(base_model, filename="base_model.pdf") # Write graph visualization
# Clone model until right before the pooling layer, ie. until including z.x.x.r
modelCloned = combine([beforePooling_node.owner]).clone(
CloneMethod.freeze if freeze_weights else CloneMethod.clone,
{feature_node: placeholder(name='features')})
# Center the input around zero and set model input.
# Do this early, to avoid CNTK bug with wrongly estimated layer shapes
feat_norm = input_features - constant(114)
model = modelCloned(feat_norm)
# Pool over all spatial dimensions and add dropout layer
avgPool = GlobalAveragePooling(name="poolingLayer")(model)
if dropout_rate > 0:
avgPoolDrop = Dropout(dropout_rate)(avgPool)
else:
avgPoolDrop = avgPool
# Add new dense layer for class prediction
finalModel = Dense(num_classes, activation=None,
name="prediction")(avgPoolDrop)
return finalModel
def create_resnet_model(input, num_classes):
conv = convolution_bn(input, (3, 3), 16)
r1_1 = resnet_basic_stack(conv, 16, 3)
r2_1 = resnet_basic_inc(r1_1, 32)
r2_2 = resnet_basic_stack(r2_1, 32, 2)
r3_1 = resnet_basic_inc(r2_2, 64)
r3_2 = resnet_basic_stack(r3_1, 64, 2)
pool = GlobalAveragePooling()(r3_2)
net = Dense(num_classes, init=he_normal(), activation=None)(pool)
return net
def create_model(input, num_stack_layers, num_classes):
c_map = [16, 32, 64]
conv = conv_bn_relu(input, (3, 3), c_map[0])
r1 = resnet_basic_stack(conv, num_stack_layers, c_map[0])
r2_1 = resnet_basic_inc(r1, c_map[1])
r2_2 = resnet_basic_stack(r2_1, num_stack_layers - 1, c_map[1])
r3_1 = resnet_basic_inc(r2_2, c_map[2])
r3_2 = resnet_basic_stack(r3_1, num_stack_layers - 1, c_map[2])
# Global average pooling and output
pool = GlobalAveragePooling(name='final_avg_pooling')(r3_2)
z = Dense(num_classes, init=normal(0.01))(pool)
return z
def create_model(base_model_file, input_features, params):
num_classes = params['num_classes']
dropout_rate = params['dropout_rate']
freeze_weights = params['freeze_weights']
# Load the pretrained classification net and find nodes
base_model = load_model(base_model_file)
log = logging.getLogger("neuralnets1.utils.create_model")
log.info('Loaded base model - %s with layers:' % base_model_file)
node_outputs = get_node_outputs(base_model)
[log.info('%s , %s' % (layer.name, layer.shape)) for layer in node_outputs]
graph.plot(base_model,
filename="base_model.pdf") # Write graph visualization
feature_node = find_by_name(base_model, 'features')
beforePooling_node = find_by_name(base_model, "z.x.x.r")
# Clone model until right before the pooling layer, ie. until including z.x.x.r
modelCloned = combine([beforePooling_node.owner]).clone(
CloneMethod.freeze if freeze_weights else CloneMethod.clone,
{feature_node: placeholder(name='features')})
# Center the input around zero and set model input.
# Do this early, to avoid CNTK bug with wrongly estimated layer shapes
feat_norm = input_features - constant(114)
model = modelCloned(feat_norm)
# Add pool layer
avgPool = GlobalAveragePooling(name="poolingLayer")(
model) # assign name to the layer and add to the model
# Add drop out layer
if dropout_rate > 0:
avgPoolDrop = Dropout(dropout_rate)(
avgPool
) # add drop out layer with specified drop out rate and add it to the model
else:
avgPoolDrop = avgPool
# Add new dense layer for class prediction
finalModel = Dense(num_classes, activation=None, name="Dense")(avgPoolDrop)
return finalModel
def convnetlrn_cifar10_dataaug(reader_train,
reader_test,
epoch_size=50000,
max_epochs=80):
_cntk_py.set_computation_network_trace_level(0)
# Input variables denoting the features and label data
input_var = C.input_variable((num_channels, image_height, image_width))
label_var = C.input_variable((num_classes))
# input normalization 1/256 = 0.00396025
scaled_input = C.element_times(C.constant(0.00390625), input_var)
f = GlobalAveragePooling()
f.update_signature((1, 8, 8))
with C.layers.default_options():
z = C.layers.Sequential([
C.layers.For(
range(1), lambda: [
C.layers.Convolution2D(
(3, 3), 32, strides=(1, 1), pad=True),
C.layers.Activation(activation=C.relu),
C.layers.Convolution2D(
(1, 1), 64, strides=(1, 1), pad=False),
C.layers.MaxPooling((3, 3), strides=(2, 2), pad=True),
C.layers.Dropout(0.5)
]),
C.layers.For(
range(1), lambda: [
C.layers.Convolution2D(
(3, 3), 128, strides=(1, 1), pad=True),
C.layers.Activation(activation=C.relu),
C.layers.Convolution2D(
(1, 1), 160, strides=(1, 1), pad=False),
C.layers.Activation(activation=C.relu),
C.layers.MaxPooling((3, 3), strides=(2, 2), pad=True),
C.layers.Dropout(0.5)
]),
C.layers.For(
range(1), lambda: [
C.layers.Convolution2D(
(3, 3), 192, strides=(1, 1), pad=True),
C.layers.Activation(activation=C.relu),
C.layers.Convolution2D(
(1, 1), 256, strides=(1, 1), pad=False),
C.layers.Activation(activation=C.relu),
C.layers.Convolution2D(
(1, 1), 10, strides=(1, 1), pad=False),
C.layers.Activation(activation=C.relu),
C.layers.AveragePooling((8, 8), strides=(1, 1), pad=False)
])
])(scaled_input)
print('z.shape', z.shape)
z = C.flatten(z)
print('z.shape now', z.shape)
# loss and metric
ce = C.cross_entropy_with_softmax(z, label_var)
pe = C.classification_error(z, label_var)
# training config
minibatch_size = 64
# Set learning parameters
# learning rate
lr_per_sample = [0.0015625] * 20 + [0.00046875] * 20 + [
0.00015625
] * 20 + [0.000046875] * 10 + [0.000015625]
lr_schedule = C.learning_parameter_schedule_per_sample(
lr_per_sample, epoch_size=epoch_size)
# momentum
mms = [0] * 20 + [0.9983347214509387] * 20 + [0.9991670137924583]
mm_schedule = C.learners.momentum_schedule_per_sample(
mms, epoch_size=epoch_size)
l2_reg_weight = 0.002
# trainer object
learner = C.learners.momentum_sgd(z.parameters,
lr_schedule,
mm_schedule,
unit_gain=True,
l2_regularization_weight=l2_reg_weight)
progress_printer = C.logging.ProgressPrinter(tag='Training',
num_epochs=max_epochs)
trainer = C.Trainer(z, (ce, pe), learner, progress_printer)
# define mapping from reader streams to network inputs
input_map = {
input_var: reader_train.streams.features,
label_var: reader_train.streams.labels
}
C.logging.log_number_of_parameters(z)
print()
# perform model training
for epoch in range(max_epochs): # loop over epochs
sample_count = 0
while sample_count < epoch_size: # loop over minibatches in the epoch
data = reader_train.next_minibatch(
min(minibatch_size, epoch_size - sample_count),
input_map=input_map) # fetch minibatch.
trainer.train_minibatch(data) # update model with it
sample_count += trainer.previous_minibatch_sample_count # count samples processed so far
trainer.summarize_training_progress()
# save model
modelname = "NIN_test1.dnn"
z.save(os.path.join(model_path, modelname))
### Evaluation action
epoch_size = 10000
minibatch_size = 16
# process minibatches and evaluate the model
metric_numer = 0
metric_denom = 0
sample_count = 0
minibatch_index = 0
while sample_count < epoch_size:
current_minibatch = min(minibatch_size, epoch_size - sample_count)
data = reader_test.next_minibatch(current_minibatch,
input_map=input_map)
metric_numer += trainer.test_minibatch(data) * current_minibatch
metric_denom += current_minibatch
sample_count += current_minibatch
minibatch_index += 1
print("")
print("Final Results: Minibatch[1-{}]: errs = {:0.2f}% * {}".format(
minibatch_index + 1, (metric_numer * 100.0) / metric_denom,
metric_denom))
print("")
return metric_numer / metric_denom