def test_iterator(): parser = NeonArgparser(__doc__) args = parser.parse_args() (X_train, y_train), (X_test, y_test), nclass = load_cifar10_imgs(path=args.data_dir) train = DataIterator(X_train, y_train, nclass=nclass, lshape=(3, 32, 32)) test = DataIterator(X_test, y_test, nclass=nclass, lshape=(3, 32, 32)) return run(args, train, test)
def test_iterator(): print('Testing iterator based data loader') parser = NeonArgparser(__doc__) args = parser.parse_args() (X_train, y_train), (X_test, y_test), nclass = load_cifar10_imgs(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)) return run(args, train, test)
def get_data(): """ Download bilingual text dataset for Machine translation example. """ # vocab_size and time_steps are hard coded here vocab_size = 16384 time_steps = 20 # download dataset url = 'http://www-lium.univ-lemans.fr/~schwenk/cslm_joint_paper/data/' filename = 'bitexts.tgz' size = 1313280000 parser = NeonArgparser(__doc__) args = parser.parse_args(gen_be=False) data_dir = os.path.join(args.data_dir, 'nmt') _, filepath = Dataset._valid_path_append(data_dir, '', filename) if not os.path.exists(filepath): Dataset.fetch_dataset(url, filename, filepath, size) # extract selected datasets datafiles = dict() datafiles['un2000'] = ('un2000_pc34.en.gz', 'un2000_pc34.fr.gz') datafiles['europarl7'] = ('ep7_pc45.en.gz', 'ep7_pc45.fr.gz') extractpath = os.path.join(data_dir, 'bitexts.selected') with tarfile.open(filepath, 'r') as tar_ref: for dset, files in datafiles.items(): datasetpath = os.path.join(data_dir, dset) # extract the files for dataset, if not already there for zipped in files: fname = '.'.join(zipped.split('.')[:-1]) fpath = os.path.join(datasetpath, fname) if not os.path.exists(fpath): gzpath = os.path.join(extractpath, zipped) if not os.path.exists(gzpath): select = [ti for ti in tar_ref if os.path.split(ti.name)[1] == zipped] tar_ref.extractall(path=data_dir, members=select) # get contents of gz files if not os.path.exists(datasetpath): os.makedirs(datasetpath) with gzip.open(gzpath, 'r') as fin, open(fpath, 'w') as fout: fout.write(fin.read()) os.remove(gzpath) if os.path.exists(extractpath): os.rmdir(extractpath) # process data and save to h5 file # loop through all datasets and get train and valid splits for dataset in datafiles.keys(): s_vocab, t_vocab = create_h5py(data_dir, dataset, 'train', vocab_size=vocab_size, time_steps=time_steps) create_h5py(data_dir, dataset, 'valid', s_vocab=s_vocab, t_vocab=t_vocab, time_steps=time_steps)
def test_loader(): parser = NeonArgparser(__doc__) args = parser.parse_args() train_dir = os.path.join(args.data_dir, 'macrotrain') test_dir = os.path.join(args.data_dir, 'macrotest') write_batches(args, train_dir, trainimgs, 0) write_batches(args, test_dir, testimgs, 1) train = ImageLoader(set_name='train', do_transforms=False, inner_size=32, repo_dir=train_dir) test = ImageLoader(set_name='validation', do_transforms=False, inner_size=32, repo_dir=test_dir) err = run(args, train, test) return err
def main(): # parse the command line arguments parser = NeonArgparser(__doc__) args = parser.parse_args() logger = logging.getLogger() logger.setLevel(args.log_thresh) #Set up batch iterator for training images print "Setting up data batch loaders..." train = ImgMaster(repo_dir='dataTmp', set_name='train', inner_size=120, subset_pct=100) val = ImgMaster(repo_dir='dataTmp', set_name='train', inner_size=120, subset_pct=100, do_transforms=False) test = ImgMaster(repo_dir='dataTestTmp', set_name='train', inner_size=120, subset_pct=100, do_transforms=False) train.init_batch_provider() val.init_batch_provider() test.init_batch_provider() print "Constructing network..." #Create AlexNet architecture model = constuct_network() #model.load_weights(args.model_file) # drop weights LR by 1/250**(1/3) at epochs (23, 45, 66), drop bias LR by 1/10 at epoch 45 weight_sched = Schedule([22, 44, 65, 90, 97], (1/250.)**(1/3.)) opt_gdm = GradientDescentMomentum(0.01, 0.9, wdecay=0.005, schedule=weight_sched) opt_biases = GradientDescentMomentum(0.04, 1.0, schedule=Schedule([130],.1)) opt = MultiOptimizer({'default': opt_gdm, 'Bias': opt_biases}) # configure callbacks valmetric = TopKMisclassification(k=5) callbacks = Callbacks(model, train, eval_set=val, metric=valmetric, **args.callback_args) cost = GeneralizedCost(costfunc=CrossEntropyMulti()) #flag = input("Press Enter if you want to begin training process.") print "Training network..." model.fit(train, optimizer=opt, num_epochs=args.epochs, cost=cost, callbacks=callbacks) mets = model.eval(test, metric=valmetric) print 'Validation set metrics:' print 'LogLoss: %.2f, Accuracy: %.1f %%0 (Top-1), %.1f %% (Top-5)' % (mets[0], (1.0-mets[1])*100, (1.0-mets[2])*100) test.exit_batch_provider() val.exit_batch_provider() train.exit_batch_provider()
def main(): # parse the command line arguments parser = NeonArgparser(__doc__) args = parser.parse_args() logger = logging.getLogger() logger.setLevel(args.log_thresh) # Set up batch iterator for training images train = ImgMaster(repo_dir="spectroDataTmp", set_name="train", inner_size=400, subset_pct=100) val = ImgMaster( repo_dir="spectroDataTmp", set_name="validation", inner_size=400, subset_pct=100, do_transforms=False ) test = ImgMaster( repo_dir="spectroTestDataTmp", set_name="validation", inner_size=400, subset_pct=100, do_transforms=False ) train.init_batch_provider() test.init_batch_provider() print "Constructing network..." model = constuct_network() model.load_weights(args.model_file) # Optimizer opt = Adadelta() # configure callbacks valmetric = TopKMisclassification(k=5) callbacks = Callbacks(model, train, eval_set=val, metric=valmetric, **args.callback_args) cost = GeneralizedCost(costfunc=CrossEntropyMulti()) # flag = input("Press Enter if you want to begin training process.") print "Training network..." print args.epochs model.fit(train, optimizer=opt, num_epochs=args.epochs, cost=cost, callbacks=callbacks) mets = model.eval(test, metric=valmetric) print "Validation set metrics:" print "LogLoss: %.2f, Accuracy: %.1f %%0 (Top-1), %.1f %% (Top-5)" % ( mets[0], (1.0 - mets[1]) * 100, (1.0 - mets[2]) * 100, ) test.exit_batch_provider() train.exit_batch_provider()
def test_loader(): print('Testing image loader') parser = NeonArgparser(__doc__) args = parser.parse_args() train_archive = os.path.join(args.data_dir, traindir + '-ingested') test_archive = os.path.join(args.data_dir, testdir + '-ingested') write_batches(args, train_archive, traindir, 0) write_batches(args, test_archive, testdir, 1) train = ImageLoader(set_name='train', do_transforms=False, inner_size=32, scale_range=0, repo_dir=train_archive) test = ImageLoader(set_name='validation', do_transforms=False, inner_size=32, scale_range=0, repo_dir=test_archive) err = run(args, train, test) return err
def test_loader(): print('Testing generic data loader') parser = NeonArgparser(__doc__) args = parser.parse_args() train_path = os.path.join(args.data_dir, traindir + '-ingested') test_path = os.path.join(args.data_dir, testdir + '-ingested') params = ImageParams(channel_count=3, height=32, width=32) common = dict(media_params=params, target_size=1, nclasses=10) train = DataLoader('train', repo_dir=os.path.join(args.data_dir, 'train'), **common) test = DataLoader('test', repo_dir=os.path.join(args.data_dir, 'test'), **common) err = run(args, train, test) return err
def get_args_and_hyperparameters(): parser = NeonArgparser(__doc__) args = parser.parse_args(gen_be=False) # Override save path if None if args.save_path is None: args.save_path = 'frcn_alexnet.pickle' if args.callback_args['save_path'] is None: args.callback_args['save_path'] = args.save_path if args.callback_args['serialize'] is None: args.callback_args['serialize'] = min(args.epochs, 10) # hyperparameters args.batch_size = 64 hyper_params = lambda: None hyper_params.use_pre_trained_weights = True # If true, load pre-trained weights to the model hyper_params.max_train_imgs = 5000 # Make this smaller in small trial runs to save time hyper_params.max_test_imgs = 5000 # Make this smaller in small trial runs to save time hyper_params.num_epochs = args.epochs hyper_params.samples_per_batch = args.batch_size # The mini-batch size # The number of multi-scale samples to make for each input image. These # samples are then fed into the network in multiple minibatches. hyper_params.samples_per_img = hyper_params.samples_per_batch*7 hyper_params.frcn_fine_tune = False hyper_params.shuffle = True if hyper_params.use_pre_trained_weights: # This will typically train in 10-15 epochs. Use a small learning rate # and quickly reduce every 5-10 epochs. Use a high momentum since we # are close to the minima. s = 1e-4 hyper_params.learning_rate_scale = s hyper_params.learning_rate_sched = Schedule(step_config=[15, 20], change=[0.1*s, 0.01*s]) hyper_params.momentum = 0.9 else: # need to be less aggressive with reducing learning rate if the model is not pre-trained s = 1e-2 hyper_params.learning_rate_scale = 1e-2 hyper_params.learning_rate_sched = Schedule(step_config=[8, 14, 18, 20], change=[0.5*s, 0.1*s, 0.05*s, 0.01*s]) hyper_params.momentum = 0.1 hyper_params.class_score_threshold = 0.000001 hyper_params.score_exponent = 5 hyper_params.shuffle = True return args, hyper_params
def run_once(web_input): """ Run forward pass for a single input. Receives input vector from the web form. """ parser = NeonArgparser(__doc__) args = parser.parse_args() num_feat = 4 npzfile = np.load('./model/homeapp_preproc.npz') mean = npzfile['mean'] std = npzfile['std'] mean = np.reshape(mean, (1,mean.shape[0])) std = np.reshape(std, (1,std.shape[0])) # Reloading saved model mlp=Model("./model/homeapp_model.prm") # Horrible terrible hack that should never be needed :-( NervanaObject.be.bsz = 1 # Actual: 275,000 Predicted: 362,177 #web_input = np.array([51.2246169879,-1.48577399748,223.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,1.0]) # Actual 185,000 Predicted: 244,526 #web_input = np.array([51.4395375168,-1.07174234072,5.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0,0.0,1.0]) # Actual 231,500 Predicted 281,053 web_input = np.array([52.2010084131,-2.18181259148,218.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,0.0,1.0]) web_input = np.reshape(web_input, (1,web_input.shape[0])) web_input[:,:num_feat-1] -= mean[:,1:num_feat] web_input[:,:num_feat-1] /= std[:,1:num_feat] web_test_set = ArrayIterator(X=web_input, make_onehot=False) web_output = mlp.get_outputs(web_test_set) #Rescale the output web_output *= std[:,0] web_output += mean[:,0] return web_output[0]
def main(): # parse the command line arguments parser = NeonArgparser(__doc__) args = parser.parse_args() logger = logging.getLogger() logger.setLevel(args.log_thresh) #Set up batch iterator for training images train = ImgMaster(repo_dir='dataTmp_optFlow_BW', set_name='train', inner_size=240, subset_pct=100) val = ImgMaster(repo_dir='dataTmp_optFlow_BW', set_name='train', inner_size=240, subset_pct=100, do_transforms=False) test = ImgMaster(repo_dir='dataTestTmp_optFlow_BW', set_name='train', inner_size=240, subset_pct=100, do_transforms=False) train.init_batch_provider() val.init_batch_provider() test.init_batch_provider() print "Constructing network..." #Create AlexNet architecture model = constuct_network() # Optimzer for model opt = Adadelta() # configure callbacks valmetric = TopKMisclassification(k=5) callbacks = Callbacks(model, train, eval_set=test, metric=valmetric, **args.callback_args) cost = GeneralizedCost(costfunc=CrossEntropyMulti()) #flag = input("Press Enter if you want to begin training process.") print "Training network..." model.fit(train, optimizer=opt, num_epochs=args.epochs, cost=cost, callbacks=callbacks) mets = model.eval(test, metric=valmetric) print 'Validation set metrics:' print 'LogLoss: %.2f, Accuracy: %.1f %%0 (Top-1), %.1f %% (Top-5)' % (mets[0], (1.0-mets[1])*100, (1.0-mets[2])*100) return
from neon.util.argparser import NeonArgparser, extract_valid_args from neon.optimizers import GradientDescentMomentum, MultiOptimizer, StepSchedule from neon.callbacks.callbacks import Callbacks from neon.util.persist import save_obj, get_data_cache_dir from objectlocalization import PASCALVOC from neon.transforms import CrossEntropyMulti, SmoothL1Loss from neon.layers import Multicost, GeneralizedCostMask import util import faster_rcnn import os train_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'pascalvoc.cfg') config_files = [train_config] if os.path.exists(train_config) else [] # parse the command line arguments parser = NeonArgparser(__doc__, default_config_files=config_files) parser.add_argument('--width', type=int, default=1000, help='Width of input image') parser.add_argument('--height', type=int, default=1000, help='Height of input image') parser.add_argument('--subset_pct', type=float, default=100, help='subset of training dataset to use (percentage)') args = parser.parse_args(gen_be=False) # hyperparameters assert args.batch_size is 1, "Faster-RCNN only supports batch size 1" assert 'train' in args.manifest rpn_rois_per_img = 256 # number of rois to sample to train rpn frcn_rois_per_img = 128 # number of rois to sample to train frcn # setup backend be = gen_backend(**extract_valid_args(args, gen_backend))
self.y_dev.set(y_batch) self.batch_index += 1 yield self.X_dev, self.y_dev # replicate neon's mse error metric def err(y, t): feature_axis = 1 return (0.5 * np.square(y - t).mean(axis=feature_axis).mean()) if __name__ == '__main__': # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('--curvetype', default='Lissajous1', choices=['Lissajous1', 'Lissajous2'], help='type of input curve data to use (Lissajous1 or Lissajous2)') args = parser.parse_args(gen_be=False) # network hyperparameters hidden = 32 args.batch_size = 1 # The following flag will switch between 2 training strategies: # 1. return_sequence True: # Inputs are sequences, and target outputs will be sequences. # The RNN layer's output at EVERY step will be used for errors and optimized. # The RNN model contains a RNN layer and an Affine layer # The data iterator will format the data accordingly, and will stride along the # whole series with no overlap
Referece: https://github.com/karpathy/neuraltalk """ from neon.backends import gen_backend from neon.data import load_flickr8k, ImageCaption, ImageCaptionTest from neon.initializers import Uniform, Constant from neon.layers import GeneralizedCostMask, LSTM, Affine, Dropout, Sequential, MergeMultistream from neon.models import Model from neon.optimizers import RMSProp from neon.transforms import Logistic, Tanh, Softmax, CrossEntropyMulti from neon.callbacks.callbacks import Callbacks from neon.util.argparser import NeonArgparser, extract_valid_args # parse the command line arguments parser = NeonArgparser(__doc__) args = parser.parse_args(gen_be=False) # hyperparameters hidden_size = 512 num_epochs = args.epochs # setup backend be = gen_backend(**extract_valid_args(args, gen_backend)) # download dataset data_path = load_flickr8k(path=args.data_dir) # Other setnames are flickr30k and coco # load data train_set = ImageCaption(path=data_path, max_images=-1)
# NB: It is good practice to set your data_dir where your batches are stored # to be local to your machine (to avoid accessing the macrobatches over network if, # for example, your data_dir is in an NFS mounted location) from neon.util.argparser import NeonArgparser from neon.initializers import Kaiming, IdentityInit from neon.layers import Conv, Pooling, GeneralizedCost, Activation, Affine from neon.layers import MergeSum, SkipNode from neon.optimizers import GradientDescentMomentum, Schedule from neon.transforms import Rectlin, Softmax, CrossEntropyMulti, Misclassification from neon.models import Model from neon.data import ImageLoader from neon.callbacks.callbacks import Callbacks # parse the command line arguments (generates the backend) parser = NeonArgparser(__doc__) parser.add_argument('--network', default='plain', choices=['plain', 'resnet'], help='type of network to create (plain or resnet)') parser.add_argument('--depth', type=int, default=9, help='depth of each stage (network depth will be 6n+2)') parser.add_argument('--subset_pct', type=float, default=100, help='subset of training dataset to use (percentage)') args = parser.parse_args() # setup data provider
""" from __future__ import division from neon.backends import gen_backend from neon.util.argparser import NeonArgparser, extract_valid_args from neon.optimizers import GradientDescentMomentum, MultiOptimizer, StepSchedule from neon.callbacks.callbacks import Callbacks, TrainMulticostCallback from neon.util.persist import save_obj from objectlocalization import PASCAL from neon.transforms import CrossEntropyMulti, SmoothL1Loss from neon.layers import Multicost, GeneralizedCostMask import util # parse the command line arguments parser = NeonArgparser(__doc__, default_overrides={'batch_size': 1}) parser.add_argument('--subset_pct', type=float, default=100, help='subset of training dataset to use (percentage)') args = parser.parse_args(gen_be=False) # hyperparameters assert args.batch_size is 1, "Faster-RCNN only supports batch size 1" n_mb = None rpn_rois_per_img = 256 # number of rois to sample to train rpn frcn_rois_per_img = 128 # number of rois to sample to train frcn # setup backend be = gen_backend(**extract_valid_args(args, gen_backend)) be.enable_winograd = 4 # default to winograd 4 for fast autotune
except ImportError as err: neon_logger.display("Running this example requires scipy packages.") neon_logger.display("try activating your virtualenv then: pip install scipy") sys.exit(1) from neon.models import Model from neon.layers import Activation from neon.data.datasets import Dataset from neon.layers import GeneralizedCost from neon.transforms.cost import Cost from neon.util.argparser import NeonArgparser # force use of CPU backend since we require a batch size of 1 # (GPU needs a multiple of 32) default_overrides = dict(backend='cpu', batch_size=1) parser = NeonArgparser(__doc__, default_overrides=default_overrides) parser.add_argument("image", help="Base image to create dream on.") parser.add_argument("--dream_file", default='dream_out.png', help="Save dream to named file.") args = parser.parse_args() # redirect the dream file to the path of output_file if args.output_file is None: output_dir = parser.work_dir elif osp.isdir(args.output_file): output_dir = args.output_file else: output_dir = osp.dirname(args.output_file) args.dream_file = osp.expanduser(
transverse, coronal, and sagittal 2D slices for the candidate positions. """ import SimpleITK as sitk import numpy as np import pandas as pd import os import ntpath from neon.util.argparser import NeonArgparser import logging # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument("--subset", default='subset9', help='LUNA16 subset directory to process') args = parser.parse_args() # To get the original LUNA16 MHD data: # wget https://www.dropbox.com/sh/mtip9dx6zt9nb3z/AAAs2wbJxbNM44-uafZyoMVca/subset5.zip # The files are 7-zipped. Regular linux unzip won't work to uncompress them. Use 7za instead. # 7za e subset5.zip DATA_DIR = '/mnt/data/medical/luna16/' SUBSET = args.subset cand_path = 'CSVFILES/candidates_with_annotations.csv' # Candidates file tells us the centers of the ROI for candidate nodules
def main(): # parse the command line arguments parser = NeonArgparser(__doc__) args = parser.parse_args() logger = logging.getLogger() logger.setLevel(args.log_thresh) #Set up batch iterator for training images train = ImgMaster(repo_dir='spectroDataTmp', set_name='train', inner_size=400, subset_pct=100) val = ImgMaster(repo_dir='spectroDataTmp', set_name='validation', inner_size=400, subset_pct=100, do_transforms=False) test = ImgMaster(repo_dir='spectroTestDataTmp', set_name='validation', inner_size=400, subset_pct=100, do_transforms=False) train.init_batch_provider() test.init_batch_provider() print "Constructing network..." model = constuct_network() model.load_weights(args.model_file) #Optimizer opt = Adadelta() # configure callbacks valmetric = TopKMisclassification(k=5) callbacks = Callbacks(model, train, eval_set=val, metric=valmetric, **args.callback_args) cost = GeneralizedCost(costfunc=CrossEntropyMulti()) #flag = input("Press Enter if you want to begin training process.") print "Training network..." print args.epochs model.fit(train, optimizer=opt, num_epochs=args.epochs, cost=cost, callbacks=callbacks) mets = model.eval(test, metric=valmetric) print 'Validation set metrics:' print 'LogLoss: %.2f, Accuracy: %.1f %%0 (Top-1), %.1f %% (Top-5)' % ( mets[0], (1.0 - mets[1]) * 100, (1.0 - mets[2]) * 100) test.exit_batch_provider() train.exit_batch_provider()
""" import numpy as np from neon.backends import gen_backend from neon.data import Text from neon.data import load_text from neon.initializers import Uniform from neon.layers import GeneralizedCost, LSTM, Affine from neon.models import Model from neon.optimizers import RMSProp from neon.transforms import Logistic, Tanh, Softmax, CrossEntropyMulti from neon.callbacks.callbacks import Callbacks from neon.util.argparser import NeonArgparser # parse the command line arguments parser = NeonArgparser(__doc__) args = parser.parse_args(gen_be=False) batch_size = 64 num_epochs = args.epochs # Override save path if None if args.save_path is None: args.save_path = 'rnn_text_gen.pickle' # hyperparameters time_steps = 64 hidden_size = 512 clip_gradients = True # setup backend
Usage: use -t to specify which bAbI task to run python examples/babi/train.py -e 20 --rlayer_type gru --save_path babi_lstm.p -t 1 """ from util import create_model, babi_handler from neon.backends import gen_backend from neon.data import QA from neon.layers import GeneralizedCost from neon.optimizers import Adam from neon.transforms import Accuracy, CrossEntropyMulti from neon.callbacks.callbacks import Callbacks from neon.util.argparser import NeonArgparser, extract_valid_args # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('-t', '--task', type=int, default='1', choices=xrange(1, 21), help='the task ID to train/test on from bAbI dataset (1-20)') parser.add_argument('--rlayer_type', default='gru', choices=['gru', 'lstm'], help='type of recurrent layer to use (gru or lstm)') args = parser.parse_args(gen_be=False) # Override save path if None if args.save_path is None: args.save_path = 'babi.p' if args.callback_args['save_path'] is None: args.callback_args['save_path'] = args.save_path # setup backend args.batch_size = 32
from neon import logger as neon_logger from neon.initializers import Gaussian, GlorotUniform from neon.optimizers import Adam, Adadelta from neon.layers import Conv, Dropout, Activation, Pooling, GeneralizedCost, Affine from neon.transforms import Rectlin, Softmax, Logistic, CrossEntropyMulti, CrossEntropyBinary, Misclassification, PrecisionRecall from neon.models import Model from aeon import DataLoader from neon.callbacks.callbacks import Callbacks from neon.util.argparser import NeonArgparser, extract_valid_args from neon.backends import gen_backend from neon.data.dataloader_transformers import BGRMeanSubtract, TypeCast, OneHot import numpy as np # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument("--learning_rate", default=0.05, help="initial learning rate") parser.add_argument("--weight_decay", default=0.001, help="weight decay") parser.add_argument('--deconv', action='store_true', help='save visualization data from deconvolution') args = parser.parse_args() # hyperparameters num_epochs = args.epochs # Next line gets rid of the deterministic warning args.deterministic = None
mlp_model.save(args.model_prm) # evaluation error_rate = mlp_model.eval(valid_set) logger.info('Mis-classification error on validation set= %.1f%%' % (error_rate * 100)) reslts = mlp_model.get_outputs(valid_set) return reslts # -------------------------------------------------------------------------------------# if __name__ == "__main__": # parse the command line arguments parser = NeonArgparser() parser.add_argument('--data_set_file', default='data/data_set.pkl', type=validate_existing_filepath, help='train and validation sets path') parser.add_argument('--model_prm', default='data/mcs_model.prm', type=validate_parent_exists, help='trained model full path') args = parser.parse_args() # generate backend, it is optional to change to backend='mkl' be = gen_backend(backend='cpu', batch_size=10) # read training and validation data file with open(args.data_set_file, 'rb') as fp: data_in = pickle.load(fp)
from neon import logger as neon_logger from neon.data import Shakespeare from neon.initializers import Uniform from neon.layers import GeneralizedCost, LSTM, Affine from neon.models import Model from neon.optimizers import RMSProp from neon.transforms import Logistic, Tanh, Softmax, CrossEntropyMulti from neon.callbacks.callbacks import Callbacks from neon.util.argparser import NeonArgparser # parse the command line arguments default_overrides = dict(save_path='rnn_text_gen.pickle', serialize=1, batch_size=64) parser = NeonArgparser(__doc__, default_overrides=default_overrides) args = parser.parse_args() # hyperparameters time_steps = 64 hidden_size = 512 gradient_clip_value = 5 # download shakespeare text dataset = Shakespeare(time_steps, path=args.data_dir) train_set = dataset.train_iter valid_set = dataset.valid_iter # weight initialization init = Uniform(low=-0.08, high=0.08)
file_name = os.path.join(image_dir, 'image_{}.jpg'.format(n)) img.save(file_name) n = n + 1 return (all_boxes, all_gt_boxes) if __name__ == '__main__': """ Simple example of using the dataloader with pre-generated augmentation data """ arg_defaults = {'batch_size': 0} parser = NeonArgparser(__doc__, default_overrides=arg_defaults) parser.add_argument('--ssd_config', action='append', required=True, help='ssd json file path') parser.add_argument('--height', type=int, help='image height') parser.add_argument('--width', type=int, help='image width') parser.add_argument('--num_images', type=int, default=0, help='number of images to plot') parser.add_argument('--image_dir', type=str, help='folder to save sampled images') parser.add_argument('--score_threshold', type=float, help='threshold for predicted scores.') parser.add_argument('--output', type=str, help='file to save detected boxes.') args = parser.parse_args(gen_be=False) if args.model_file is None: parser.print_usage() exit('You need to specify model file to evaluate.') if args.ssd_config: args.ssd_config = {k: v for k, v in [ss.split(':') for ss in args.ssd_config]}
Googlenet V1 implementation """ import os from neon.util.argparser import NeonArgparser from neon.layers import Conv, Pooling, MergeBroadcast, BranchNode, Affine, Tree, Dropout from neon.layers import GeneralizedCost, Multicost from neon.initializers import Constant, Xavier from neon.backends import gen_backend from neon.optimizers import GradientDescentMomentum, MultiOptimizer from neon.transforms import Rectlin, Softmax, CrossEntropyMulti, TopKMisclassification from neon.models import Model from neon.data import ImageLoader parser = NeonArgparser(__doc__) parser.add_argument('--subset_pct', type=float, default=100, help='subset of training dataset to use (percentage)') parser.add_argument('--test_only', action='store_true', help='skip fitting - evaluate metrics on trained model weights') args = parser.parse_args() # setup data provider img_set_options = dict(repo_dir=args.data_dir, inner_size=224, dtype=args.datatype, subset_pct=args.subset_pct) test = ImageLoader(set_name='validation', scale_range=(256, 256), do_transforms=False, **img_set_options) init1 = Xavier(local=False) initx = Xavier(local=True) bias = Constant(val=0.20)
im = np.uint8(np.transpose(im, axes=[1, 2, 0]).copy()) im = Image.fromarray(im) path = os.path.join(img_dir, str(labels[idx][0]), str(idx) + '.png') im.save(path, format='PNG') if setn == 'train': self.pixel_mean = list( data.mean(axis=0).reshape(3, -1).mean(axis=1)) self.pixel_mean.reverse( ) # We will see this in BGR order b/c of opencv if __name__ == "__main__": from neon.util.argparser import NeonArgparser parser = NeonArgparser(__doc__) parser.add_argument('--set_type', help='(i1k|cifar10|directory|csv)', required=True, choices=['i1k', 'cifar10', 'directory', 'csv']) parser.add_argument('--image_dir', help='Directory to find images', default=None) parser.add_argument( '--target_size', type=int, default=0, help= 'Size in pixels to scale shortest side DOWN to (0 means no scaling)') parser.add_argument('--macro_size', type=int,
import os import sys import numpy as np from neon.util.argparser import NeonArgparser from neon.initializers import Gaussian, GlorotUniform from neon.layers import Conv, Pooling, GeneralizedCost, Affine from neon.layers import DeepBiRNN, RecurrentMean from neon.optimizers import Adagrad from neon.transforms import Rectlin, Softmax, CrossEntropyBinary from neon.models import Model from neon.data import DataLoader, AudioParams from neon.callbacks.callbacks import Callbacks from sklearn import metrics from indexer import Indexer parser = NeonArgparser(__doc__) parser.add_argument('-elec', '--electrode', default=0, help='electrode index') parser.add_argument('-out', '--out_dir', default='preds', help='directory to write output files') parser.add_argument('-test', '--test_mode', action="store_true", help="testing mode") args = parser.parse_args() pattern = '*.' + str(args.electrode) + '.wav' data_dir = args.data_dir out_dir = args.out_dir if not os.path.exists(out_dir): os.makedirs(out_dir)
dd = x - y worst_case = np.max(np.abs(dd)) print 'worst case abs diff = %e' % worst_case ind = np.where((x != 0) | (y != 0)) rel_err = np.abs( np.divide(dd[ind], np.abs(x[ind]) + np.abs(y[ind]))) worst_case = np.max(rel_err) print 'worst case rel diff = %e' % worst_case assert False else: assert x == y # parse the command line arguments parser = NeonArgparser(__doc__) args = parser.parse_args() # hyperparameters batch_size = 128 num_epochs = args.epochs def gen_model(backend_type): # setup backend gen_backend(backend=backend_type, batch_size=batch_size, rng_seed=2, device_id=args.device_id, default_dtype=args.datatype)
x = x.reshape(x.size) y = y.reshape(y.size) dd = x - y worst_case = np.max(np.abs(dd)) print "worst case abs diff = %e" % worst_case ind = np.where((x != 0) | (y != 0)) rel_err = np.abs(np.divide(dd[ind], np.abs(x[ind]) + np.abs(y[ind]))) worst_case = np.max(rel_err) print "worst case rel diff = %e" % worst_case assert False else: assert x == y # parse the command line arguments parser = NeonArgparser(__doc__) args = parser.parse_args() # hyperparameters batch_size = 128 num_epochs = args.epochs def gen_model(backend_type): # setup backend gen_backend( backend=backend_type, batch_size=batch_size, rng_seed=2, device_id=args.device_id, default_dtype=args.datatype ) init_uni = Uniform(low=-0.1, high=0.1)
from datetime import datetime from neon.callbacks.callbacks import Callbacks, GANCostCallback from neon.callbacks.plotting_callbacks import GANPlotCallback from neon.optimizers import RMSProp from neon.util.argparser import NeonArgparser from neon.util.persist import ensure_dirs_exist from network_gan import create_model from lsun_data import make_loader # parse the command line arguments train_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'train.cfg') config_files = [train_config] if os.path.exists(train_config) else [] parser = NeonArgparser(__doc__, default_config_files=config_files, default_overrides={ 'rng_seed': 0, 'batch_size': 64 }) parser.add_argument('-D', '--dmodel', type=str, default='dc', help='discriminator model type: dc or mlp, default dc') parser.add_argument('-G', '--gmodel', type=str, default='dc', help='generator model type: dc or mlp, default dc') parser.add_argument( '--subset_pct', type=float,
from builtins import range import util from objectlocalization import PASCALVOC from neon.backends import gen_backend from neon.util.persist import get_data_cache_dir, save_obj from neon.util.argparser import NeonArgparser, extract_valid_args from neon import logger as neon_logger from voc_eval import voc_eval import numpy as np import faster_rcnn from tqdm import tqdm # parse the command line arguments parser = NeonArgparser(__doc__, default_overrides={'batch_size': 1}) parser.add_argument('--normalize', action='store_true', help='Normalize the final bounding box regression layers.') parser.add_argument('--output', default=None, help='File to save inference results (optional)') parser.add_argument('--width', type=int, default=1000, help='Width of input image') parser.add_argument('--height', type=int, default=1000, help='Height of input image') args = parser.parse_args() assert args.model_file is not None, "Model file required for Faster-RCNN testing" assert 'val' in args.manifest, "Path to manifest file requred" # hyperparameters assert args.batch_size is 1, "Faster-RCNN only supports batch size 1" rpn_rois_per_img = 256
Striving for Simplicity: the All Convolutional Net `[Springenberg2014]`_ .. _[Springenberg2014]: http://arxiv.org/pdf/1412.6806.pdf """ from neon.util.argparser import NeonArgparser from neon.backends import gen_backend from neon.initializers import GlorotUniform from neon.optimizers import GradientDescentMomentum, Schedule from neon.layers import Conv, Dropout, Activation, Pooling, GeneralizedCost, DataTransform from neon.transforms import Rectlin, Softmax, CrossEntropyMulti, Normalizer from neon.models import Model from neon.callbacks.callbacks import Callbacks from neon.data import ImageLoader # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('--deconv', action='store_true', help='save visualization data from deconvolution') args = parser.parse_args() # hyperparameters batch_size = 64 # setup backend be = gen_backend(backend=args.backend, batch_size=batch_size, rng_seed=args.rng_seed, device_id=args.device_id, datatype=args.datatype)
from glob import glob import functools import gzip from multiprocessing import Pool import numpy as np import os import tarfile import struct from PIL import Image as PILImage from neon.util.compat import range, StringIO from neon.util.persist import load_obj, save_obj from neon.data import load_i1kmeta from neon.util.argparser import NeonArgparser parser = NeonArgparser(__doc__) parser.add_argument('--set_type', help='(i1k|directory)', required=True, choices=['i1k', 'directory']) parser.add_argument('--image_dir', help='Directory to find images', required=True) parser.add_argument('--target_size', type=int, default=256, help='Size in pixels to scale images (Must be 256 for i1k dataset)') parser.add_argument('--macro_size', type=int, default=5000, help='Images per processed batch') parser.add_argument('--file_pattern', default='*.jpg', help='Image extension to include in' 'directory crawl') args = parser.parse_args() logger = logging.getLogger(__name__) # NOTE: We have to leave this helper function out of the class to use multiprocess pool.map def proc_img(target_size, squarecrop, is_string=False, imgfile=None):
self.batch_index += 1 yield self.X_dev, self.y_dev # replicate neon's mse error metric def err(y, t): feature_axis = 1 return (0.5 * np.square(y - t).mean(axis=feature_axis).mean()) if __name__ == '__main__': # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('--curvetype', default='Lissajous1', choices=['Lissajous1', 'Lissajous2'], help='type of input curve data to use (Lissajous1 or Lissajous2)') args = parser.parse_args(gen_be=False) # network hyperparameters hidden = 32 args.batch_size = 1 # The following flag will switch between 2 training strategies: # 1. return_sequence True: # Inputs are sequences, and target outputs will be sequences. # The RNN layer's output at EVERY step will be used for errors and optimized. # The RNN model contains a RNN layer and an Affine layer # The data iterator will format the data accordingly, and will stride along the # whole series with no overlap
import sys import os import json import numpy as np from neon.util.argparser import NeonArgparser from neon.initializers import Gaussian from neon.layers import Conv, Deconv, GeneralizedCost from neon.optimizers import Adadelta from neon.transforms import Rectlin, Logistic, SumSquared from neon.models import Model from neon.callbacks.callbacks import Callbacks from localizer_loader import LocalizerLoader from evaluator import Evaluator parser = NeonArgparser(__doc__) parser.add_argument('-tw', '--test_data_dir', default='', help='directory in which to find test images') parser.add_argument('-pn', '--point_num', default=None, help='1 or 2') parser.add_argument('-iw', '--image_width', default=384, help='image width') args = parser.parse_args() point_num = int(args.point_num) imwidth = int(args.image_width) train = LocalizerLoader(repo_dir=args.data_dir, inner_size=imwidth, set_name='train', nlabels=4, do_transforms=False, point_num=point_num) test = LocalizerLoader(repo_dir=args.test_data_dir, inner_size=imwidth, set_name='validation', nlabels=4, do_transforms=False, point_num=point_num)
from neon.data.pascal_voc import PASCAL_VOC_CLASSES from neon.data import PASCALVOCInference from neon.util.argparser import NeonArgparser from util import create_frcn_model do_plots = True try: import matplotlib.pyplot as plt plt.switch_backend('agg') except ImportError: neon_logger.display('matplotlib needs to be installed manually to generate plots needed ' 'for this example. Skipping plot generation') do_plots = False # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('--img_prefix', type=str, help='prefix for the saved image file names. If None, use ' 'the model file name') args = parser.parse_args(gen_be=True) assert args.model_file is not None, "need a model file to do Fast R-CNN testing" if args.img_prefix is None: args.img_prefix = os.path.splitext(os.path.basename(args.model_file))[0] output_dir = os.path.join(args.data_dir, 'frcn_output') if not os.path.isdir(output_dir): os.mkdir(output_dir) # hyperparameters args.batch_size = 1
python train.py -eval 1 --model_type alexnet --freeze 2 -w ~/nervana/data/NABirds_batchs -b gpu -i 0 -e 40 --dataset_dir ~/NABirds --model_file alexnet.p -vvvv """ from neon.util.argparser import NeonArgparser from neon.initializers import Constant, Gaussian from neon.layers import Conv, Dropout, Pooling, GeneralizedCost, Affine from neon.transforms import Rectlin, Softmax, CrossEntropyMulti, TopKMisclassification from neon.models import Model from neon.data import ImageLoader from neon.callbacks.callbacks import Callbacks from model_descriptions import create_model # parse the command line arguments (generates the backend) parser = NeonArgparser(__doc__) parser.add_argument('--model_type', help='Name of model', required=True, choices=['alexnet', 'vgg']) parser.add_argument('--model_tree', help='Whether or not to train tree of classifiers', default=False, type=bool) parser.add_argument('--freeze', type=int, help='Layers to freeze starting from end', default=0) parser.add_argument('--dataset_dir', help='Directory containing images folder and label text files') args = parser.parse_args() # setup data provider train_set_options = dict(repo_dir=args.data_dir, inner_size=224, dtype=args.datatype, subset_pct=100) test_set_options = dict(repo_dir=args.data_dir, inner_size=224, dtype=args.datatype,
from neon.backends import gen_backend from neon.data import ArrayIterator from neon.models import Model from neon.util.argparser import NeonArgparser from os.path import split, splitext, isfile from scipy.misc import imread, imsave #pretty printing full ndarrays def ndprint(a, format_string ='{0:.5f}'): print [format_string.format(v,i) for i,v in enumerate(a)] model_path = 'Googlenet_791113_192patch.prm' model_URL = 'http://degas.ecs.soton.ac.uk/~productizer/Googlenet_791113_192patch.prm' parser = NeonArgparser(__doc__) parser.add_argument('--image', dest='image', help="A string path to the location of an image readable by scipy's imread") parser.add_argument('--prm-name', dest='prm_name', default= model_path, help="The name of the prm to use as a model") parser.add_argument('--layer', dest='layer_index', default=-4, help="The index of the layer to extract the activations from") args = parser.parse_args() # load the cnn model gen_backend(batch_size=1, backend='cpu') # gen_backend(batch_size=32, backend='gpu') model_dict = load_obj(args.prm_name)
def train_mlp(): """ Train data and save scaling and network weights and biases to file to be used by forward prop phase on test data """ parser = NeonArgparser(__doc__) args = parser.parse_args() logger = logging.getLogger() logger.setLevel(args.log_thresh) # hyperparameters num_epochs = args.epochs #preprocessor std_scale = preprocessing.StandardScaler(with_mean=True,with_std=True) #std_scale = feature_scaler(type='Standardizer',with_mean=True,with_std=True) #number of non one-hot encoded features, including ground truth num_feat = 4 # load up the mnist data set # split into train and tests sets #load data from csv-files and rescale #training traindf = pd.DataFrame.from_csv('data/train.csv') ncols = traindf.shape[1] #tmpmat=std_scale.fit_transform(traindf.as_matrix()) #print std_scale.scale_ #print std_scale.mean_ tmpmat = traindf.as_matrix() #print tmpmat[:,1:num_feat] tmpmat[:,:num_feat] = std_scale.fit_transform(tmpmat[:,:num_feat]) X_train = tmpmat[:,1:] y_train = np.reshape(tmpmat[:,0],(tmpmat[:,0].shape[0],1)) #validation validdf = pd.DataFrame.from_csv('data/validate.csv') ncols = validdf.shape[1] tmpmat = validdf.as_matrix() tmpmat[:,:num_feat] = std_scale.transform(tmpmat[:,:num_feat]) X_valid = tmpmat[:,1:] y_valid = np.reshape(tmpmat[:,0],(tmpmat[:,0].shape[0],1)) #test testdf = pd.DataFrame.from_csv('data/test.csv') ncols = testdf.shape[1] tmpmat = testdf.as_matrix() tmpmat[:,:num_feat] = std_scale.transform(tmpmat[:,:num_feat]) X_test = tmpmat[:,1:] y_test = np.reshape(tmpmat[:,0],(tmpmat[:,0].shape[0],1)) # setup a training set iterator train_set = CustomDataIterator(X_train, lshape=(X_train.shape[1]), y_c=y_train) # setup a validation data set iterator valid_set = CustomDataIterator(X_valid, lshape=(X_valid.shape[1]), y_c=y_valid) # setup a validation data set iterator test_set = CustomDataIterator(X_test, lshape=(X_test.shape[1]), y_c=y_test) # setup weight initialization function init_norm = Xavier() # setup model layers layers = [Affine(nout=X_train.shape[1], init=init_norm, activation=Rectlin()), Dropout(keep=0.5), Affine(nout=X_train.shape[1]/2, init=init_norm, activation=Rectlin()), Linear(nout=1, init=init_norm)] # setup cost function as CrossEntropy cost = GeneralizedCost(costfunc=SmoothL1Loss()) # setup optimizer #schedule #schedule = ExpSchedule(decay=0.3) #optimizer = GradientDescentMomentum(0.0001, momentum_coef=0.9, stochastic_round=args.rounding, schedule=schedule) optimizer = Adam(learning_rate=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1.e-8) # initialize model object mlp = Model(layers=layers) # configure callbacks if args.callback_args['eval_freq'] is None: args.callback_args['eval_freq'] = 1 # configure callbacks callbacks = Callbacks(mlp, eval_set=valid_set, **args.callback_args) callbacks.add_early_stop_callback(stop_func) callbacks.add_save_best_state_callback(os.path.join(args.data_dir, "early_stop-best_state.pkl")) # run fit mlp.fit(train_set, optimizer=optimizer, num_epochs=args.epochs, cost=cost, callbacks=callbacks) #evaluate model print('Evaluation Error = %.4f'%(mlp.eval(valid_set, metric=SmoothL1Metric()))) print('Test set error = %.4f'%(mlp.eval(test_set, metric=SmoothL1Metric()))) # Saving the model print 'Saving model parameters!' mlp.save_params("model/homeapp_model.prm") # Reloading saved model # This should go in run.py mlp=Model("model/homeapp_model.prm") print('Test set error = %.4f'%(mlp.eval(test_set, metric=SmoothL1Metric()))) # save the preprocessor vectors: np.savez("model/homeapp_preproc", mean=std_scale.mean_, std=std_scale.scale_) return 1
""" from neon import logger as neon_logger from neon.backends import gen_backend from neon.data import IMDB from neon.initializers import Uniform, GlorotUniform from neon.layers import (GeneralizedCost, LSTM, Affine, Dropout, LookupTable, RecurrentSum, Recurrent, DeepBiLSTM, DeepBiRNN) from neon.models import Model from neon.optimizers import Adagrad from neon.transforms import Logistic, Tanh, Softmax, CrossEntropyMulti, Accuracy from neon.callbacks.callbacks import Callbacks from neon.util.argparser import NeonArgparser, extract_valid_args # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument( '--rlayer_type', default='lstm', choices=['bilstm', 'lstm', 'birnn', 'bibnrnn', 'rnn'], help='type of recurrent layer to use (lstm, bilstm, rnn, birnn, bibnrnn)') args = parser.parse_args(gen_be=False) # hyperparameters from the reference args.batch_size = 128 gradient_clip_value = 15 vocab_size = 20000 sentence_length = 128 embedding_dim = 128 hidden_size = 128
return manifest_file def caption_video(infile, caption, outfile): cmd = '''ffmpeg -i {0} -an \ -vf drawtext="textfile={1}: fontcolor=white: fontsize=16: box=1: [email protected]" \ -y {2}''' proc = subprocess.Popen(cmd.format(infile, caption, outfile), shell=True) proc.communicate() # parse the command line arguments demo_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'test.cfg') config_files = [demo_config] if os.path.exists(demo_config) else [] parser = NeonArgparser(__doc__, default_config_files=config_files) parser.add_argument('--input_video', help='video file') parser.add_argument('--output_video', help='Video file with overlayed inference hypotheses') args = parser.parse_args() assert args.model_file is not None, "need a model file for testing" model = Model(args.model_file) assert 'categories' in args.manifest, "Missing categories file" category_map = {t[0]: t[1] for t in np.genfromtxt(args.manifest['categories'], dtype=None, delimiter=',')} # Make a temporary directory and clean up afterwards outdir = mkdtemp() atexit.register(shutil.rmtree, outdir) caption_file = os.path.join(outdir, 'caption.txt')
""" from neon import logger as neon_logger from neon.backends import gen_backend from neon.data.text import Text from neon.data.dataloaders import load_ptb_train, load_ptb_test from neon.initializers import Uniform from neon.layers import GeneralizedCost, LSTM, Affine, GRU from neon.models import Model from neon.optimizers import RMSProp, Schedule from neon.transforms import Logistic, Tanh, Softmax, CrossEntropyMulti from neon.callbacks.callbacks import Callbacks from neon.util.argparser import NeonArgparser, extract_valid_args # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('--rlayer_type', default='lstm', choices=['gru', 'lstm'], help='type of recurrent layer to use (gru or lstm)') args = parser.parse_args(gen_be=False) # hyperparameters args.batch_size = 64 # note Karpathy's char-rnn uses 50 time_steps = 50 hidden_size = 128 gradient_clip_value = 5 # setup backend be = gen_backend(**extract_valid_args(args, gen_backend))
from __future__ import print_function from future import standard_library standard_library.install_aliases() # triggers E402, hence noqa below from builtins import input # noqa import numpy as np # noqa from neon.backends import gen_backend # noqa from neon.initializers import Uniform, GlorotUniform # noqa from neon.layers import LSTM, Affine, Dropout, LookupTable, RecurrentSum # noqa from neon.models import Model # noqa from neon.transforms import Logistic, Tanh, Softmax # noqa from neon.util.argparser import NeonArgparser, extract_valid_args # noqa from neon.util.compat import pickle # noqa from neon.data.text_preprocessing import clean_string # noqa # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument( '--model_weights', required=True, help='pickle file of trained weights') parser.add_argument('--vocab_file', required=True, help='vocabulary file') args = parser.parse_args() # hyperparameters from the reference batch_size = 1 clip_gradients = True gradient_limit = 5 vocab_size = 20000 sentence_length = 128 embedding_dim = 128 hidden_size = 128 reset_cells = True num_epochs = args.epochs
# self._target = target # self._args = args # threading.Thread.__init__(self) # # def run(self): # self._target(*self._args) # http://stackoverflow.com/questions/9258602/elegant-pythonic-cumsum def cumsum(it): total = 0 for x in it: total += x yield total # add custom command line arguments on top of standard neon arguments parser = NeonArgparser(__doc__) # extra arguments controlling model and learning parser.add_argument('--model_arch', type=str, default='fergus', help='Specify convnet model architecture from arch/') #parser.add_argument('--rate_decay', type=float, default=0.0, # help='Learning schedule rate decay time constant (in epochs)') #parser.add_argument('--rate_freq', type=int, default=0, # help='Batch frequency to update rate decay (< 1 is once per EM epoch (training macrobatches))') parser.add_argument('--rate_step', type=float, default=1.0, help='Learning schedule rate step (in emneon epochs)') parser.add_argument('--epoch_dstep', nargs='*', type=int, default=[], help='Learning schedule neon delta epochs to adjust rate (use instead of rate_step)') parser.add_argument('--rate_change', type=float, default=0.5, help='Learning schedule rate change (occurs each rate_step)') parser.add_argument('--weight_decay', type=float, default=0.01, help='Weight decay') parser.add_argument('--rate_init', nargs=2, type=float, default=[0.001, 0.002], help='Initial learning rates [weight, bias]') parser.add_argument('--momentum', nargs=2, type=float, default=[0.9, 0.9],
python examples/word_lstm.py -e 13 -eval 1 --rlayer_type lstm """ from neon.backends import gen_backend from neon.data import Text, load_text from neon.initializers import Uniform from neon.layers import GeneralizedCost, LSTM, Affine, GRU, LookupTable from neon.models import Model from neon.optimizers import GradientDescentMomentum, Schedule from neon.transforms import Logistic, Tanh, Softmax, CrossEntropyMulti from neon.callbacks.callbacks import Callbacks from neon.util.argparser import NeonArgparser, extract_valid_args # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('--rlayer_type', default='lstm', choices=['gru', 'lstm'], help='type of recurrent layer to use (gru or lstm)') args = parser.parse_args(gen_be=False) # hyperparameters from the reference args.batch_size = 20 time_steps = 20 hidden_size = 200 gradient_clip_norm = 5 # setup backend be = gen_backend(**extract_valid_args(args, gen_backend)) # download penn treebank train_path = load_text('ptb-train', path=args.data_dir)
from neon.initializers import GlorotUniform, Constant, Gaussian from neon.layers import Conv, GeneralizedCost, Affine, DeepBiRNN from neon.models import Model from neon.transforms import Rectlin, Identity, Rectlinclip from neon.optimizers import GradientDescentMomentum from neon.util.argparser import NeonArgparser, extract_valid_args from ctc import CTC from decoder import ArgMaxDecoder from sample_proposals_callback import WordErrorRateCallback from data.dataloader import make_loader # Parse the command line arguments arg_defaults = {'batch_size': 32} parser = NeonArgparser(__doc__, default_overrides=arg_defaults) parser.add_argument('--nfilters', type=int, help='no. of conv filters', default=1152) parser.add_argument('--filter_width', type=int, help='width of conv filter', default=11) parser.add_argument('--str_w', type=int, help='stride in time', default=3) parser.add_argument('--depth', type=int, help='rnn depth', default=9) parser.add_argument('--hidden_size', type=int, help='affine/rnn hidden units', default=1152) parser.add_argument('--lr', type=float, help='learning rate', default=2e-5) parser.add_argument('--momentum', type=float, help='momentum', default=0.99) args = parser.parse_args() # Setup model hyperparameters
from prepare import build_data_train from neon.backends import gen_backend from neon.data import ArrayIterator from neon.initializers import Uniform, GlorotUniform from neon.layers import GeneralizedCost, Affine, Dropout, LookupTable, LSTM, RecurrentSum from neon.models import Model from neon.optimizers import Adagrad from neon.transforms import Logistic, Tanh, Softmax, CrossEntropyMulti, Accuracy from neon.util.argparser import NeonArgparser, extract_valid_args from neon.callbacks.callbacks import Callbacks from neon.data.text_preprocessing import get_paddedXY, get_google_word2vec_W import h5py import cPickle # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('-f', '--review_file', default='labeledTrainData.tsv', help='input movie review file') parser.add_argument('--vocab_file', default='labeledTrainData.tsv.vocab', help='output file to save the processed vocabulary') parser.add_argument('--use_w2v', action='store_true', help='use downloaded Google Word2Vec') parser.add_argument('--w2v', default='GoogleNews-vectors-negative300.bin', help='the pre-built Word2Vec') args = parser.parse_args() # hyperparameters
import sys from neon.util.argparser import NeonArgparser from neon.backends import gen_backend from neon.initializers import Constant, Gaussian from neon.layers import Conv, Dropout, Pooling, GeneralizedCost, Affine from neon.optimizers import GradientDescentMomentum, MultiOptimizer, Schedule from neon.transforms import Rectlin, Softmax, CrossEntropyMulti, TopKMisclassification from neon.models import Model from neon.data import ImgMaster from neon.callbacks.callbacks import Callbacks, Callback # For running complete alexnet # alexnet.py -e 90 -val 1 -s <save-path> -w <path-to-saved-batches> # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('--model_file', help='load model from pkl file') args = parser.parse_args() # hyperparameters batch_size = 128 # setup backend be = gen_backend(backend=args.backend, rng_seed=args.rng_seed, device_id=args.device_id, batch_size=batch_size, default_dtype=args.datatype) try: train = ImgMaster(repo_dir=args.data_dir, inner_size=224, set_name='train') test = ImgMaster(repo_dir=args.data_dir, inner_size=224, set_name='validation', do_transforms=False) except (OSError, IOError, ValueError) as err:
for idx in range(data.shape[0]): im = np.pad(data[idx].reshape((3, 32, 32)), self.pad_width, mode='mean') im = np.uint8(np.transpose(im, axes=[1, 2, 0]).copy()) im = Image.fromarray(im) path = os.path.join(img_dir, str(labels[idx][0]), str(idx) + '.png') im.save(path, format='PNG') if setn == 'train': self.pixel_mean = list(data.mean(axis=0).reshape(3, -1).mean(axis=1)) self.pixel_mean.reverse() # We will see this in BGR order b/c of opencv if __name__ == "__main__": from neon.util.argparser import NeonArgparser parser = NeonArgparser(__doc__) parser.add_argument('--set_type', help='(i1k|cifar10|directory|csv)', required=True, choices=['i1k', 'cifar10', 'directory', 'csv']) parser.add_argument('--image_dir', help='Directory to find images', default=None) parser.add_argument('--target_size', type=int, default=0, help='Size in pixels to scale shortest side DOWN to (0 means no scaling)') parser.add_argument('--macro_size', type=int, default=5000, help='Images per processed batch') parser.add_argument('--file_pattern', default='*.jpg', help='Image extension to include in' 'directory crawl') args = parser.parse_args() logger = logging.getLogger(__name__) if args.set_type == 'i1k': args.target_size = 256 # (maybe 512 for Simonyan's methodology?) bw = BatchWriterI1K(out_dir=args.data_dir, image_dir=args.image_dir,
from prepare import build_data_train from neon.backends import gen_backend from neon.data import ArrayIterator from neon.initializers import Uniform, GlorotUniform from neon.layers import GeneralizedCost, Affine, Dropout, LookupTable, LSTM, RecurrentSum from neon.models import Model from neon.optimizers import Adagrad from neon.transforms import Logistic, Tanh, Softmax, CrossEntropyMulti, Accuracy from neon.util.argparser import NeonArgparser, extract_valid_args from neon.callbacks.callbacks import Callbacks from neon.data.text_preprocessing import get_paddedXY, get_google_word2vec_W import h5py import cPickle # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('-f', '--review_file', default='labeledTrainData.tsv', help='input movie review file') parser.add_argument('--vocab_file', default='labeledTrainData.tsv.vocab', help='output file to save the processed vocabulary') parser.add_argument('--use_w2v', action='store_true', help='use downloaded Google Word2Vec') parser.add_argument('--w2v', default='GoogleNews-vectors-negative300.bin', help='the pre-built Word2Vec') args = parser.parse_args()
Striving for Simplicity: the All Convolutional Net `[Springenberg2014]`_ .. _[Springenberg2014]: http://arxiv.org/pdf/1412.6806.pdf """ from neon.util.argparser import NeonArgparser from neon.backends import gen_backend from neon.initializers import GlorotUniform from neon.optimizers import GradientDescentMomentum, Schedule from neon.layers import Conv, Dropout, Activation, Pooling, GeneralizedCost, DataTransform from neon.transforms import Rectlin, Softmax, CrossEntropyMulti, Normalizer from neon.models import Model from neon.callbacks.callbacks import Callbacks from neon.data import ImgMaster, ImageLoader # parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument('--deconv', action='store_true', help='save visualization data from deconvolution') parser.add_argument('--loader_version', default='old', choices=['old', 'new'], help='whether to use old dataloader (ImgMaster) or new (ImageLoader)') args = parser.parse_args() # hyperparameters batch_size = 64 # setup backend be = gen_backend(backend=args.backend, batch_size=batch_size, rng_seed=args.rng_seed, device_id=args.device_id,
from neon.optimizers import GradientDescentMomentum, MultiOptimizer, StepSchedule from neon.callbacks.callbacks import Callbacks, TrainMulticostCallback from neon.util.persist import save_obj, get_data_cache_dir from objectlocalization import PASCALVOC from neon.transforms import CrossEntropyMulti, SmoothL1Loss from neon.layers import Multicost, GeneralizedCostMask import util import faster_rcnn import os train_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'pascalvoc.cfg') config_files = [train_config] if os.path.exists(train_config) else [] # parse the command line arguments parser = NeonArgparser(__doc__, default_config_files=config_files) parser.add_argument('--width', type=int, default=1000, help='Width of input image') parser.add_argument('--height', type=int, default=1000, help='Height of input image') parser.add_argument('--subset_pct', type=float, default=100, help='subset of training dataset to use (percentage)') args = parser.parse_args(gen_be=False) # hyperparameters