def _createLayers(self, num_actions):
# create network
init_xavier_conv = Xavier(local=True)
init_xavier_affine = Xavier(local=False)
# init_uniform_conv = Uniform(low=-.01, high=.01)
# init_uniform_affine = Uniform(low=-.01, high=.01)
layers = []
# The first hidden layer convolves 32 filters of 8x8 with stride 4 with the input image and applies a rectifier nonlinearity.
# layers.append(Conv((8, 8, 32), strides=4, init=init_xavier_conv, activation=Rectlin(), batch_norm=self.batch_norm))
layers.append(
Conv((5, 5, 32),
strides=2,
init=init_xavier_conv,
activation=Rectlin(),
batch_norm=self.batch_norm))
# The second hidden layer convolves 64 filters of 4x4 with stride 2, again followed by a rectifier nonlinearity.
# layers.append(Conv((4, 4, 64), strides=2, init=init_xavier_conv, activation=Rectlin(), batch_norm=self.batch_norm))
layers.append(
Conv((5, 5, 32),
strides=2,
init=init_xavier_conv,
activation=Rectlin(),
batch_norm=self.batch_norm))
# This is followed by a third convolutional layer that convolves 64 filters of 3x3 with stride 1 followed by a rectifier.
# layers.append(Conv((3, 3, 64), strides=1, init=init_xavier_conv, activation=Rectlin(), batch_norm=self.batch_norm))
# The final hidden layer is fully-connected and consists of 512 rectifier units.
layers.append(
Affine(nout=512,
init=init_xavier_affine,
activation=Rectlin(),
batch_norm=self.batch_norm))
# The output layer is a fully-connected linear layer with a single output for each valid action.
layers.append(Affine(nout=num_actions, init=init_xavier_affine))
return layers
def _createLayers(self, num_actions):
init_xavier_conv = Xavier(local=True)
init_xavier_affine = Xavier(local=False)
layers = []
layers.append(
Conv((8, 8, 32),
strides=4,
init=init_xavier_conv,
activation=Rectlin(),
batch_norm=self.batch_norm))
layers.append(
Conv((4, 4, 64),
strides=2,
init=init_xavier_conv,
activation=Rectlin(),
batch_norm=self.batch_norm))
layers.append(
Conv((2, 2, 128),
strides=1,
init=init_xavier_conv,
activation=Rectlin(),
batch_norm=self.batch_norm))
layers.append(
Affine(nout=256,
init=init_xavier_affine,
activation=Rectlin(),
batch_norm=self.batch_norm))
layers.append(Affine(nout=num_actions, init=init_xavier_affine))
return layers
def generate_leafs(self, layer):
"""
Given a key to the ssd_config, generate the leafs
"""
config = self.ssd_config[layer]
leaf_params = {
'strides': 1,
'padding': 1,
'init': Xavier(local=True),
'bias': Constant(0)
}
# to match caffe layer's naming
if config['normalize']:
layer += '_norm'
priorbox_args = self.get_priorbox_args(config)
mbox_prior = PriorBox(**priorbox_args)
num_priors = mbox_prior.num_priors_per_pixel
loc_name = layer + '_mbox_loc'
mbox_loc = Conv((3, 3, 4 * num_priors), name=loc_name, **leaf_params)
conf_name = layer + '_mbox_conf'
mbox_conf = Conv((3, 3, self.num_classes * num_priors),
name=conf_name,
**leaf_params)
return {
'mbox_prior': mbox_prior,
'mbox_loc': mbox_loc,
'mbox_conf': mbox_conf
}
def get_initializer(self, input_size):
dnnInit = self.args.dnn_initializer
if dnnInit == 'xavier':
initializer = Xavier()
elif dnnInit == 'fan_in':
std_dev = 1.0 / math.sqrt(input_size)
initializer = Uniform(low=-std_dev, high=std_dev)
else:
initializer = Gaussian(0, 0.01)
return initializer
def fit_model(train_set, val_set, num_epochs=50):
relu = Rectlin()
conv_params = {
'strides': 1,
'padding': 1,
'init': Xavier(local=True), # Xavier sqrt(3)/num_inputs [CHECK THIS]
'bias': Constant(0),
'activation': relu
}
layers = []
layers.append(Conv((3, 3, 128), **conv_params)) # 3x3 kernel * 128 nodes
layers.append(Pooling(2))
layers.append(Conv((3, 3, 128), **conv_params))
layers.append(Pooling(2)) # Highest value from 2x2 window.
layers.append(Conv((3, 3, 128), **conv_params))
layers.append(
Dropout(keep=0.5)
) # Flattens Convolution into a flat array, with probability 0.5 sets activation values to 0
layers.append(
Affine(nout=128,
init=GlorotUniform(),
bias=Constant(0),
activation=relu)
) # 1 value per conv kernel - Linear Combination of layers
layers.append(Dropout(keep=0.5))
layers.append(
Affine(nout=2,
init=GlorotUniform(),
bias=Constant(0),
activation=Softmax(),
name="class_layer"))
# initialize model object
cnn = Model(layers=layers)
cost = GeneralizedCost(costfunc=CrossEntropyMulti())
optimizer = Adam()
# callbacks = Callbacks(cnn)
# out_fname = 'yarin_fdl_out_data.h5'
callbacks = Callbacks(cnn, eval_set=val_set,
eval_freq=1) # , output_file=out_fname
cnn.fit(train_set,
optimizer=optimizer,
num_epochs=num_epochs,
cost=cost,
callbacks=callbacks)
return cnn
def add_vgg_layers():
# setup layers
init1_vgg = Xavier(local=True)
relu = Rectlin()
conv_params = {
'strides': 1,
'padding': 1,
'init': init1_vgg,
'bias': Constant(0),
'activation': relu
}
# Set up the model layers
vgg_layers = []
# set up 3x3 conv stacks with different feature map sizes
vgg_layers.append(Conv((3, 3, 64), **conv_params))
vgg_layers.append(Conv((3, 3, 64), **conv_params))
vgg_layers.append(Pooling(2, strides=2))
vgg_layers.append(Conv((3, 3, 128), **conv_params))
vgg_layers.append(Conv((3, 3, 128), **conv_params))
vgg_layers.append(Pooling(2, strides=2))
vgg_layers.append(Conv((3, 3, 256), **conv_params))
vgg_layers.append(Conv((3, 3, 256), **conv_params))
vgg_layers.append(Conv((3, 3, 256), **conv_params))
vgg_layers.append(Pooling(2, strides=2))
vgg_layers.append(Conv((3, 3, 512), **conv_params))
vgg_layers.append(Conv((3, 3, 512), **conv_params))
vgg_layers.append(Conv((3, 3, 512), **conv_params))
vgg_layers.append(Pooling(2, strides=2))
vgg_layers.append(Conv((3, 3, 512), **conv_params))
vgg_layers.append(Conv((3, 3, 512), **conv_params))
vgg_layers.append(Conv((3, 3, 512), **conv_params))
# not used after this layer
# vgg_layers.append(Pooling(2, strides=2))
# vgg_layers.append(Affine(nout=4096, init=initfc, bias=Constant(0), activation=relu))
# vgg_layers.append(Dropout(keep=0.5))
# vgg_layers.append(Affine(nout=4096, init=initfc, bias=Constant(0), activation=relu))
# vgg_layers.append(Dropout(keep=0.5))
# vgg_layers.append(Affine(nout=1000, init=initfc, bias=Constant(0), activation=Softmax()))
return vgg_layers
type="image,localization",
image=image_config,
localization=localization_config,
manifest_filename="train_json.csv",
cache_directory="/home/auto-114/PycharmProjects/neon_study_10/cache",
minibatch_size=1,
macrobatch_size=1)
train = DataLoader(config, be)
# weight initialization
init_norm = Gaussian(loc=0.0, scale=0.01)
# setup model layers
init1_vgg = Xavier(local=True)
relu = Rectlin()
conv_params = {
'strides': 1,
'padding': 1,
'init': init1_vgg,
'bias': Constant(0),
'activation': relu
}
# Set up the model layers
layers = []
# set up 3x3 conv stacks with different feature map sizes
layers.append(Conv((3, 3, 64), name="skip", **conv_params))
batch_size = 32 * 8 # for some reason bs 128 does not work with bias layers
else:
batch_size = 32
# subset pct is set to make sure that every epoch has the same mb count
img_set_options = dict(repo_dir=args.data_dir,
inner_size=224,
dtype=np.float32,
subset_pct=0.09990891117239205)
train = ImageLoader(set_name='train',
scale_range=(256, 256),
shuffle=False,
do_transforms=False,
**img_set_options)
init1 = Xavier(local=False)
initx = Xavier(local=True)
bias = Constant(val=0.20)
relu = Rectlin()
common = dict(activation=relu, init=initx, bias=bias)
commonp1 = dict(activation=relu, init=initx, bias=bias, padding=1)
commonp2 = dict(activation=relu, init=initx, bias=bias, padding=2)
pool3s1p1 = dict(fshape=3, padding=1, strides=1)
pool3s2p1 = dict(fshape=3, padding=1, strides=2, op='max')
def inception(kvals, name):
(p1, p2, p3, p4) = kvals
branch1 = [Conv((1, 1, p1[0]), name=name + '1x1', **common)]
parser.add_argument('--vgg_version', default='D', choices=['D', 'E'],
help='vgg model type')
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()
img_set_options = dict(repo_dir=args.data_dir, inner_size=224,
subset_pct=args.subset_pct)
train = ImageLoader(set_name='train', scale_range=(256, 384),
shuffle=True, **img_set_options)
test = ImageLoader(set_name='validation', scale_range=(256, 256), do_transforms=False,
shuffle=False, **img_set_options)
init1 = Xavier(local=True)
initfc = GlorotUniform()
relu = Rectlin()
conv_params = {'init': init1,
'strides': 1,
'padding': 1,
'bias': Constant(0),
'activation': relu}
# Set up the model layers
layers = []
# set up 3x3 conv stacks with different feature map sizes
for nofm in [64, 128, 256, 512, 512]:
layers.append(Conv((3, 3, nofm), **conv_params))
manifest_filename='manifest_subset2_augmented.csv',
minibatch_size=args.batch_size,
subset_fraction=1.0)
test_set = DataLoader(config, be)
test_set = TypeCast(test_set, index=0, dtype=np.float32) # cast image to float
#test_set = OneHot(test_set, index=1, nclasses=2)
#init_uni = Gaussian(scale=0.05)
init_uni = GlorotUniform()
#opt_gdm = Adam(learning_rate=args.learning_rate, beta_1=0.9, beta_2=0.999)
opt_gdm = Adadelta(decay=0.95, epsilon=1e-6)
relu = Rectlin()
conv_params = {'strides': 1,
'padding': 1,
'init': Xavier(local=True),
'bias': Constant(0),
'activation': relu,
'batch_norm': False}
# Set up the model layers
vgg_layers = []
# set up 3x3 conv stacks with different number of filters
vgg_layers.append(Conv((3, 3, 64), **conv_params))
vgg_layers.append(Conv((3, 3, 64), **conv_params))
vgg_layers.append(Pooling(2, strides=2))
vgg_layers.append(Conv((3, 3, 128), **conv_params))
vgg_layers.append(Conv((3, 3, 128), **conv_params))
vgg_layers.append(Pooling(2, strides=2))
vgg_layers.append(Conv((3, 3, 256), **conv_params))
def generate_layers(self):
conv_params = {
'strides': 1,
'padding': 1,
'init': Xavier(local=True),
'bias': Constant(0),
'activation': Rectlin()
}
params = {
'init': Xavier(local=True),
'bias': Constant(0),
'activation': Rectlin()
}
# Set up the model layers
trunk_layers = []
# set up 3x3 conv stacks with different feature map sizes
# use same names as Caffe model for comparison purposes
trunk_layers.append(Conv((3, 3, 64), name='conv1_1',
**conv_params)) # conv1_1
trunk_layers.append(Conv((3, 3, 64), name='conv1_2', **conv_params))
trunk_layers.append(Pooling(2, strides=2))
trunk_layers.append(Conv((3, 3, 128), name='conv2_1',
**conv_params)) # conv2_1
trunk_layers.append(Conv((3, 3, 128), name='conv2_2', **conv_params))
trunk_layers.append(Pooling(2, strides=2))
trunk_layers.append(Conv((3, 3, 256), name='conv3_1',
**conv_params)) # conv3_1
trunk_layers.append(Conv((3, 3, 256), name='conv3_2', **conv_params))
trunk_layers.append(Conv((3, 3, 256), name='conv3_3', **conv_params))
trunk_layers.append(Pooling(2, strides=2))
trunk_layers.append(Conv((3, 3, 512), name='conv4_1',
**conv_params)) # conv4_1
trunk_layers.append(Conv((3, 3, 512), name='conv4_2', **conv_params))
trunk_layers.append(Conv((3, 3, 512), name='conv4_3', **conv_params))
trunk_layers.append(Pooling(2, strides=2))
trunk_layers.append(Conv((3, 3, 512), name='conv5_1',
**conv_params)) # conv5_1
trunk_layers.append(Conv((3, 3, 512), name='conv5_2', **conv_params))
trunk_layers.append(Conv((3, 3, 512), name='conv5_3', **conv_params))
trunk_layers.append(Pooling(3, strides=1, padding=1))
trunk_layers.append(
Conv((3, 3, 1024), dilation=6, padding=6, name='fc6',
**params)) # fc6
trunk_layers.append(
Conv((1, 1, 1024), dilation=1, padding=0, name='fc7',
**params)) # fc7
trunk_layers.append(
Conv((1, 1, 256), strides=1, padding=0, name='conv6_1', **params))
trunk_layers.append(
Conv((3, 3, 512), strides=2, padding=1, name='conv6_2', **params))
trunk_layers.append(
Conv((1, 1, 128), strides=1, padding=0, name='conv7_1', **params))
trunk_layers.append(
Conv((3, 3, 256), strides=2, padding=1, name='conv7_2', **params))
# append conv8, conv9, conv10, etc. (if needed)
matches = [re.search('conv(\d+)_2', key) for key in self.ssd_config]
layer_nums = [
int(m.group(1)) if m is not None else -1 for m in matches
]
max_layer_num = np.max(layer_nums)
if max_layer_num is not None:
for layer_num in range(8, max_layer_num + 1):
trunk_layers.append(
Conv((1, 1, 128),
strides=1,
padding=0,
name='conv{}_1'.format(layer_num),
**params))
trunk_layers.append(
Conv((3, 3, 256),
strides=1,
padding=0,
name='conv{}_2'.format(layer_num),
**params))
layers = []
output_config = OrderedDict()
mbox_index = 1
for layer in self.ssd_config:
index = self.find_insertion_index(trunk_layers, layer)
conv_layer = self.get_conv_layer(trunk_layers, index)
branch_node = BranchNode(name=layer + '_branch')
trunk_layers.insert(index, branch_node)
leafs = self.generate_leafs(layer)
is_terminal = layer == 'conv{}_2'.format(max_layer_num)
# append leafs to layers
# mbox_loc_index and mbox_conf_index map to locations
# in the output list of the model.
if self.ssd_config[layer]['normalize']:
branch = self.create_normalize_branch(leafs, branch_node,
layer)
layers.append(branch)
mbox_loc_index = (mbox_index, 0)
mbox_conf_index = (mbox_index, 1)
mbox_index += 1
else:
if is_terminal:
trunk_layers.append(leafs['mbox_loc'])
mbox_loc_index = (0, )
else:
layers.append([branch_node, leafs['mbox_loc']])
mbox_loc_index = (mbox_index, )
mbox_index += 1
layers.append([branch_node, leafs['mbox_conf']])
mbox_conf_index = (mbox_index, )
mbox_index += 1
output_config[layer] = {
'layers': leafs,
'conv_layer': conv_layer,
'index': {
'mbox_conf': mbox_conf_index,
'mbox_loc': mbox_loc_index
}
}
layers.insert(0, trunk_layers)
return layers, output_config
train_data, valid_data, train_label, valid_label = gene.load_data(
ip_file_path, filename, names, validation_size=0.20)
train_iter = ArrayIterator(train_data,
train_label,
nclass=nclass,
lshape=(1, 4),
name='train')
val_iter = ArrayIterator(valid_data,
valid_label,
nclass=nclass,
lshape=(1, 4),
name='valid')
# weight
w = Xavier()
# bias
b = Constant()
# setup model layers
# fc1, Relu, dropout
# fc2, Relu, dropout
# fc3, Softmax, dropout
layers = [
Affine(nout=50, init=w, bias=b, activation=Rectlin()),
Dropout(keep=0.5),
Affine(nout=50, init=w, bias=b, activation=Rectlin()),
Dropout(keep=0.4),
Affine(nout=3, init=w, bias=b, activation=Softmax()),
Dropout(keep=0.3)
