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
