def _rnn_convolution(X, n_filters, weight):
return layers.convolution(X=X,
n_filters=n_filters,
kernel_shape=(1, 1),
stride=(1, 1),
pad=(0, 0),
weight=weight,
no_bias=True)
def _normalized_convolution(network, kernel_shape, n_filters, stride, pad, weight=None, bias=None):
args = {'X' : network, 'kernel_shape' : kernel_shape, 'n_filters' : n_filters, 'stride' : stride, 'pad' : pad}
if weight is not None: args['weight'] = weight
if bias is not None: args['bias'] = bias
network = layers.convolution(**args)
network = layers.batch_normalization(network)
network = layers.ReLU(network)
return network
def _convolution(**kwargs):
defaults = {
'kernel_shape': (3, 3),
'stride': (1, 1),
'pad': (1, 1),
'no_bias': True
}
defaults.update(kwargs)
return layers.convolution(**defaults)
def _normalized_convolution(network, kernel_shape, n_filters, stride, pad):
network = layers.convolution(X=network,
kernel_shape=kernel_shape,
n_filters=n_filters,
stride=stride,
pad=pad)
network = layers.batch_normalization(network)
network = layers.ReLU(network)
return network
def _normalized_convolution(network, kernel_shape, n_filters, stride, pad):
args = {
'X': network,
'kernel_shape': kernel_shape,
'n_filters': n_filters,
'stride': stride,
'pad': pad
}
network = layers.convolution(**args)
network = layers.batch_normalization(network)
network = layers.ReLU(network)
return network
import mx_layers as layers
from mx_initializer import PReLUInitializer
from mx_solver import MXSolver
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('--gpu_index', type=int, default=0)
parser.add_argument('--n_residual_layers', type=int, required=True)
parser.add_argument('--postfix', type=str, default='')
args = parser.parse_args()
# TODO calculate receptive field
_convolution = lambda X: layers.convolution(
X=X, n_filters=16, kernel_shape=(5, 5), stride=(1, 1), pad=(2, 2))
network = layers.variable('data')
for index in range(3):
network = _convolution(network)
network = layers.ReLU(network)
network = layers.pooling(X=network,
mode='maximum',
kernel_shape=(2, 2),
stride=(2, 2),
pad=(0, 0))
shared_weight = layers.variable('shared_weight')
shared_gamma = layers.variable('shared_gamma')
shared_beta = layers.variable('shared_beta')
_convolution = lambda X: layers.convolution(
def _normalized_convolution(**args): network = layers.convolution(**args) network = layers.batch_normalization(network) network = layers.ReLU(network) return network
def _normalized_convolution(**kwargs):
network = layers.convolution(no_bias=True, **kwargs)
network = layers.batch_normalization(network, fix_gamma=False)
network = layers.ReLU(network)
return network
# TODO calculate receptive field
network = layers.variable('data')
for index in range(3):
network = _normalized_convolution(X=network, n_filters=16, kernel_shape=(5, 5), stride=(1, 1), pad=(2, 2))
network = layers.pooling(X=network, mode='maximum', kernel_shape=(2, 2), stride=(2, 2), pad=(0, 0))
shared_weight = layers.variable('shared_weight')
shared_gamma = layers.variable('shared_gamma')
shared_beta = layers.variable('shared_beta')
kwargs = {'n_filters' : 16, 'kernel_shape' : (3, 3), 'stride' : (1, 1), 'pad' : (1, 1)}
for index in range(configs.n_residual_layers):
network = ReLU(network)
network = layers.batch_normalization(network, beta=shared_beta, gamma=shared_gamma, fix_gamma=False)
identity = network
residual = layers.convolution(X=network, weight=shared_weight, no_bias=True, **kwargs)
network = identity + residual
network = layers.pooling(X=network, mode='average', global_pool=True, kernel_shape=(1, 1), stride=(1, 1), pad=(0, 0))
network = layers.flatten(network)
network = layers.fully_connected(X=network, n_hidden_units=10)
network = layers.softmax_loss(prediction=network, normalization='batch', id='softmax')
optimizer_settings = {'args' : {'momentum' : 0.9}, 'initial_lr' : 0.1, 'optimizer' : 'SGD'}
solver = MXSolver(
batch_size = 64,
devices = (configs.gpu_index,),
epochs = 30,
initializer = PReLUInitializer(),
optimizer_settings = optimizer_settings,
def _activated_convolution(**kwargs):
network = layers.convolution(**kwargs)
return layers.ReLU(X=network)
import mx_layers as layers
from mx_initializer import PReLUInitializer
from mx_solver import MXSolver
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('--gpu_index', type=int, required=True)
parser.add_argument('--n_residual_layers', type=int, required=True)
parser.add_argument('--postfix', type=str, required=True)
args = parser.parse_args()
_convolution = lambda network : \
layers.convolution(X=network, n_filters=16, kernel_shape=(5, 5), stride=(1, 1), pad=(2, 2), no_bias=True)
network = layers.variable('data')
for index in range(args.n_residual_layers):
network = layers.batch_normalization(network)
network = layers.ReLU(network)
network += _convolution(network)
network = layers.pooling(X=network,
mode='average',
kernel_shape=(56, 56),
stride=(1, 1),
pad=(0, 0))
network = layers.flatten(network)
network = layers.fully_connected(X=network, n_hidden_units=10)
network = layers.softmax_loss(prediction=network,
normalization='batch',
id='softmax')
