def main(args):
# load up the mnist data set
dataset = MNIST(path=args.data_dir)
# initialize model object
mlp = Model(layers=[
Affine(nout=100,
init=Gaussian(loc=0.0, scale=0.01),
activation=Rectlin()),
Affine(nout=10,
init=Gaussian(loc=0.0, scale=0.01),
activation=Logistic(shortcut=True))
])
# setup optimizer
optimizer = GradientDescentMomentum(0.1,
momentum_coef=0.9,
stochastic_round=args.rounding)
# configure callbacks
callbacks = Callbacks(mlp,
eval_set=dataset.valid_iter,
**args.callback_args)
# run fit
# setup cost function as CrossEntropy
mlp.fit(dataset.train_iter,
optimizer=optimizer,
num_epochs=args.epochs,
cost=GeneralizedCost(costfunc=CrossEntropyBinary()),
callbacks=callbacks)
error_rate = mlp.eval(dataset.valid_iter, metric=Misclassification())
neon_logger.display('Classification accuracy = %.4f' % (1 - error_rate))
def run(train, test):
init = Gaussian(scale=0.01)
layers = [
Conv((3, 3, 128),
init=init,
activation=Rectlin(),
strides=dict(str_h=1, str_w=2)),
Conv((3, 3, 256), init=init, batch_norm=True, activation=Rectlin()),
Pooling(2, strides=2),
Conv((2, 2, 512), init=init, batch_norm=True, activation=Rectlin()),
DeepBiRNN(256,
init=init,
activation=Rectlin(),
reset_cells=True,
depth=3),
RecurrentLast(),
Affine(32, init=init, batch_norm=True, activation=Rectlin()),
Affine(nout=common['nclasses'], init=init, activation=Softmax())
]
model = Model(layers=layers)
opt = Adadelta()
metric = Misclassification()
callbacks = Callbacks(model,
eval_set=test,
metric=metric,
**args.callback_args)
cost = GeneralizedCost(costfunc=CrossEntropyBinary())
model.fit(train,
optimizer=opt,
num_epochs=args.epochs,
cost=cost,
callbacks=callbacks)
return model
def evaluate(model, val_iter, Metric):
running_error = np.zeros((len(Metric.metric_names)), dtype=np.float32)
nprocessed = 0
dataset = val_iter
dataset.reset()
if hasattr(dataset, 'seq_length'):
ndata = dataset.ndata * dataset.seq_length
else:
ndata = dataset.ndata
Metric = Misclassification()
N = 0
for x, t in dataset:
x = model.fprop(x, inference=True)
# This logic is for handling partial batch sizes at the end of the dataset
nsteps = x.shape[1] // model.be.bsz if not isinstance(x, list) else \
x[0].shape[1] // model.be.bsz
bsz = min(ndata - nprocessed, model.be.bsz)
tmp = float(running_error)
if not math.isnan(float(running_error)):
running_error += Metric(x, t, calcrange=slice(
0, nsteps * bsz)) * nsteps * bsz
nprocessed += bsz * nsteps
if not math.isnan(float(running_error)):
running_error /= nprocessed
if math.isnan(float(running_error)):
running_error = tmp
break
neon_logger.display('Misclassification error = %.1f%%' %
(running_error * 100))
def test_misclassification(backend_default):
NervanaObject.be.bsz = 3
outputs = np.array(
[[0.25, 0.99, 0.33], [0.5, 0.005, 0.32], [0.25, 0.005, 0.34]])
targets = np.array([[0, 1, 0], [1, 0, 1], [0, 0, 0]])
expected_result = np.ones((1, 1)) / 3.
compare_metric(Misclassification(),
outputs, targets, expected_result, tol=1e-7)
def train(self, dataset, model=None):
"""Trains the passed model on the given dataset. If no model is passed, `generate_default_model` is used."""
print "[%s] Starting training..." % self.model_name
start = time.time()
# The training will be run on the CPU. If a GPU is available it should be used instead.
backend = gen_backend(backend='cpu',
batch_size=self.batch_size,
rng_seed=self.random_seed,
stochastic_round=False)
cost = GeneralizedCost(
name='cost',
costfunc=CrossEntropyMulti())
optimizer = GradientDescentMomentum(
learning_rate=self.lrate,
momentum_coef=0.9)
# set up the model and experiment
if not model:
model = self.generate_default_model(dataset.num_labels)
args = NeonCallbackParameters()
args.output_file = os.path.join(self.root_path, self.Callback_Store_Filename)
args.evaluation_freq = 1
args.progress_bar = False
args.epochs = self.max_epochs
args.save_path = os.path.join(self.root_path, self.Intermediate_Model_Filename)
args.serialize = 1
args.history = 100
args.model_file = None
callbacks = Callbacks(model, dataset.train(), args, eval_set=dataset.test())
# add a callback that saves the best model state
callbacks.add_save_best_state_callback(self.model_path)
# Uncomment line below to run on GPU using cudanet backend
# backend = gen_backend(rng_seed=0, gpu='cudanet')
model.fit(
dataset.train(),
optimizer=optimizer,
num_epochs=self.max_epochs,
cost=cost,
callbacks=callbacks)
print("[%s] Misclassification error = %.1f%%"
% (self.model_name, model.eval(dataset.test(), metric=Misclassification()) * 100))
print "[%s] Finished training!" % self.model_name
end = time.time()
print "[%s] Duration in seconds", end - start
return model
def eval(self, test_set):
"""
Evaluate the model's test_set on error_rate, test_accuracy_rate and precision_recall_rate
Args:
test_set (ArrayIterator): The test set
Returns:
tuple(int): error_rate, test_accuracy_rate and precision_recall_rate
"""
error_rate = self.model.eval(test_set, metric=Misclassification())
test_accuracy_rate = self.model.eval(test_set, metric=Accuracy())
precision_recall_rate = self.model.eval(test_set,
metric=PrecisionRecall(2))
return error_rate, test_accuracy_rate, precision_recall_rate
def run(args, train, test):
init_uni = Uniform(low=-0.1, high=0.1)
opt_gdm = GradientDescentMomentum(learning_rate=0.01,
momentum_coef=0.9,
stochastic_round=args.rounding)
layers = [Conv((5, 5, 16), init=init_uni, activation=Rectlin(), batch_norm=True),
Pooling((2, 2)),
Conv((5, 5, 32), init=init_uni, activation=Rectlin(), batch_norm=True),
Pooling((2, 2)),
Affine(nout=500, init=init_uni, activation=Rectlin(), batch_norm=True),
Affine(nout=10, init=init_uni, activation=Softmax())]
cost = GeneralizedCost(costfunc=CrossEntropyMulti())
mlp = Model(layers=layers)
callbacks = Callbacks(mlp, eval_set=test, **args.callback_args)
mlp.fit(train, optimizer=opt_gdm, num_epochs=args.epochs, cost=cost, callbacks=callbacks)
err = mlp.eval(test, metric=Misclassification())*100
print('Misclassification error = %.2f%%' % err)
return err
# 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 neon.util.argparser import NeonArgparser
from neon.util.persist import load_obj
from neon.transforms import Misclassification
from neon.models import Model
from neon.data import ImageLoader
# parse the command line arguments (generates the backend)
parser = NeonArgparser(__doc__)
args = parser.parse_args()
# setup data provider
test_set = ImageLoader(set_name='validation',
repo_dir=args.data_dir,
inner_size=32,
scale_range=40,
do_transforms=False)
model = Model(load_obj(args.model_file))
print 'Accuracy: %.1f %% (Top-1)' % (
1.0 - model.eval(test_set, metric=Misclassification()) * 100)
Conv((1, 1, 16), **conv),
Pooling(8, op="avg"),
Activation(Softmax())
]
cost = GeneralizedCost(costfunc=CrossEntropyMulti())
mlp = Model(layers=layers)
# configure callbacks
callbacks = Callbacks(mlp)
def do_nothing(_):
pass
callbacks.callbacks = []
callbacks.on_train_begin = do_nothing
callbacks.on_epoch_end = do_nothing
mlp.fit(train_set,
optimizer=opt_gdm,
num_epochs=num_epochs,
cost=cost,
callbacks=callbacks)
opt_metric = 1.0 - mlp.eval(valid_set, metric=Misclassification())
print('Metric = {}'.format(opt_metric))
conn.experiments(experiment.id).observations().create(
suggestion=suggestion.id,
value=float(opt_metric[0]),
)
layers = [
Conv((4, 4, 32), init=init_norm, activation=Rectlin()),
Pooling((2, 2)),
Conv((3, 3, 16), init=init_norm, activation=Rectlin()),
Pooling((2, 2)),
Dropout(keep=0.8),
Affine(nout=128, init=init_norm, activation=Rectlin()),
Affine(nout=64, init=init_norm, activation=Rectlin()),
Affine(nout=10, init=init_norm, activation=Softmax())
]
mlp = Model(layers=layers)
cost = GeneralizedCost(costfunc=CrossEntropyBinary())
optimizer = GradientDescentMomentum(learning_rate=0.05,
momentum_coef=0.9,
wdecay=1e-5)
callbacks = Callbacks(mlp, eval_set=train_set, **args.callback_args)
start = time.time()
mlp.fit(train_set,
optimizer=optimizer,
num_epochs=10,
cost=cost,
callbacks=callbacks)
end = time.time()
print('Train time:', end - start, 'sec')
error_rate = mlp.eval(test_set, metric=Misclassification())
print('Error rate:', 100 * error_rate[0], '%')
lunaModel.load_params(args.model_file)
# configure callbacks
if args.callback_args['eval_freq'] is None:
args.callback_args['eval_freq'] = 1
# configure callbacks
callbacks = Callbacks(lunaModel, eval_set=valid_set, **args.callback_args)
# add a callback that saves the best model state
callbacks.add_save_best_state_callback(
'LUNA16_VGG_model_no_batch_sigmoid_pretrained.prm')
if args.deconv:
callbacks.add_deconv_callback(train_set, valid_set)
lunaModel.fit(train_set,
optimizer=opt,
num_epochs=num_epochs,
cost=cost,
callbacks=callbacks)
lunaModel.save_params('LUNA16_VGG_model_no_batch_sigmoid_pretrained.prm')
neon_logger.display(
'Calculating metrics on the test set. This could take a while...')
neon_logger.display('Misclassification error (test) = {:.2f}%'.format(
lunaModel.eval(test_set, metric=Misclassification())[0] * 100))
neon_logger.display('Precision/recall (test) = {}'.format(
lunaModel.eval(test_set, metric=PrecisionRecall(num_classes=2))))
common_params = dict(sampling_freq=22050, clip_duration=16000, frame_duration=16)
train_params = AudioParams(**common_params)
valid_params = AudioParams(**common_params)
common = dict(target_size=1, nclasses=10, repo_dir=args.data_dir)
train = DataLoader(set_name='music-train', media_params=train_params,
index_file=train_idx, shuffle=True, **common)
valid = DataLoader(set_name='music-valid', media_params=valid_params,
index_file=valid_idx, shuffle=False, **common)
init = Gaussian(scale=0.01)
layers = [Conv((2, 2, 4), init=init, activation=Rectlin(),
strides=dict(str_h=2, str_w=4)),
Pooling(2, strides=2),
Conv((3, 3, 4), init=init, batch_norm=True, activation=Rectlin(),
strides=dict(str_h=1, str_w=2)),
DeepBiRNN(128, init=GlorotUniform(), batch_norm=True, activation=Rectlin(),
reset_cells=True, depth=3),
RecurrentMean(),
Affine(nout=common['nclasses'], init=init, activation=Softmax())]
model = Model(layers=layers)
opt = Adagrad(learning_rate=0.01, gradient_clip_value=15)
metric = Misclassification()
callbacks = Callbacks(model, eval_set=valid, metric=metric, **args.callback_args)
cost = GeneralizedCost(costfunc=CrossEntropyMulti())
model.fit(train, optimizer=opt, num_epochs=args.epochs, cost=cost, callbacks=callbacks)
print('Misclassification error = %.1f%%' % (model.eval(valid, metric=metric)*100))
display(model, ['Convolution_0'], 'inputs')
display(model, ['Convolution_0', 'Convolution_1', 'Pooling_0'], 'outputs')
opt = MultiOptimizer({'default': opt_vgg, 'Bias': opt_bias,
'class_layer': opt_class_layer, 'class_layer_bias': opt_bias_class})
# use cross-entropy cost to train the network
cost = GeneralizedCost(costfunc=CrossEntropyMulti())
lunaModel = Model(layers=vgg_layers)
if args.model_file:
import os
assert os.path.exists(args.model_file), '%s not found' % args.model_file
lunaModel.load_params(args.model_file)
# configure callbacks
#callbacks = Callbacks(lunaModel, eval_set=valid_set, **args.callback_args)
callbacks = Callbacks(lunaModel, eval_set=valid_set, metric=Misclassification(), **args.callback_args)
if args.deconv:
callbacks.add_deconv_callback(train_set, valid_set)
lunaModel.fit(train_set, optimizer=opt, num_epochs=num_epochs,
cost=cost, callbacks=callbacks)
lunaModel.save_params('LUNA16_VGG_model.prm')
neon_logger.display('Finished training. Calculating error on the validation set...')
neon_logger.display('Misclassification error (validation) = {:.2f}%'.format(lunaModel.eval(valid_set, metric=Misclassification())[0] * 100))
neon_logger.display('Precision/recall (validation) = {}'.format(lunaModel.eval(valid_set, metric=PrecisionRecall(num_classes=2))))
neon_logger.display('Calculating metrics on the test set. This could take a while...')
def eval(self, valid_set):
eval_rate = self.model.eval(valid_set, metric=Misclassification())
return eval_rate
init=Gaussian(scale=0.01))
]
model = Model(layers=layers)
model.load_params('models/cifar10/cifar10vgg.pkl', load_states=False)
# define optimizer
opt_w = GradientDescentMomentum(learning_rate=0.01,
momentum_coef=0.9,
wdecay=0.0005)
opt_b = GradientDescentMomentum(learning_rate=0.01, momentum_coef=0.9)
opt = MultiOptimizer({'default': opt_w, 'Bias': opt_b}, name='multiopt')
# configure callbacks
callbacks = Callbacks(model,
eval_set=valid_set,
metric=Misclassification(),
**args.callback_args)
callbacks.add_callback(
TrainByStageCallback(model,
valid_set,
Misclassification(),
max_patience=10))
num_prune = [5, 10, 15, 15, 20, 20, 20, 20]
callbacks.add_callback(
FuzzyPruneCallback(num_states=100, num_prune=num_prune, model=model))
cost = GeneralizedCost(costfunc=CrossEntropyMulti())
logger.info('Training ...')
model.fit(train_set,
optimizer=opt,
num_epochs=250,
init=init_uni,
bias=init_cst,
padding=0,
activation=Rectlin()))
layers.append(Pooling(fshape=2, strides=2))
layers.append(Affine(nout=2, init=init_uni, activation=Softmax()))
from neon.models import Model
model = Model(layers)
from neon.layers import GeneralizedCost
from neon.transforms import CrossEntropyBinary
cost = GeneralizedCost(costfunc=CrossEntropyBinary())
from neon.optimizers import GradientDescentMomentum
optimizer = GradientDescentMomentum(0.1, momentum_coef=0.9)
from neon.callbacks.callbacks import Callbacks
callbacks = Callbacks(model, train_set)
model.fit(dataset=train_set,
cost=cost,
optimizer=optimizer,
num_epochs=10,
callbacks=callbacks)
from neon.transforms import Misclassification
error_pct = 100 * model.eval(test_set, metric=Misclassification())
accuracy_fp = 100 - error_pct
print 'Model Accuracy : %.1f%%' % accuracy_fp
def eval(self):
print('Misclassification error = %.1f%%' %
(self.model.eval(self.valid_set, metric=Misclassification()) *
100))
def test_model(model, s):
error = model.eval(s, metric=Misclassification()) * 100
return error
test = DataIterator(X_test, y_test, nclass=nclass)
init_uni = Uniform(low=-0.1, high=0.1)
opt_gdm = GradientDescentMomentum(learning_rate=0.01, momentum_coef=0.9)
# set up the model layers
layers = []
layers.append(Affine(nout=200, init=init_uni, activation=Rectlin()))
layers.append(
Affine(nout=10, init=init_uni, activation=Logistic(shortcut=True)))
cost = GeneralizedCost(costfunc=CrossEntropyBinary())
mlp = Model(layers=layers)
# configure callbacks
callbacks = Callbacks(mlp,
train,
output_file=args.output_file,
valid_set=test,
valid_freq=args.validation_freq,
progress_bar=args.progress_bar)
mlp.fit(train,
optimizer=opt_gdm,
num_epochs=num_epochs,
cost=cost,
callbacks=callbacks)
print mlp.eval(test, metric=Misclassification())
# setup model layers
layers = [
Affine(nout=100, init=init_norm, activation=Rectlin()),
Affine(nout=10, init=init_norm, activation=Logistic(shortcut=True))
]
# setup cost function as CrossEntropy
cost = GeneralizedCost(costfunc=CrossEntropyBinary())
# setup optimizer
optimizer = GradientDescentMomentum(0.1,
momentum_coef=0.9,
stochastic_round=args.rounding)
# initialize model object
mlp = Model(layers=layers)
# configure callbacks
callbacks = Callbacks(mlp, train_set, eval_set=valid_set, **args.callback_args)
# run fit
mlp.fit(train_set,
optimizer=optimizer,
num_epochs=args.epochs,
cost=cost,
callbacks=callbacks)
print('Misclassification error = %.1f%%' %
(mlp.eval(valid_set, metric=Misclassification()) * 100))
bias=init,
activation=Softmax(),
name="AffOut"))
layers = Seq2Seq([encoder, decoder],
decoder_connections=decoder_connections,
name="Seq2Seq")
cost = GeneralizedCost(costfunc=CrossEntropyMulti(usebits=True))
model = Model(layers=layers)
optimizer = RMSProp(gradient_clip_value=gradient_clip_value,
stochastic_round=args.rounding)
callbacks = Callbacks(model, eval_set=valid_set, **args.callback_args)
# train model
model.fit(train_set,
optimizer=optimizer,
num_epochs=args.epochs,
cost=cost,
callbacks=callbacks)
# Misclassification rate on validation set
error_rate = model.eval(valid_set, metric=Misclassification(steps=time_steps))
neon_logger.display('Misclassification error = %.2f%%' % (error_rate * 100))
# Print some example predictions.
prediction, groundtruth = get_predictions(model, valid_set, time_steps)
# convert them into text and display
display_text(valid_set.index_to_token, groundtruth, prediction)
opt = MultiOptimizer({'default': opt_vgg, 'Bias': opt_bias,
'class_layer': opt_class_layer, 'class_layer_bias': opt_bias_class})
# use cross-entropy cost to train the network
cost = GeneralizedCost(costfunc=CrossEntropyMulti())
lunaModel = Model(layers=vgg_layers)
if args.model_file:
import os
assert os.path.exists(args.model_file), '%s not found' % args.model_file
lunaModel.load_params(args.model_file)
# configure callbacks
#callbacks = Callbacks(lunaModel, eval_set=valid_set, **args.callback_args)
callbacks = Callbacks(lunaModel, eval_set=valid_set, metric=Misclassification(), **args.callback_args)
if args.deconv:
callbacks.add_deconv_callback(train_set, valid_set)
lunaModel.fit(train_set, optimizer=opt, num_epochs=num_epochs,
cost=cost, callbacks=callbacks)
lunaModel.save_params('LUNA16_VGG_model_no_batch.prm')
# neon_logger.display('Finished training. Calculating error on the validation set...')
# neon_logger.display('Misclassification error (validation) = {:.2f}%'.format(lunaModel.eval(valid_set, metric=Misclassification())[0] * 100))
# neon_logger.display('Precision/recall (validation) = {}'.format(lunaModel.eval(valid_set, metric=PrecisionRecall(num_classes=2))))
# neon_logger.display('Calculating metrics on the test set. This could take a while...')
stochastic_round=args.rounding)
bn = True
layers = [
Conv((5, 5, 16), init=init_uni, activation=Rectlin(), batch_norm=bn),
Pooling((2, 2)),
Conv((5, 5, 32), init=init_uni, activation=Rectlin(), batch_norm=bn),
Pooling((2, 2)),
Affine(nout=500, init=init_uni, activation=Rectlin(), batch_norm=bn),
Affine(nout=10, init=init_uni, activation=Softmax())
]
if args.datatype in [np.float32, np.float64]:
cost = GeneralizedCost(costfunc=CrossEntropyMulti())
elif args.datatype in [np.float16]:
cost = GeneralizedCost(costfunc=CrossEntropyMulti(scale=cost_scale))
model = Model(layers=layers)
# configure callbacks
callbacks = Callbacks(model, eval_set=test, **args.callback_args)
model.fit(train,
optimizer=opt_gdm,
num_epochs=num_epochs,
cost=cost,
callbacks=callbacks)
error_rate = model.eval(test, metric=Misclassification())
neon_logger.display('Misclassification error = %.1f%%' % (error_rate * 100))
def ShiftAdaMax_with_Scale(LR=1):
return ShiftAdaMax(learning_rate=LR_start * LR,
schedule=ShiftSchedule(2, shift_size=1))
optimizer = MultiOptimizer({
'default': ShiftAdaMax_with_Scale(),
'BinaryLinear_0': ShiftAdaMax_with_Scale(57.038),
'BinaryLinear_1': ShiftAdaMax_with_Scale(73.9008),
'BinaryLinear_2': ShiftAdaMax_with_Scale(73.9008),
'BinaryLinear_3': ShiftAdaMax_with_Scale(52.3195)
})
# initialize model object
bnn = Model(layers=layers)
# configure callbacks
callbacks = Callbacks(bnn, eval_set=val_set, **args.callback_args)
# run fit
bnn.fit(train_set,
optimizer=optimizer,
num_epochs=args.epochs,
cost=cost,
callbacks=callbacks)
print('Misclassification error = %.1f%%' %
(bnn.eval(val_set, metric=Misclassification()) * 100))
bnn.save_params("bin_model/final_model.prm")
cost = GeneralizedCost(costfunc=CrossEntropyMulti())
model.initialize(train_set, cost)
model.load_params('models/mnist/mnist_cnn.pkl', load_states=False)
# define optimizer
opt_w = GradientDescentMomentum(learning_rate=0.01,
momentum_coef=0.9,
wdecay=0.0005)
opt_b = GradientDescentMomentum(learning_rate=0.01, momentum_coef=0.9)
opt = MultiOptimizer({'default': opt_w, 'Bias': opt_b}, name='multiopt')
# configure callbacks
callbacks = Callbacks(model,
eval_set=valid_set,
metric=Misclassification(),
**args.callback_args)
callbacks.add_callback(
TrainByStageCallback(model, valid_set, Misclassification(),
max_patience=5))
num_prune = [5, 10, 25, 10]
callbacks.add_callback(
FuzzyPruneCallback(num_states=100, num_prune=num_prune, model=model))
print('Original Accuracy = %.2f%%' %
(100. - model.eval(valid_set, metric=Misclassification()) * 100))
logger.info('Training ...')
model.fit(train_set,
optimizer=opt,
num_epochs=250,
cost = GeneralizedCost(costfunc=CrossEntropyBinary())
# setup optimizer
optimizer = GradientDescentMomentum(0.1,
momentum_coef=0.9,
stochastic_round=args.rounding)
# initialize model object
mlp = Model(layers=layers)
path = "./best_state_" + str(i) + ".prm"
# configure callbacks
callbacks = Callbacks(mlp, train_set, eval_set=valid_set, **args.callback_args)
# add a callback that saves the best model state
callbacks.add_save_best_state_callback(path)
# print "epocs", args.epochs
# run fit
mlp.fit(train_set,
optimizer=optimizer,
num_epochs=15,
cost=cost,
callbacks=callbacks)
result_float = (mlp.eval(valid_set, metric=Misclassification())) * 100
result_string = '%.1f%%' % result_float
print(result_string[:-1])
# print('Misclassification error = %.1f%%' % r)
(X_train, y_train), (X_test, y_test), nclass = load_cifar10(path=args.data_dir)
train = ArrayIterator(X_train, y_train, nclass=nclass, lshape=(3, 32, 32))
test = ArrayIterator(X_test, y_test, nclass=nclass, lshape=(3, 32, 32))
init_uni = Uniform(low=-0.1, high=0.1)
opt_gdm = GradientDescentMomentum(learning_rate=0.01, momentum_coef=0.9)
# set up the model layers
layers = [
Affine(nout=200, init=init_uni, activation=Rectlin()),
Affine(nout=10, init=init_uni, activation=Logistic(shortcut=True))
]
cost = GeneralizedCost(costfunc=CrossEntropyBinary())
mlp = Model(layers=layers)
# configure callbacks
callbacks = Callbacks(mlp, eval_set=test, **args.callback_args)
mlp.fit(train,
optimizer=opt_gdm,
num_epochs=args.epochs,
cost=cost,
callbacks=callbacks)
print('Misclassification error = %.1f%%' %
(mlp.eval(test, metric=Misclassification()) * 100))
def benchmark(self):
for d in self.devices:
b = d if (self.backends is None) or (
"mkl" not in self.backends) else "mkl"
print("Use {} as backend.".format(b))
# Common suffix
suffix = "neon_{}_{}_{}by{}_{}".format(b, self.dataset,
self.resize_size[0],
self.resize_size[1],
self.preprocessing)
# Set up backend
# backend: 'cpu' for single cpu, 'mkl' for cpu using mkl library, and 'gpu' for gpu
be = gen_backend(backend=b,
batch_size=self.batch_size,
rng_seed=542,
datatype=np.float32)
# Prepare training/validation/testing sets
neon_train_set = ArrayIterator(X=np.asarray(
[t.flatten().astype('float32') / 255 for t in self.x_train]),
y=np.asarray(self.y_train),
make_onehot=True,
nclass=self.class_num,
lshape=(3, self.resize_size[0],
self.resize_size[1]))
neon_valid_set = ArrayIterator(X=np.asarray(
[t.flatten().astype('float32') / 255 for t in self.x_valid]),
y=np.asarray(self.y_valid),
make_onehot=True,
nclass=self.class_num,
lshape=(3, self.resize_size[0],
self.resize_size[1]))
neon_test_set = ArrayIterator(X=np.asarray([
t.flatten().astype('float32') / 255 for t in self.testImages
]),
y=np.asarray(self.testLabels),
make_onehot=True,
nclass=self.class_num,
lshape=(3, self.resize_size[0],
self.resize_size[1]))
# Initialize model object
self.neon_model = SelfModel(layers=self.constructCNN())
# Costs
neon_cost = GeneralizedCost(costfunc=CrossEntropyMulti())
# Model summary
self.neon_model.initialize(neon_train_set, neon_cost)
print(self.neon_model)
# Learning rules
neon_optimizer = SGD(0.01,
momentum_coef=0.9,
schedule=ExpSchedule(0.2))
# neon_optimizer = RMSProp(learning_rate=0.0001, decay_rate=0.95)
# # Benchmark for 20 minibatches
# d[b] = self.neon_model.benchmark(neon_train_set, cost=neon_cost, optimizer=neon_optimizer)
# Reset model
# self.neon_model = None
# self.neon_model = Model(layers=layers)
# self.neon_model.initialize(neon_train_set, neon_cost)
# Callbacks: validate on validation set
callbacks = Callbacks(
self.neon_model,
eval_set=neon_valid_set,
metric=Misclassification(3),
output_file="./saved_data/{}/{}/callback_data_{}.h5".format(
self.network_type, d, suffix))
callbacks.add_callback(
SelfCallback(eval_set=neon_valid_set,
test_set=neon_test_set,
epoch_freq=1))
# Fit
start = time.time()
self.neon_model.fit(neon_train_set,
optimizer=neon_optimizer,
num_epochs=self.epoch_num,
cost=neon_cost,
callbacks=callbacks)
print("Neon training finishes in {:.2f} seconds.".format(
time.time() - start))
# Result
# results = self.neon_model.get_outputs(neon_valid_set)
# Print error on validation set
start = time.time()
neon_error_mis = self.neon_model.eval(
neon_valid_set, metric=Misclassification()) * 100
print(
'Misclassification error = {:.1f}%. Finished in {:.2f} seconds.'
.format(neon_error_mis[0],
time.time() - start))
# start = time.time()
# neon_error_top3 = self.neon_model.eval(neon_valid_set, metric=TopKMisclassification(3))*100
# print('Top 3 Misclassification error = {:.1f}%. Finished in {:.2f} seconds.'.format(neon_error_top3[2], time.time() - start))
# start = time.time()
# neon_error_top5 = self.neon_model.eval(neon_valid_set, metric=TopKMisclassification(5))*100
# print('Top 5 Misclassification error = {:.1f}%. Finished in {:.2f} seconds.'.format(neon_error_top5[2], time.time() - start))
self.neon_model.save_params("./saved_models/{}/{}/{}.prm".format(
self.network_type, d, suffix))
# Print error on test set
start = time.time()
neon_error_mis_t = self.neon_model.eval(
neon_test_set, metric=Misclassification()) * 100
print(
'Misclassification error = {:.1f}% on test set. Finished in {:.2f} seconds.'
.format(neon_error_mis_t[0],
time.time() - start))
# start = time.time()
# neon_error_top3_t = self.neon_model.eval(neon_test_set, metric=TopKMisclassification(3))*100
# print('Top 3 Misclassification error = {:.1f}% on test set. Finished in {:.2f} seconds.'.format(neon_error_top3_t[2], time.time() - start))
# start = time.time()
# neon_error_top5_t = self.neon_model.eval(neon_test_set, metric=TopKMisclassification(5))*100
# print('Top 5 Misclassification error = {:.1f}% on test set. Finished in {:.2f} seconds.'.format(neon_error_top5_t[2], time.time() - start))
cleanup_backend()
self.neon_model = None
Affine(nout=16, linear_name="b1_l1", **normrelu),
Affine(nout=10, linear_name="b1_l2", **normsigm)]
p3 = [b2,
Affine(nout=16, linear_name="b2_l1", **normrelu),
Affine(nout=10, linear_name="b2_l2", **normsigm)]
# setup cost function as CrossEntropy
cost = Multicost(costs=[GeneralizedCost(costfunc=CrossEntropyMulti()),
GeneralizedCost(costfunc=CrossEntropyBinary()),
GeneralizedCost(costfunc=CrossEntropyBinary())],
weights=[1, 0., 0.])
# setup optimizer
optimizer = GradientDescentMomentum(0.1, momentum_coef=0.9, stochastic_round=args.rounding)
# initialize model object
alphas = [1, 0.25, 0.25]
mlp = Model(layers=Tree([p1, p2, p3], alphas=alphas))
# setup standard fit callbacks
callbacks = Callbacks(mlp, train_set, eval_set=valid_set, **args.callback_args)
# run fit
mlp.fit(train_set, optimizer=optimizer, num_epochs=args.epochs, cost=cost, callbacks=callbacks)
logging.getLogger('neon').info("Misclassification error = %.1f%%",
(mlp.eval(valid_set, metric=Misclassification())*100))
print('Misclassification error = %.1f%%' % (mlp.eval(valid_set, metric=Misclassification())*100))
from neon.optimizers import GradientDescentMomentum
optimizer = GradientDescentMomentum(0.1, momentum_coef=0.9)
#callbacks show the progress of calculations
from neon.callbacks.callbacks import Callbacks
callbacks = Callbacks(mlp, eval_set=test_set, **args.callback_args)
#train the model
mlp.fit(train_set,
optimizer=optimizer,
num_epochs=10,
cost=cost,
callbacks=callbacks)
#The variable results is a numpy array with
#shape (num_test_examples, num_outputs) = (10000,10) with the model probabilities for each label.
results = mlp.get_outputs(test_set)
print "labels: %s, %s, %s: " % (y_test[2], y_test[5], y_test[100])
#ind1, val1 = max(results[2].tolist())
#ind2, val2 = max(results[5].tolist())
#ind3, val3 = max(results[100].tolist())
print "results: %s, %s, %s:" % (results[2].tolist(), results[5].tolist(),
results[100].tolist())
from neon.transforms import Misclassification
# evaluate the model on test_set using the misclassification metric
error = mlp.eval(test_set, metric=Misclassification()) * 100
print('Misclassification error = %.1f%%' % error)