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
Ejemplo n.º 3
0
    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()
Ejemplo n.º 4
0
    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
Ejemplo n.º 6
0
 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
Ejemplo n.º 7
0
    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
Ejemplo n.º 8
0
                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'])