Ejemplo n.º 1
0
    def Setup(self):
        # self.ckpt = SSD_CKPT
        self.thres = SSD_THRES  
        self.nms_thres = SSD_NMS
        self.net_shape = SSD_NET_SHAPE

        # gpu_options = tf.GPUOptions(allow_growth=True)
        # config = tf.ConfigProto(log_device_placement=False, gpu_options=gpu_options)
        
        # self.isess = tf.InteractiveSession(config=config)

        # data_format = 'NHWC'
        # self.img_input = tf.placeholder(tf.uint8, shape=(None, None, 3))

        # image_pre, labels_pre, bboxes_pre, bbox_img = ssd_vgg_preprocessing.preprocess_for_eval(
        #                                 self.img_input, None, None, self.net_shape, data_format, 
        #                                 resize=ssd_vgg_preprocessing.Resize.WARP_RESIZE)
        
        # self.image_4d = tf.expand_dims(image_pre, 0)
        # self.bbx = bbox_img

        # reuse = True if 'ssd_net' in locals() else None
        ssd_net = ssd_vgg_512.SSDNet()
        # slim = tf.contrib.slim
        # with slim.arg_scope(ssd_net.arg_scope(data_format=data_format)):
        #     predictions, localisations, _, _ = ssd_net.net(self.image_4d, is_training=False, reuse=reuse)

        # self.isess.run(tf.global_variables_initializer())
        # saver = tf.train.Saver()
        # saver.restore(self.isess, self.ckpt)

        # self.pred = predictions
        # self.loc = localisations
        self.ssd_anchors = ssd_net.anchors(self.net_shape)
        self.total_classes = 21
Ejemplo n.º 2
0
    def __init__(self):

        # TensorFlow session: grow memory when needed. TF, DO NOT USE ALL MY GPU MEMORY!!!
        gpu_options = tf.GPUOptions(allow_growth=True)
        config = tf.ConfigProto(log_device_placement=False, gpu_options=gpu_options)

        # Input placeholder.
        self.net_shape = (512, 512)
        data_format = 'NHWC'
        self.img_input = tf.placeholder(tf.uint8, shape=(None, None, 3))
        # Evaluation pre-processing: resize to SSD net shape.
        image_pre, labels_pre, bboxes_pre, self.bbox_img = ssd_vgg_preprocessing.preprocess_for_eval(
            self.img_input, None, None, self.net_shape, data_format, resize=ssd_vgg_preprocessing.Resize.WARP_RESIZE)
        self.image_4d = tf.expand_dims(image_pre, 0)

        # Define the SSD model.
        reuse = True if 'ssd_net' in locals() else None
        ssd_net = ssd_vgg_512.SSDNet()
        with slim.arg_scope(ssd_net.arg_scope(data_format=data_format)):
            self.predictions, self.localisations, _, _ = ssd_net.net(self.image_4d, is_training=False, reuse=reuse)

        # Restore SSD model.
        ckpt_filename = 'tl_ssd_detector/checkpoint/model.ckpt-226812'
        self.isess = tf.Session(config=config)
        self.isess.run(tf.global_variables_initializer())
        saver = tf.train.Saver()
        saver.restore(self.isess, ckpt_filename)

        # SSD default anchor boxes.
        self.ssd_anchors = ssd_net.anchors(self.net_shape)
    def Setup():
        SSD.thres = SSD_THRES
        SSD.nms_thres = SSD_NMS
        SSD.net_shape = SSD_NET_SHAPE

        ssd_net = ssd_vgg_512.SSDNet()

        SSD.ssd_anchors = ssd_net.anchors(SSD.net_shape)
        SSD.total_classes = 21
    def __init__(self, params=None):
        # TensorFlow session: grow memory when needed. TF, DO NOT USE ALL MY GPU MEMORY!!!
        self.gpu_options = tf.GPUOptions(allow_growth=True)
        self.config = tf.ConfigProto(log_device_placement=False,
                                     gpu_options=self.gpu_options)
        # Input placeholder.
        self.net_shape = (512, 512) if MODEL == 512 else (300, 300)
        self.data_format = 'NHWC'
        self.img_input = tf.placeholder(tf.uint8, shape=(None, None, 3))
        # Evaluation pre-processing: resize to SSD net shape.
        self.image_pre, self.labels_pre, self.bboxes_pre, self.bbox_img = ssd_vgg_preprocessing.preprocess_for_eval(
            self.img_input,
            None,
            None,
            self.net_shape,
            self.data_format,
            resize=ssd_vgg_preprocessing.Resize.WARP_RESIZE)
        self.image_4d = tf.expand_dims(self.image_pre, 0)
        # Define the SSD model.
        try:
            tf.get_variable('ssd_512_vgg/conv1/conv1_1/weights'
                            ) if MODEL == 512 else tf.get_variable(
                                'ssd_300_vgg/conv1/conv1_1/weights')
            self.reuse = True  # if tf.variable_scope('ssd_300_vgg/conv1/conv1_1/weights') else None
        except ValueError:
            print('model loading failed')
            self.reuse = None
        self.ssd_net = ssd_vgg_512.SSDNet(
        ) if MODEL == 512 else ssd_vgg_300.SSDNet()
        with slim.arg_scope(
                self.ssd_net.arg_scope(data_format=self.data_format)):
            self.predictions, self.localisations, _, _ = self.ssd_net.net(
                self.image_4d, is_training=False, reuse=self.reuse)
        # Restore SSD model.
        self.ckpt_filename = './checkpoints/VGG_VOC0712_SSD_512x512_ft_iter_120000.ckpt' if MODEL == 512 else './checkpoints/ssd_300_vgg.ckpt'
        # SSD default anchor boxes.
        self.ssd_anchors = self.ssd_net.anchors(self.net_shape)

        self.isess = tf.InteractiveSession(config=self.config)
        # Load Model
        self.isess.run(tf.global_variables_initializer())
        self.saver = tf.train.Saver()
        self.saver.restore(self.isess, self.ckpt_filename)
