def testSimpleOpGetRegularizer(self, use_batch_norm, use_partitioner,
scope):
# Tests the alive patern of the conv and relu ops.
# use_batch_norm: A Boolean. Inidcats if batch norm should be used.
# use_partitioner: A Boolean. Inidcats if a fixed_size_partitioner should be
# used.
# scope: A String. with the scope to test.
sc = self._batch_norm_scope() if use_batch_norm else []
partitioner = tf.fixed_size_partitioner(2) if use_partitioner else None
with tf.contrib.framework.arg_scope(sc):
with tf.variable_scope(tf.get_variable_scope(),
partitioner=partitioner):
final_op = op_regularizer_stub.build_model()
op_reg_manager = orm.OpRegularizerManager(
[final_op], op_regularizer_stub.MOCK_REG_DICT)
expected_alive = op_regularizer_stub.expected_alive()
with self.test_session():
conv_reg = op_reg_manager.get_regularizer(
_get_op(scope + '/Conv2D'))
self.assertAllEqual(expected_alive[scope],
conv_reg.alive_vector.eval())
relu_reg = op_reg_manager.get_regularizer(_get_op(scope + '/Relu'))
self.assertAllEqual(expected_alive[scope],
relu_reg.alive_vector.eval())
def testGroupingOps(self, tested_op):
th, size = 0.5, 11
image = tf.constant(0.5, shape=[1, 17, 19, 3])
conv1 = layers.conv2d(image, 5, [1, 1], padding='SAME', scope='conv1')
conv2 = layers.conv2d(image, 5, [1, 1], padding='SAME', scope='conv2')
res = tested_op(conv1, conv2)
reg = {
'conv1': np.random.random(size),
'conv2': np.random.random(size)
}
def regularizer(conv_op, manager=None):
del manager # unused
for prefix in ['conv1', 'conv2']:
if conv_op.name.startswith(prefix):
return op_regularizer_stub.OpRegularizerStub(
reg[prefix], reg[prefix] > th)
op_reg_manager = orm.OpRegularizerManager([res.op],
{'Conv2D': regularizer})
with self.test_session():
alive = op_reg_manager.get_regularizer(res.op).alive_vector.eval()
self.assertAllEqual(
alive, np.logical_or(reg['conv1'] > th, reg['conv2'] > th))
def __init__(self, ops, gamma_threshold):
gamma_l1_reg_factory = gamma_l1_regularizer.GammaL1RegularizerFactory(
gamma_threshold)
opreg_manager = op_regularizer_manager.OpRegularizerManager(
ops, {
'Conv2D': gamma_l1_reg_factory.create_regularizer,
'DepthwiseConv2dNative':
gamma_l1_reg_factory.create_regularizer
})
super(GammaFlopsRegularizer,
self).__init__(opreg_manager, bilinear_cost_utils.flop_coeff)
def __init__(self, ops, threshold):
# Regularizer factories for convolution and fully connected layers.
conv_regularizer_factory = (
conv_group_lasso_regularizer.ConvGroupLassoRegularizerFactory(
threshold))
regularizer_factories = {
'Conv2D': conv_regularizer_factory.create_regularizer,
'Conv2DBackpropInput': conv_regularizer_factory.create_regularizer,
}
# Create OpRegularizerManager instance.
opreg_manager = op_regularizer_manager.OpRegularizerManager(
ops, regularizer_factories)
super(GroupLassoFlopsRegularizer,
self).__init__(opreg_manager, bilinear_cost_utils.flop_coeff)
def testGetRegularizerForConcatWithNone(self, test_concat, depth):
image = tf.constant(0.0, shape=[1, 17, 19, 3])
conv2 = layers.conv2d(image, 5, [1, 1], padding='SAME', scope='conv2')
other_input = tf.add(
tf.identity(tf.constant(3.0, shape=[1, 17, 19, depth])), 3.0)
# other_input has None as regularizer.
concat = tf.concat([other_input, conv2], 3)
output = tf.add(concat, concat, name='output_out')
op = concat.op if test_concat else output.op
op_reg_manager = orm.OpRegularizerManager(
[output.op], op_regularizer_stub.MOCK_REG_DICT)
expected_alive = op_regularizer_stub.expected_alive()
with self.test_session():
alive = op_reg_manager.get_regularizer(op).alive_vector.eval()
self.assertAllEqual([True] * depth, alive[:depth])
self.assertAllEqual(expected_alive['conv2'], alive[depth:])
def testConcatOpGetRegularizer(self, use_batch_norm, use_partitioner):
sc = self._batch_norm_scope() if use_batch_norm else []
partitioner = tf.fixed_size_partitioner(2) if use_partitioner else None
with tf.contrib.framework.arg_scope(sc):
with tf.variable_scope(tf.get_variable_scope(),
partitioner=partitioner):
final_op = op_regularizer_stub.build_model()
op_reg_manager = orm.OpRegularizerManager(
[final_op], op_regularizer_stub.MOCK_REG_DICT)
expected_alive = op_regularizer_stub.expected_alive()
expected = np.logical_or(expected_alive['conv4'],
expected_alive['concat'])
with self.test_session():
conv_reg = op_reg_manager.get_regularizer(_get_op('conv4/Conv2D'))
self.assertAllEqual(expected, conv_reg.alive_vector.eval())
relu_reg = op_reg_manager.get_regularizer(_get_op('conv4/Relu'))
self.assertAllEqual(expected, relu_reg.alive_vector.eval())