def load_data(name):
if name == 'cifar10':
(X_train, y_train), (X_test, y_test), nout = load_cifar10(path=args.data_dir)
nout = 16
elif name == 'cifar100':
(X_train, y_train), (X_test, y_test) = cifar100.load_data(label_mode='fine')
X_train = X_train.reshape(50000, 3072)
X_test = X_test.reshape(10000, 3072)
nout = 128
elif name == 'svhn':
from scipy.io import loadmat
train = loadmat('../data/svhm_train.mat')
test = loadmat('../data/svhn_test.mat')
(X_train, y_train), (X_test, y_test) = (train['X'], train['y']), (test['X'], test['y'])
s = X_train.shape
X_train = X_train.reshape(-1, s[-1]).transpose()
s = X_test.shape
X_test = X_test.reshape(-1, s[-1]).transpose()
temp = np.empty(X_train.shape, dtype=np.uint)
np.copyto(temp, X_train)
X_train = temp
temp = np.empty(X_test.shape, dtype=np.uint)
np.copyto(temp, X_test)
X_test = temp
nout = 16
return (X_train, y_train), (X_test, y_test), nout
def extract_images(self, overwrite=False):
from neon.data import load_cifar10
from PIL import Image
dataset = dict()
dataset['train'], dataset['val'], _ = load_cifar10(self.out_dir, normalize=False)
for setn in ('train', 'val'):
data, labels = dataset[setn]
img_dir = os.path.join(self.out_dir, setn)
ulabels = np.unique(labels)
for ulabel in ulabels:
subdir = os.path.join(img_dir, str(ulabel))
if not os.path.exists(subdir):
os.makedirs(subdir)
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
def extract_images(out_dir, padded_size):
'''
Save CIFAR-10 dataset as PNG files
'''
import numpy as np
from neon.data import load_cifar10
from PIL import Image
dataset = dict()
dataset['train'], dataset['val'], _ = load_cifar10(out_dir,
normalize=False)
pad_size = (padded_size - 32) // 2 if padded_size > 32 else 0
pad_width = ((0, 0), (pad_size, pad_size), (pad_size, pad_size))
for setn in ('train', 'val'):
data, labels = dataset[setn]
img_dir = os.path.join(out_dir, setn)
ulabels = np.unique(labels)
for ulabel in ulabels:
subdir = os.path.join(img_dir, str(ulabel))
if not os.path.exists(subdir):
os.makedirs(subdir)
for idx in range(data.shape[0]):
im = np.pad(data[idx].reshape((3, 32, 32)), 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')
def extract_images(out_dir, padded_size):
'''
Save CIFAR-10 dataset as PNG files
'''
import numpy as np
from neon.data import load_cifar10
from PIL import Image
dataset = dict()
dataset['train'], dataset['val'], _ = load_cifar10(out_dir, normalize=False)
pad_size = (padded_size - 32) // 2 if padded_size > 32 else 0
pad_width = ((0, 0), (pad_size, pad_size), (pad_size, pad_size))
for setn in ('train', 'val'):
data, labels = dataset[setn]
img_dir = os.path.join(out_dir, setn)
ulabels = np.unique(labels)
for ulabel in ulabels:
subdir = os.path.join(img_dir, str(ulabel))
if not os.path.exists(subdir):
os.makedirs(subdir)
for idx in range(data.shape[0]):
im = np.pad(data[idx].reshape((3, 32, 32)), 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')
be = gen_backend(backend='cpu', batch_size=128)
# doesn't actually do anything with the doc string!
parser = NeonArgparser(__doc__)
# Creates a "namespace" or backend which is then put into the original
# parser instantiation.
args = parser.parse_args()
epochs = 10
# To train a deep network we need to specify the following:
# - dataset
(X_train, y_train), (X_test, y_test), nclass = load_cifar10()
# lshape tells the cnn what shape each row should be resized to since otherwise
# it's a 3 x 32 x 32 shape array.
train_set = ArrayIterator(X_train, y_train, nclass=nclass, lshape=(3, 32, 32))
test_set = ArrayIterator(X_test, y_test, nclass=nclass, lshape=(3, 32, 32))
# - list of layers
arch = Architecture('AlexNet', nclass)
layers = arch.layers
learning_rate = arch.learning_rate
momentum = arch.momentum
# using the code provided by neon
# init_uni = Uniform(low=-0.1, high=0.1)
"""
from neon.data import ArrayIterator, load_cifar10
from neon.initializers import Uniform
from neon.layers import GeneralizedCost, Affine
from neon.models import Model
from neon.optimizers import GradientDescentMomentum
from neon.transforms import Misclassification, CrossEntropyBinary, Logistic, Rectlin
from neon.callbacks.callbacks import Callbacks
from neon.util.argparser import NeonArgparser
# parse the command line arguments
parser = NeonArgparser(__doc__)
args = parser.parse_args()
(X_train, y_train), (X_test, y_test), nclass = load_cifar10(path=args.data_dir)
train = ArrayIterator(X_train, y_train, nclass=nclass, lshape=(3, 32, 32))
test = ArrayIterator(X_test, y_test, nclass=nclass, lshape=(3, 32, 32))
init_uni = Uniform(low=-0.1, high=0.1)
opt_gdm = GradientDescentMomentum(learning_rate=0.01, momentum_coef=0.9)
# set up the model layers
layers = [
Affine(nout=200, init=init_uni, activation=Rectlin()),
Affine(nout=10, init=init_uni, activation=Logistic(shortcut=True))
]
cost = GeneralizedCost(costfunc=CrossEntropyBinary())
# parse the command line arguments
parser = NeonArgparser(__doc__)
args = parser.parse_args()
# hyperparameters
batch_size = 128
num_epochs = args.epochs
# setup backend
be = gen_backend(backend=args.backend,
batch_size=batch_size,
rng_seed=args.rng_seed,
device_id=args.device_id,
default_dtype=args.datatype)
(X_train, y_train), (X_test, y_test), nclass = load_cifar10(path=args.data_dir)
# really 10 classes, pad to nearest power of 2 to match conv output
train_set = DataIterator(X_train, y_train, nclass=16, lshape=(3, 32, 32))
valid_set = DataIterator(X_test, y_test, nclass=16, lshape=(3, 32, 32))
init_uni = GlorotUniform()
opt_gdm = GradientDescentMomentum(learning_rate=0.5,
schedule=Schedule(step_config=[200, 250, 300],
change=0.1),
momentum_coef=0.9, wdecay=.0001)
relu = Rectlin()
layers = []
layers.append(Dropout(keep=.8))
layers.append(Conv((3, 3, 96), init=init_uni, batch_norm=True, activation=relu))
layers.append(Conv((3, 3, 96), init=init_uni, batch_norm=True, activation=relu, pad=1))
from joblib import dump
be = gen_backend(backend='cpu', batch_size=128)
# doesn't actually do anything with the doc string!
parser = NeonArgparser(__doc__)
# Creates a "namespace" or backend which is then put into the original
# parser instantiation.
args = parser.parse_args()
epochs = 10
# To train a deep network we need to specify the following:
# - dataset
(X_train, y_train), (X_test, y_test), nclass = load_cifar10()
# lshape tells the cnn what shape each row should be resized to since otherwise
# it's a 3 x 32 x 32 shape array.
train_set = ArrayIterator(X_train, y_train, nclass=nclass, lshape=(3, 32, 32))
test_set = ArrayIterator(X_test, y_test, nclass=nclass, lshape=(3, 32, 32))
# - list of layers
arch = Architecture('AlexNet', nclass)
layers = arch.layers
learning_rate = arch.learning_rate
momentum = arch.momentum
# using the code provided by neon
# init_uni = Uniform(low=-0.1, high=0.1)
def process(inputpath):
(X_train, y_train), (X_test, y_test), nclass = load_cifar10(inputpath,
normalize=False)
process_dataset(X_train, y_train, inputpath, trainimgs)
process_dataset(X_test, y_test, inputpath, testimgs)
"type": "int",
"bounds": {
"max": 500,
"min": 50,
}
},
],
# Sign up for an enterprise account to get more observations
observation_budget=150,
)
DATA_DIR = "/home/ubuntu/data"
(X_train, y_train), (X_test, y_test), nclass = load_cifar10(
path=DATA_DIR,
normalize=False,
contrast_normalize=True,
whiten=False,
)
# get error on this command
train_set = DataIterator(X_train, y_train, nclass=16, lshape=(3, 32, 32))
valid_set = DataIterator(X_test, y_test, nclass=16, lshape=(3, 32, 32))
# run optimization loop
for ir in xrange(experiment.observation_budget):
suggestion = conn.experiments(experiment.id).suggestions().create()
assignments = suggestion.assignments
print assignments
num_epochs = int(assignments.get("epochs"))
init_uni = Gaussian(scale=assignments.get("gaussian_scale"))
def process(inputpath):
(X_train, y_train), (X_test, y_test), nclass = load_cifar10(inputpath,
normalize=False)
process_dataset(X_train, y_train, inputpath, traindir)
process_dataset(X_test, y_test, inputpath, testdir)
from neon.data import ArrayIterator, load_cifar10
from neon.callbacks.callbacks import Callbacks
from neon.util.argparser import NeonArgparser
# 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
(X_train, y_train), (X_test, y_test), nclass = load_cifar10(
path=args.data_dir, normalize=False, contrast_normalize=True, whiten=True
)
# really 10 classes, pad to nearest power of 2 to match conv output
train_set = ArrayIterator(X_train, y_train, nclass=16, lshape=(3, 32, 32))
valid_set = ArrayIterator(X_test, y_test, nclass=16, lshape=(3, 32, 32))
init_uni = Gaussian(scale=0.05)
opt_gdm = GradientDescentMomentum(
learning_rate=float(args.learning_rate),
momentum_coef=0.9,
wdecay=float(args.weight_decay),
schedule=Schedule(step_config=[200, 250, 300], change=0.1),
)
relu = Rectlin()
from neon.callbacks.callbacks import Callbacks
from neon.util.argparser import NeonArgparser
# 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
(X_train, y_train), (X_test, y_test), nclass = load_cifar10(path=args.data_dir,
normalize=False,
contrast_normalize=True,
whiten=True)
# really 10 classes, pad to nearest power of 2 to match conv output
train_set = ArrayIterator(X_train, y_train, nclass=16, lshape=(3, 32, 32))
valid_set = ArrayIterator(X_test, y_test, nclass=16, lshape=(3, 32, 32))
init_uni = Gaussian(scale=0.05)
opt_gdm = GradientDescentMomentum(learning_rate=float(args.learning_rate), momentum_coef=0.9,
wdecay=float(args.weight_decay),
schedule=Schedule(step_config=[200, 250, 300], change=0.1))
relu = Rectlin()
conv = dict(init=init_uni, batch_norm=False, activation=relu)
convp1 = dict(init=init_uni, batch_norm=False, activation=relu, padding=1)
convp1s2 = dict(init=init_uni, batch_norm=False, activation=relu, padding=1, strides=2)
