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)