Ejemplo n.º 5
0
    def load(self):
        try:
            data_format = 'NHWC'
            img_input = tf.placeholder(tf.uint8, shape=(None, None, 3))
            # Evaluation pre-processing: resize to SSD net shape.
            image_pre, labels_pre, bboxes_pre, bbox_img = ssd_vgg_preprocessing.preprocess_for_eval(
                img_input,
                None,
                None,
                self.net_shape,
                data_format,
                resize=ssd_vgg_preprocessing.Resize.WARP_RESIZE)
            image_4d = tf.expand_dims(image_pre, 0)

            # Define the SSD model.
            reuse = True if 'ssd_net' in locals() else None
            if self.net_to_use == 'ssd-300':
                ssd_net = ssd_vgg_300.SSDNet()
            else:
                ssd_net = ssd_vgg_512.SSDNet()

            with tf.contrib.slim.arg_scope(
                    ssd_net.arg_scope(data_format=data_format)):
                predictions, localisations, _, _ = ssd_net.net(
                    image_4d, is_training=False, reuse=reuse)

            # Restore SSD model.
            self.isess.run(tf.global_variables_initializer())
            saver = tf.train.Saver()
            saver.restore(self.isess, self.ckpt_filename)

            # SSD default anchor boxes.
            ssd_anchors = ssd_net.anchors(self.net_shape)
            cropper_model = SSD_Bundle(ssd_net, img_input, predictions,
                                       localisations, bbox_img, image_4d,
                                       ssd_anchors)
            return cropper_model
        except Exception as e:
            message = "Could not load model."
            print(message + str(e))
            raise Exception(message)
Ejemplo n.º 6
0
gpu_options = tf.GPUOptions(allow_growth=True)
config = tf.ConfigProto(log_device_placement=False, gpu_options=gpu_options)
isess = tf.InteractiveSession(config=config)

# Input placeholder.
net_shape = (512, 512)
data_format = 'NHWC'
img_input = tf.placeholder(tf.uint8, shape=(None, None, 3))
# Evaluation pre-processing: resize to SSD net shape.
image_pre, labels_pre, bboxes_pre, bbox_img = ssd_vgg_preprocessing.preprocess_for_eval(
    img_input, None, None, net_shape, data_format, resize=ssd_vgg_preprocessing.Resize.WARP_RESIZE)
image_4d = tf.expand_dims(image_pre, 0)

# Define the SSD model.
reuse = True if 'ssd_net' in locals() else None
ssd_net = ssd_vgg_512.SSDNet()
with slim.arg_scope(ssd_net.arg_scope(data_format=data_format)):
    predictions, localisations, _, _ = ssd_net.net(image_4d, is_training=False, reuse=reuse)

# Restore SSD model.
ckpt_filename = './checkpoints/VGG_VOC0712_SSD_512x512_ft_iter_120000.ckpt'
# ckpt_filename = '../checkpoints/VGG_VOC0712_SSD_300x300_ft_iter_120000.ckpt'
isess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(isess, ckpt_filename)

# SSD default anchor boxes.
ssd_anchors = ssd_net.anchors(net_shape)

# Main image processing routine.
def process_image(img, select_threshold=0.55, nms_threshold=.45, net_shape=(512, 512)):
Ejemplo n.º 7
0
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)

from nets import ssd_vgg_512
from nets import ssd_common

from preprocessing import ssd_vgg_preprocessing

ckpt_filename = '/mogu/liubang/mytf/SSD-Tensorflow/logs2/model.ckpt-122449'
NUM = 7

# SSD object.
reuse = True if 'ssd' in locals() else None
params = ssd_vgg_512.SSDNet.default_params
ssd_params = params._replace(num_classes=NUM)
ssd = ssd_vgg_512.SSDNet(ssd_params)

# Image pre-processimg
out_shape = ssd.params.img_shape
image_pre, labels_pre, bboxes_pre, bbox_img = \
    ssd_vgg_preprocessing.preprocess_for_eval(image, labels, bboxes, out_shape,
                                              resize=ssd_vgg_preprocessing.Resize.WARP_RESIZE)

image_4d = tf.expand_dims(image_pre, 0)

# SSD construction.
with slim.arg_scope(ssd.arg_scope(weight_decay=0.0005)):
    predictions, localisations, logits, end_points = ssd.net(image_4d,
                                                             is_training=False,
                                                             reuse=reuse)