def inference(input_tensor, phase):
"""
feed forward
:param input_tensor:
:param phase:
:return:
"""
encoder = vgg_encoder.VGG16Encoder(phase=phase)
with tf.variable_scope('inference'):
encode_ret = encoder.encode(input_tensor=input_tensor)
decode_logits = encode_ret['prob_output']
binary_seg_ret = tf.nn.softmax(logits=decode_logits)
prob_list = []
kernel = tf.get_variable('kernel', [9, 9, 1, 1], initializer=tf.constant_initializer(1.0/81), trainable=False)
with tf.variable_scope("convs_smooth"):
prob_smooth = tf.nn.conv2d(tf.cast(tf.expand_dims(binary_seg_ret[:, :, :, 0], axis=3), tf.float32), kernel, [1, 1, 1, 1], 'SAME')
prob_list.append(prob_smooth)
for cnt in range(1, binary_seg_ret.get_shape().as_list()[3]):
with tf.variable_scope("convs_smooth", reuse=True):
prob_smooth = tf.nn.conv2d(tf.cast(tf.expand_dims(binary_seg_ret[:, :, :, cnt], axis=3), tf.float32), kernel, [1, 1, 1, 1], 'SAME')
prob_list.append(prob_smooth)
processed_prob = tf.stack(prob_list, axis=4)
processed_prob = tf.squeeze(processed_prob)
binary_seg_ret = processed_prob
# Predict lane existence:
existence_logit = encode_ret['existence_output']
existence_output = tf.nn.sigmoid(existence_logit)
encode_ret['prob_output'] = binary_seg_ret
encode_ret['existence_output'] = existence_output
return encode_ret
def __init__(self, phase, net_flag='vgg'):
"""
"""
super(LaneNet, self).__init__()
self._net_flag = net_flag
self._phase = phase
self._encoder = vgg_encoder.VGG16Encoder(phase=phase)
return
def inference(input_tensor, phase):
"""
feed forward
:param input_tensor:
:param phase:
:return:
"""
encoder = vgg_encoder.VGG16Encoder(phase=phase)
encode_ret = encoder.encode(input_tensor=input_tensor)
return encode_ret
def inference(input_tensor, phase, name):
"""
feed forward
:param name:
:param input_tensor:
:param phase:
:return:
"""
with tf.variable_scope(name):
with tf.variable_scope('inference'):
encoder = vgg_encoder.VGG16Encoder(phase=phase)
encode_ret = encoder.encode(input_tensor=input_tensor,
name='encode')
return encode_ret
def __init__(self, phase, net_flag='vgg'):
"""
"""
super(LaneNet, self).__init__()
self._net_flag = net_flag
self._phase = phase
if self._net_flag == 'vgg':
self._encoder = vgg_encoder.VGG16Encoder(phase=phase)
elif self._net_flag == 'dense':
self._encoder = dense_encoder.DenseEncoder(l=20, growthrate=8,
with_bc=True,
phase=self._phase,
n=5)
return
def __init__(self, phase, net_flag='shuffle'):
"""
"""
super(ShuffleNetBinarySeg, self).__init__()
self._net_flag = net_flag
self._phase = phase
if self._net_flag == 'vgg':
self._encoder = vgg_encoder.VGG16Encoder(phase=phase)
elif self._net_flag == 'dense':
self._encoder = dense_encoder.DenseEncoder(l=20, growthrate=8,
with_bc=True,
phase=self._phase,
n=5)
elif self._net_flag == 'shuffle':
self._encoder = shuffle_encoder.ShuffleEncoder(phase=phase)
self._decoder = fcn_decoder.FCNDecoder(phase=phase)
return
def __init__(self, phase, net_flag='vgg'):
"""
:param phase:
:param net_flag:
"""
super(LaneNetBinarySeg, self).__init__()
self._phase = phase
self._net_flag = net_flag
if net_flag == 'vgg':
self._encoder = vgg_encoder.VGG16Encoder(phase=phase)
elif net_flag == 'dense':
self._encoder = dense_encoder.DenseEncoder(phase=phase,
L=20,
N=5,
growth_rate=8,
with_bc=True)
self._decoder = fcn_decoder.FCNDecoder()
def __init__(self, phase, net_flag='vgg'):
"""
"""
super(LaneNet, self).__init__()
self._net_flag = net_flag
self._phase = phase
if self._net_flag == 'vgg':
# 使用基于VGG16的特征编码类
self._encoder = vgg_encoder.VGG16Encoder(phase=phase)
elif self._net_flag == 'dense':
self._encoder = dense_encoder.DenseEncoder(l=20, growthrate=8,
with_bc=True,
phase=phase,
n=5)
# 确定使用一全卷积网络解码类
self._decoder = fcn_decoder.FCNDecoder(phase=phase)
return
def __init__(self, phase, net_flag='resnet'):
"""
"""
super(LaneNet, self).__init__()
self._net_flag = net_flag
self._phase = phase
if self._net_flag == 'vgg':
self._encoder = vgg_encoder.VGG16Encoder(phase=phase)
elif self._net_flag == 'resnet':
self._encoder = resnet2_encoder.RESNETEncoder(phase=phase)
elif self._net_flag == 'dense':
self._encoder = dense_encoder.DenseEncoder(l=20, growthrate=8,
with_bc=True,
phase=self._phase,
n=5)
self._decoder = myfcn_decoder.FCNDecoder()
return
def __init__(self, phase, net_flag='vgg'):
"""
Init for LaneNet class
"""
super(LaneNet, self).__init__()
self._net_flag = net_flag
self._phase = phase
if self._net_flag.lower() == 'vgg':
self._encoder = vgg_encoder.VGG16Encoder(phase=phase)
elif self._net_flag.lower() == 'dense':
self._encoder = dense_encoder.DenseEncoder(l=20, growthrate=8,
with_bc=True,
phase=phase,
n=5)
elif self._net_flag.lower() == 'enet':
# Need not encoder and decoder for enet.
return
self._decoder = fcn_decoder.FCNDecoder(phase=phase)
return
def __init__(self, phase, net_flag='vgg'):
"""
"""
super(LaneNet, self).__init__()
self._net_flag = net_flag
self._phase = phase
self._add_coord = coord_conv.AddCoords(CFG.TRAIN.IMG_HEIGHT,
CFG.TRAIN.IMG_WIDTH, False)
if self._net_flag == 'vgg':
self._encoder = vgg_encoder.VGG16Encoder(phase=phase)
elif self._net_flag == 'dense':
self._encoder = dense_encoder.DenseEncoder(l=20,
growthrate=8,
with_bc=True,
phase=phase,
n=5)
elif self._net_flag == 'mobile':
self._encoder = mobile_encoder.MobielnetV2Encoder(phase=phase)
self._decoder = fcn_decoder.FCNDecoder(phase=phase)
return
score = fused
deconv_final = self.deconv2d(inputdata=score, out_channel=64, kernel_size=16,
stride=8, use_bias=False, name='deconv_final')
score_final = self.conv2d(inputdata=deconv_final, out_channel=2,
kernel_size=1, use_bias=False, name='score_final')
ret['logits'] = score_final
ret['deconv'] = deconv_final
return ret
if __name__ == '__main__':
vgg_encoder = vgg_encoder.VGG16Encoder(phase=tf.constant('train', tf.string))
dense_encoder = dense_encoder.DenseEncoder(l=40, growthrate=12,
with_bc=True, phase='train', n=5)
decoder = FCNDecoder(phase='train')
in_tensor = tf.placeholder(dtype=tf.float32, shape=[None, 256, 512, 3],
name='input')
vgg_encode_ret = vgg_encoder.encode(in_tensor, name='vgg_encoder')
dense_encode_ret = dense_encoder.encode(in_tensor, name='dense_encoder')
decode_ret = decoder.decode(vgg_encode_ret, name='decoder',
decode_layer_list=['pool5',
'pool4',
'pool3'])
