class ConvolutionNet(ModelBase):
def __init__(self):
super(ConvolutionNet, self).__init__()
# Define symbols that using convolution and max pooling to extract better features
# from input image.
net = mx.sym.Variable(name='X')
net = mx.sym.Convolution(
data=net, name='conv', kernel=(7, 7), num_filter=32)
net = mx.sym.Activation(
data=net, act_type='relu')
net = mx.sym.Pooling(
data=net, name='pool', pool_type='max', kernel=(2, 2),
stride=(2, 2))
net = mx.sym.Flatten(data=net)
net = mx.sym.FullyConnected(
data=net, name='fc1', num_hidden=hidden_size)
net = mx.sym.Activation(
data=net, act_type='relu')
net = mx.sym.FullyConnected(
data=net, name='fc2', num_hidden=num_classes)
net = mx.sym.SoftmaxOutput(data=net, name='softmax', normalization='batch')
# Create forward function and add parameters to this model.
input_shapes = {'X': (batch_size,) + input_size, 'softmax_label': (batch_size,)}
self.cnn = Function(net, input_shapes=input_shapes, name='cnn')
self.add_params(self.cnn.get_params())
def forward_batch(self, batch, mode):
out = self.cnn(X=batch.data[0],
softmax_label=batch.label[0],
**self.params)
return out
def loss(self, predict, y):
return layers.softmax_cross_entropy(predict, y)
class ConvolutionNet(ModelBase):
def __init__(self):
super(ConvolutionNet, self).__init__()
# Define symbols that using convolution and max pooling to extract better features
# from input image.
net = mx.sym.Variable(name="X")
net = mx.sym.Convolution(data=net, name="conv", kernel=(7, 7), num_filter=32)
net = mx.sym.Activation(data=net, act_type="relu")
net = mx.sym.Pooling(data=net, name="pool", pool_type="max", kernel=(2, 2), stride=(2, 2))
net = mx.sym.Flatten(data=net)
net = mx.sym.FullyConnected(data=net, name="fc1", num_hidden=hidden_size)
net = mx.sym.Activation(data=net, act_type="relu")
net = mx.sym.FullyConnected(data=net, name="fc2", num_hidden=num_classes)
net = mx.sym.SoftmaxOutput(data=net, name="softmax", normalization="batch")
# Create forward function and add parameters to this model.
input_shapes = {"X": (batch_size,) + input_size, "softmax_label": (batch_size,)}
self.cnn = Function(net, input_shapes=input_shapes, name="cnn")
self.add_params(self.cnn.get_params())
def forward_batch(self, batch, mode):
return self.cnn(X=batch.data[0], softmax_label=batch.label[0], **self.params)
def loss(self, predict, y):
# Add L2 regularization for all the weights.
reg_loss = 0.0
for name, weight in self.params.items():
reg_loss += np.sum(weight ** 2)
return layers.softmax_cross_entropy(predict, y) + 0.5 * weight_decay * reg_loss
class ConvolutionNet(ModelBase):
def __init__(self):
super(ConvolutionNet, self).__init__()
# Define symbols that using convolution and max pooling to extract better features
# from input image.
net = mx.sym.Variable(name="X")
net = mx.sym.Convolution(data=net, name="conv", kernel=(7, 7), num_filter=32)
net = mx.sym.Activation(data=net, act_type="relu")
net = mx.sym.Pooling(data=net, name="pool", pool_type="max", kernel=(2, 2), stride=(2, 2))
net = mx.sym.Flatten(data=net)
# Create forward function and add parameters to this model.
self.conv = Function(net, input_shapes={"X": (batch_size,) + input_size}, name="conv")
self.add_params(self.conv.get_params())
# Define ndarray parameters used for classification part.
output_shape = self.conv.get_one_output_shape()
conv_out_size = output_shape[1]
self.add_param(name="w1", shape=(conv_out_size, hidden_size)).add_param(
name="b1", shape=(hidden_size,)
).add_param(name="w2", shape=(hidden_size, num_classes)).add_param(name="b2", shape=(num_classes,))
def forward(self, X, mode):
out = self.conv(X=X, **self.params)
out = layers.affine(out, self.params["w1"], self.params["b1"])
out = layers.relu(out)
out = layers.affine(out, self.params["w2"], self.params["b2"])
return out
def loss(self, predict, y):
return layers.softmax_loss(predict, y)
class ConvolutionNet(ModelBase):
def __init__(self):
super(ConvolutionNet, self).__init__()
# Define symbols that using convolution and max pooling to extract better features
# from input image.
net = mx.sym.Variable(name='X')
net = mx.sym.Convolution(data=net,
name='conv',
kernel=(7, 7),
num_filter=32)
net = mx.sym.Activation(data=net, act_type='relu')
net = mx.sym.Pooling(data=net,
name='pool',
pool_type='max',
kernel=(2, 2),
stride=(2, 2))
net = mx.sym.Flatten(data=net)
net = mx.sym.FullyConnected(data=net,
name='fc1',
num_hidden=hidden_size)
net = mx.sym.Activation(data=net, act_type='relu')
net = mx.sym.FullyConnected(data=net,
name='fc2',
num_hidden=num_classes)
net = mx.sym.SoftmaxOutput(data=net,
name='softmax',
normalization='batch')
# Create forward function and add parameters to this model.
input_shapes = {
'X': (batch_size, ) + input_size,
'softmax_label': (batch_size, )
}
self.cnn = Function(net, input_shapes=input_shapes, name='cnn')
self.add_params(self.cnn.get_params())
def forward_batch(self, batch, mode):
out = self.cnn(X=batch.data[0],
softmax_label=batch.label[0],
**self.params)
return out
def loss(self, predict, y):
return layers.softmax_cross_entropy(predict, y)
class ConvolutionNet(ModelBase):
def __init__(self):
super(ConvolutionNet, self).__init__()
# Define symbols that using convolution and max pooling to extract better features
# from input image.
net = mx.sym.Variable(name='X')
net = mx.sym.Convolution(data=net,
name='conv',
kernel=(7, 7),
num_filter=32)
net = mx.sym.Activation(data=net, act_type='relu')
net = mx.sym.Pooling(data=net,
name='pool',
pool_type='max',
kernel=(2, 2),
stride=(2, 2))
net = mx.sym.Flatten(data=net)
net = mx.sym.FullyConnected(data=net,
name='fc1',
num_hidden=hidden_size)
net = mx.sym.Activation(data=net, act_type='relu')
net = mx.sym.FullyConnected(data=net,
name='fc2',
num_hidden=num_classes)
net = mx.sym.SoftmaxOutput(data=net, name='output')
# Create forward function and add parameters to this model.
self.cnn = Function(net,
input_shapes={'X': (batch_size, ) + input_size},
name='cnn')
self.add_params(self.cnn.get_params())
def forward(self, X, mode):
out = self.cnn(X=X, **self.params)
return out
def loss(self, predict, y):
# Add L2 regularization for all the weights.
reg_loss = 0.0
for name, weight in self.params.items():
reg_loss += np.sum(weight**2) * 0.5
return layers.softmax_cross_entropy(predict,
y) + weight_decay * reg_loss
class ConvolutionNet(ModelBase):
def __init__(self):
super(ConvolutionNet, self).__init__()
# Define symbols that using convolution and max pooling to extract better features
# from input image.
net = mx.sym.Variable(name='X')
net = mx.sym.Convolution(data=net,
name='conv',
kernel=(7, 7),
num_filter=32)
net = mx.sym.Activation(data=net, act_type='relu')
net = mx.sym.Pooling(data=net,
name='pool',
pool_type='max',
kernel=(2, 2),
stride=(2, 2))
net = mx.sym.Flatten(data=net)
# Create forward function and add parameters to this model.
self.conv = Function(
net,
input_shapes={'X': (batch_size, ) + input_size},
name='conv')
self.add_params(self.conv.get_params())
# Define ndarray parameters used for classification part.
output_shape = self.conv.get_one_output_shape()
conv_out_size = output_shape[1]
self.add_param(name='w1', shape=(conv_out_size, hidden_size)) \
.add_param(name='b1', shape=(hidden_size,)) \
.add_param(name='w2', shape=(hidden_size, num_classes)) \
.add_param(name='b2', shape=(num_classes,))
def forward(self, X, mode):
out = self.conv(X=X, **self.params)
out = layers.affine(out, self.params['w1'], self.params['b1'])
out = layers.relu(out)
out = layers.affine(out, self.params['w2'], self.params['b2'])
# This verifies whether symbols can be reused.
trash = self.conv(X=np.zeros(X.shape), **self.params)
return out
def loss(self, predict, y):
return layers.softmax_loss(predict, y)
class ConvolutionNet(ModelBase):
def __init__(self):
super(ConvolutionNet, self).__init__()
# Define symbols that using convolution and max pooling to extract better features
# from input image.
net = mx.sym.Variable(name='X')
net = mx.sym.Convolution(
data=net, name='conv', kernel=(7, 7), num_filter=32)
net = mx.sym.Activation(
data=net, act_type='relu')
net = mx.sym.Pooling(
data=net, name='pool', pool_type='max', kernel=(2, 2),
stride=(2, 2))
net = mx.sym.Flatten(data=net)
# Create forward function and add parameters to this model.
self.conv = Function(
net, input_shapes={'X': (batch_size,) + input_size},
name='conv')
self.add_params(self.conv.get_params())
# Define ndarray parameters used for classification part.
output_shape = self.conv.get_one_output_shape()
conv_out_size = output_shape[1]
self.add_param(name='w1', shape=(conv_out_size, hidden_size)) \
.add_param(name='b1', shape=(hidden_size,)) \
.add_param(name='w2', shape=(hidden_size, num_classes)) \
.add_param(name='b2', shape=(num_classes,))
def forward(self, X, mode):
out = self.conv(X=X, **self.params)
out = layers.affine(out, self.params['w1'], self.params['b1'])
out = layers.relu(out)
out = layers.affine(out, self.params['w2'], self.params['b2'])
# This verifies whether symbols can be reused.
trash = self.conv(X=np.zeros(X.shape), **self.params)
return out
def loss(self, predict, y):
return layers.softmax_loss(predict, y)
