Harvesting Visual Objects from Internet Images via Deep Learning Based Objectness Assessment

TL;DR

This paper introduces a deep learning approach for assessing objectness in internet images, enabling the construction of a large, high-quality visual object database for various image applications.

Contribution

A novel deep convolutional neural network for objectness inference that improves proposal ranking and database quality over existing methods.

Findings

Re-ranked proposals outperform state-of-the-art methods.

Constructed a database of over 1.2 million visual objects.

Enhanced performance in data-driven image applications.

Abstract

The collection of internet images has been growing in an astonishing speed. It is undoubted that these images contain rich visual information that can be useful in many applications, such as visual media creation and data-driven image synthesis. In this paper, we focus on the methodologies for building a visual object database from a collection of internet images. Such database is built to contain a large number of high-quality visual objects that can help with various data-driven image applications. Our method is based on dense proposal generation and objectness-based re-ranking. A novel deep convolutional neural network is designed for the inference of proposal objectness, the probability of a proposal containing optimally-located foreground object. In our work, the objectness is quantitatively measured in regard of completeness and fullness, reflecting two complementary features of an optimal proposal: a complete foreground and relatively small background. Our experiments indicate that object proposals re-ranked according to the output of our network generally achieve higher performance than those produced by other state-of-the-art methods. As a concrete example, a database of over 1.2 million visual objects has been built using the proposed method, and has been successfully used in various data-driven image applications.

Tables

Table 1. Table 1 . The configuration of our network. Note that both sub-networks (green and blue parts in Figure  4 ) have the same structure of convolutional and pooling layers (the groups of “conv1”, “conv2”, “conv3”, “conv4”, “conv5” below)

GROUP	LAYER	TYPE	OUTPUT	PARAMETER	LAYER	TYPE	OUTPUT	PARAMETER
input	image	Input	$224\times 224\times 3\times 1$	-	boxes	Input	$4\times 256\times 1\times 1$	-
conv1$(\times 2)$	conv1_1	Convolution	$224\times 224\times 64\times 1$	kernel_size=3, filter_num=64, pad=1	relu1_1	ReLU	$224\times 224\times 64\times 1$	-
	conv1_2	Convolution	$224\times 224\times 64\times 1$	kernel_size=3, filter_num=64, pad=1	relu1_2	ReLU	$224\times 224\times 64\times 1$	-
	pool1	Pooling	$112\times 112\times 64\times 1$	type=max, kernel_size=2, stride=2	-	-	-	-
conv2$(\times 2)$	conv2_1	Convolution	$112\times 112\times 128\times 1$	kernel_size=3, filter_num=128, pad=1	relu2_1	ReLU	$112\times 112\times 128\times 1$	-
	conv2_2	Convolution	$112\times 112\times 128\times 1$	kernel_size=3, filter_num=128, pad=1	relu2_2	ReLU	$112\times 112\times 128\times 1$	-
	pool2	Pooling	$56\times 56\times 128\times 1$	type=max, kernel_size=2, stride=2	-	-	-	-
conv3$(\times 2)$	conv3_1	Convolution	$56\times 56\times 256\times 1$	kernel_size=3, filter_num=256, pad=1	relu3_1	ReLU	$56\times 56\times 256\times 1$	-
	conv3_2	Convolution	$56\times 56\times 256\times 1$	kernel_size=3, filter_num=256, pad=1	relu3_2	ReLU	$56\times 56\times 256\times 1$	-
	conv3_3	Convolution	$56\times 56\times 256\times 1$	kernel_size=3, filter_num=256, pad=1	relu3_3	ReLU	$56\times 56\times 256\times 1$	-
	pool3	Pooling	$28\times 28\times 256\times 1$	type=max, kernel_size=2, stride=2	-	-	-	-
	roi_pool3	ROI Pooling	$7\times 7\times 256\times 256$	type=max, grid_size=7	-	-	-	-
conv4$(\times 2)$	conv4_1	Convolution	$28\times 28\times 512\times 1$	kernel_size=3, filter_num=512, pad=1	relu4_1	ReLU	$28\times 28\times 512\times 1$	-
	conv4_2	Convolution	$28\times 28\times 512\times 1$	kernel_size=3, filter_num=512, pad=1	relu4_2	ReLU	$28\times 28\times 512\times 1$	-
	conv4_3	Convolution	$28\times 28\times 512\times 1$	kernel_size=3, filter_num=512, pad=1	relu4_3	ReLU	$28\times 28\times 512\times 1$	-
	pool4	Pooling	$14\times 14\times 512\times 1$	type=max, kernel_size=2, stride=2	-	-	-	-
	roi_pool4	ROI Pooling	$7\times 7\times 512\times 256$	type=max, grid_size=7	-	-	-	-
conv5$(\times 2)$	conv5_1	Convolution	$14\times 14\times 512\times 1$	kernel_size=3, filter_num=512, pad=1	relu5_1	ReLU	$14\times 14\times 512\times 1$	-
	conv5_2	Convolution	$14\times 14\times 512\times 1$	kernel_size=3, filter_num=512, pad=1	relu5_2	ReLU	$14\times 14\times 512\times 1$	-
	conv5_3	Convolution	$14\times 14\times 512\times 1$	kernel_size=3, filter_num=512, pad=1	relu5_3	ReLU	$14\times 14\times 512\times 1$	-
	roi_pool5	ROI Pooling	$7\times 7\times 512\times 256$	type=max, grid_size=7	-	-	-	-
fc	concat	Concatenation	$7\times 7\times 1280\times 256$	axis=1	-	-	-	-
	fc1	Fully-connected	$400\times 256\times 1\times 1$	neuron_num=400	bn_1	Batch-normalization	$400\times 256\times 1\times 1$	-
	nn_relu1	ReLU	$400\times 256\times 1\times 1$	-	dropout1	Dropout	$400\times 256\times 1\times 1$	-
	fc2	Fully-connected	$400\times 256\times 1\times 1$	neuron_num=400	bn_2	Batch-normalization	$400\times 256\times 1\times 1$	-
	nn_relu2	ReLU	$400\times 256\times 1\times 1$	-	dropout2	Dropout	$400\times 256\times 1\times 1$	-
output	fc3	Fully-connected	$1\times 256\times 1\times 1$	neuron_num=1	bn_2	Batch-normalization	$1\times 256\times 1\times 1$	-
	nn_relu3	ReLU	$1\times 256\times 1\times 1$	-	-	-	-	-

Table 2. Table 2 . Comparison of AUCs of precision and recall curves between models trained with different scoring schemes. Ours : scoring scheme described in Section  5.1 . Linear : scoring scheme with linear transfer functions (grey dash-lines in Figure  3 ). IOU : Intersection-over-union as proposal objectness scores.

Dataset	Precision Curve AUCs			Recall Curve AUCs
	IOU	Linear	Ours	IOU	Linear	Ours
VOC2012	29.11%	27.98%	31.15%	38.10%	38.75%	40.94%
VOC2007	26.73%	28.41%	29.12%	33.28%	32.38%	35.73%
SOS	29.28%	28.74%	30.34%	68.75%	69.65%	69.87%

Table 3. Table 3 . Comparison of AUCs of precision curves between models trained with different weights. w 𝑤 {w} : weight used in Equation  4 .

Dataset	Precision Curve AUCs
	w=0.35	w=0.4	w=0.45	w=0.5	w=0.55	w=0.6	w=0.65
COB+OA	30.32%	31.15%	28.17%	29.67%	29.59%	28.37%	29.32%
MCG+OA	26.66%	25.98%	25.44%	26.93%	26.40%	25.31%	26.08%
RPN+OA	36.19%	36.30%	36.67%	35.97%	36.26%	35.87%	34.99%

Table 4. Table 4 . Comparison of AUCs of precision and recall curves between models with and without the integration of our proposal objectness assessment network.

Dataset	Precision Curve AUCs						Recall Curve AUCs
	COB	COB+OA	MCG	MCG+OA	RPN	RPN+OA	COB	COB+OA	MCG	MCG+OA	RPN	RPN+OA
VOC2012	8.24%	31.15%	19.36%	26.93%	17.79%	36.67%	36.52%	40.94%	28.23%	31.15%	24.24%	36.52%
VOC2007	7.57%	29.12%	18.01%	25.05%	16.84%	34.49%	31.52%	35.73%	24.81%	27.30%	21.54%	28.28%
SOS	9.03%	30.34%	21.62%	28.02%	11.71%	27.81%	61.95%	69.87%	53.97%	58.10%	27.06%	43.61%

Table 5. Table 5 . Comparison of AUCs of precision and recall curves between models trained with different data preparations. bN : number of proposal windows (per image) generated during training.

Dataset	Precision Curve AUCs						Recall Curve AUCs
	bN=2000	bN=1500	bN=1000	bN=500	bN=100	bN=50	bN=2000	bN=1500	bN=1000	bN=500	bN=100	bN=50
VOC2012	31.28%	31.18%	31.15%	30.83%	28.53%	27.99%	40.44%	40.97%	40.94%	40.19%	40.02%	40.11%
VOC2007	29.10%	29.99%	29.12%	28.73%	27.58%	26.71%	36.15%	35.90%	35.73%	35.54%	34.68%	34.93%
SOS	30.19%	29.92%	30.34%	30.08%	28.51%	27.59%	70.16%	69.77%	69.87%	69.76%	69.22%	68.92%

Table 6. Table 6 . The effect of non-maximal suppression (NMS) on original object proposal generators. I : threshold of intersection-over-union (IOU) used in NMS. - : no NMS is used.

Dataset	Precision Curve AUCs (COB)								Precision Curve AUCs (RPN)
	–	I=0.9	I=0.8	I=0.7	I=0.6	I=0.5	I=0.4	I=0.3	–	I=0.9	I=0.8	I=0.7	I=0.6	I=0.5	I=0.4	I=0.3
VOC2012	8.24%	7.72%	6.93%	6.30%	5.89%	5.60%	5.32%	5.03%	19.36%	16.06%	11.97%	8.61%	6.85%	6.19%	6.55%	7.91%
VOC2007	7.57%	7.15%	6.49%	5.97%	5.62%	5.33%	5.09%	4.85%	18.01%	15.17%	11.17%	8.13%	6.44%	5.92%	6.35%	7.63%
SOS	9.03%	8.44%	7.52%	6.89%	6.47%	6.16%	5.84%	5.57%	21.62%	10.77%	8.09%	5.83%	4.50%	3.91%	3.95%	4.51%

Table 7. Table 7 . Comparison of AUCs of precision and recall curves of applying non-maximal suppression on object proposals re-ranked by our OA method. I : threshold of intersection-over-union (IOU) used in NMS. - : no NMS used.

Dataset	Precision Curve AUCs								Recall Curve AUCs
	–	I=0.9	I=0.8	I=0.7	I=0.6	I=0.5	I=0.4	I=0.3	–	I=0.9	I=0.8	I=0.7	I=0.6	I=0.5	I=0.4	I=0.3
VOC2012	31.15%	24.73%	16.93%	11.76%	9.19%	7.96%	7.26%	6.78%	40.94%	45.69%	48.90%	49.45%	46.40%	40.49%	35.48%	32.06%
VOC2007	29.12%	23.54%	16.23%	11.41%	8.95%	7.85%	7.23%	6.80%	35.73%	40.66%	43.87%	44.47%	41.58%	36.36%	32.08%	29.34%
SOS	30.34%	23.86%	16.40%	11.20%	8.80%	7.63%	7.00%	6.45%	69.87%	73.72%	77.73%	77.87%	73.23%	63.97%	56.52%	50.51%

Equations

$$\begin{array}{c}{C}_c=Area(I)/Area(G)\\ C_f=Area(I)/Area(P)\end{array}$$

$$S_f=\frac{1}{{1+q{e}^{-(\beta (C_f-\alpha )))}}^{1/\gamma }}$$

$$S_c={C_c}^2$$

$$S_{final}=w{S}_c+(1-w)S_f$$

$$L=\frac{1}{2N}\sum _{i=1}^N{\Vert S_i^p-S_i^g\Vert }_2^2$$

$$N_{picked}/N_{total}$$

Full text

Object Detection, Object Proposals, Objectness, Internet Images, Convolutional Neural Networks

*Corresponding author: Guanbin Li

This project was partially supported by the EU H2020 project-AniAge (No.691215) and the National Natural Science Foundation of China (No.61702565).

1. Introduction

Internet images have been growing in an astonishing speed in recent years. With daily increased popularity of online social media sites such as Instagram (ins, [n. d.]), Flickr (fli, [n. d.]), Facebook (fac, [n. d.]), etc., the number of internet images has become quite huge. For example, Flickr, which began in 2005, now hosts more than 13 billion images, and is continuously growing by the minute with more than 120 million active users. The rapid growth of internet images also brings up many applications that make a good use of this big data, such as image retrieval (Ma et al., 2017), stitching (Li et al., 2017b), recommendation (Zhang et al., 2017), image quality assessment (Guan et al., 2017), or benchmark dataset making (Yao et al., 2017), etc. It is also obvious that within these images the number and richness of contained objects are of great usefulness, especially in some data-driven applications related to object manipulation, such as object retrieval (Wang et al., 2011; Yang et al., 2011), classification (Lu et al., 2013), enhancement (Zhang et al., 2013), etc. Traditionally, searching for images that contain desired objects is done through online search engines such as Google Images, which utilizes content-based image retrieval techniques to find images that contain similar objects, or simply acquires images by their tagged information. However, images returned by a search engine can not be easily controlled, as they may be biased towards highly similar objects, or sometimes contain unwanted objects. This observation motivates building a rich object database that is tailored to support various demanding data-driven image applications.

However, mining objects from internet images is challenging. First, information regarding exact object location is not readily available within most internet images. For example, on Flickr (fli, [n. d.]) and Instagram (ins, [n. d.]), most image tags are “object types”, “object names”, “camera parameters”, ‘locations where pictures were taken”, etc. Second, there are usually problems like inter-class variation, object occlusion, and background cluttering within images taken by non-professional people (Cho et al., 2015; Wang et al., 2013). Third, to collect visual objects, the method should be class-agnostic, without any pre-defined object categories. Currently, there are many methods for locating objects, but most of them assume a predefined, finite set of object categories (Ren et al., 2015), resulting in limited objects to be discovered. Last but not the least, the object proposals should be of optimal sizes so that foreground objects are properly located within them. In this work, the term objectness is used to indicate the probability of an object proposal being optimal in location and size. We measure the objectness by two criteria: completeness and fullness. Completeness requires contained foreground to be complete, while fullness requires the background to be relatively small. Satisfying both completeness and fullness is important, especially in some data-driven image applications that require properly-cropped images, such as clip-art illustrations (Lalonde et al., 2007), image compositing (Snavely et al., 2006), imaginary scene synthesis (Chen et al., 2009), etc.

In this paper, we propose an object mining pipeline for building a database of objects from internet images. Our pipeline starts with object proposal generation using off-the-shelves methods. Typically for a proposal generator, several partially overlapping proposals are produced around a true object, and they only differ slightly in location, size and aspect ratio. Among these similar proposals, we need to discover the optimal ones that completely cover the objects, since most other proposals either cut off parts of the object (violating completeness) or contain too much background area (violating fullness). To this end, we design a deep convolutional neural network for objectness assessment, which is the cornerstone of the whole pipeline. The network architecture is based on the design of two sub-networks for extracting object-oriented features and edge-oriented features separately. For each object proposal box, grid-based spatial pooling is performed on multiple feature maps given by the convolutional layers, resulting in multi-scale aggregated features. Fully-connected layers are used for regression that gives the final objectness score. Quantitative experimental results and user study records indicate that top proposals given by our method exhibit higher performance in general.

In summary, this work has the following contributions:

• •

An effective pipeline for mining objects from internet images. This pipeline is based on dense object proposal generation and objectness assessment.

• •

A novel deep neural network for objectness assessment. The output of this network can be used to choose proposals that have optimal locations and sizes.

• •

A large database of objects that has been successfully used in some data-driven image applications, and can be of potential use in other applications as well, such as image style transferring, object co-segmentation, etc.

2. Related Work

2.1. Data-driven Image Editing

There are many applications that make use of large image collection, such as Lalonde et al. ’s “Photo Clip Art” (Lalonde et al., 2007). For a given location where new objects are to be inserted, the system searches within a large database to find objects with desired properties (i.e., category, resolution, camera pose, lighting, etc.). Similar idea is also exploited in scene synthesis, such as Hays et al. ’s work (Hays and Efros, 2007), where they perform image completion by querying for similar scenes as replacements for selected regions. The rapidly growing collection of internet image also enables synthesizing imaginary scenes using convenient user interaction, such as in “Sketch2Photo” (Chen et al., 2009), where user-drawn sketches are combined with text labels to find suitable background and foreground images for blending. The synthesized images can be quite convincing due to the richness and diversity of internet images that easily guarantee a reasonable combination of found objects and backgrounds. Wang et al. ’s work (Wang et al., 2014a) uses internet images on image extrapolation, where candidate contents near edges are obtained from a pre-built database using graph-matching over hierarchically-segmented patches. Aside from that, large image collection can also be useful in style transferring and colorization, such as Tsai et al. ’s automatic sky replacement algorithm (Tsai et al., 2016) that generates naturally looking images with various sky styles, and Chia et al. ’s image colorization system (Chia et al., 2011) that leverages the rich image contents from the internet. On the other hand, for exploring and visualizing a large set of images of the same scene, Snavely et al. present “Photo Tourism”, a system that recovers 3D viewing scene geometry by matching dense key feature points among photos taken from different angles (Snavely et al., 2006). Russell et al. propose to organize online text information to explore images within a reconstructed virtual scene (Russell et al., 2013).

A common key component within many data-driven image editing systems is a large image database that contains significantly diversified visual contents. More importantly, the images within should also be of good quality to be useful in real applications. Regarding object-oriented image editing applications, such as “Photo Clip Art” (Lalonde et al., 2007) and “Sketch2Photo” (Chen et al., 2009), the object images within the database should have two important features: complete and clear foregrounds and less interfering backgrounds. In multimedia area, there are many works related to material quality assessment, such as visual importance and distortion evaluation on images (Guan et al., 2017) and quality-of-experience rating on videos (Zhang et al., 2018). In this work, the “quality” to be assessed is different. The goal is to quantitatively measure image objectness that indicates the presence of foreground objects, instead of color, distortion, resolution, frame rate, etc.

2.2. Object Proposals and Objectness

For a given image, object proposals are referred to as bounding boxes that are likely to contain meaningful objects. The term objectness is usually used to indicate the probability of the presence of a foreground object (Li and Yu, 2018). Object proposals are usually generated by window sampling, followed by some searching or rating process to further narrow down optimal boxes to keep (Uijlings et al., 2013). It is straight-forward to use exhaustive searching over entire sampling space to obtain proposal windows (Harzallah et al., 2009). However, exhaustive searching is usually computationally expensive, forcing coarse sampling grids or low-level image features to be used in objectness calculation (Uijlings et al., 2013). Therefore, most state-of-the-art methods exploit more adaptive methods for searching proposal windows, such as randomly picking proposals with high object classification scores (Alexe et al., 2012), or merging image segments obtained from hierarchical segmentation using certain strategies (Uijlings et al., 2013; Arbeláez et al., 2014; Maninis et al., 2016; Xiao et al., 2015), etc. The measurement of objectness has been widely explored in object proposal generators that aim at locating target objects through a minimum number of proposal window hypotheses (Alexe et al., 2012). In Alexe et al. ’s work (Alexe et al., 2012), multiple measurements of objectness such as multi-scale saliency, edge density, super pixels straddling,  etc., are combined in a Bayesian framework to obtain final objectness scores. In Selective Search (Uijlings et al., 2013), hierarchical segmentation results are merged in a bottom-up fashion by similarities between adjacent regions. In MCG (Arbeláez et al., 2014), proposal windows are merged hierarchically using combinatorial grouping that maintains high achievable performance and are further sorted by a regression model trained on hierarchical features that can be computed efficiently. In Edge Box (Zitnick and Dollar, 2014), the number of contours that are completely contained in a bounding box is used as an indication of objectness. Other than directly rating proposals, Lu et al. ’s work uses a different strategy of rejecting bounding boxes that have no explicit closed contours (Lu et al., 2015).

Recently, deep convolutional neural networks (CNNs) have achieved great successe in image recognition (Krizhevsky et al., 2012; Simonyan and Zisserman, 2014) and object detection (Ren et al., 2015; Redmon et al., 2015). There are also successful attempts to apply deep CNNs to object proposal generation, such as Kuo et al. ’s Deep Box (Kuo et al., 2015) and Ghodrati et al. ’s Deep Proposal (Ghodrati et al., 2015). Recently, Ren et al. introduce a region proposal network to predict object bounding boxes and objectness scores simultaneously (Ren et al., 2015). Researchers have also been using neural networks in saliency detection (Li and Yu, 2016, 2018), which can also be used in measuring objectness in object proposal generation and instance-level segmentation (Li et al., 2017a). However, foreground objects in images are not always “salient” in images. There are also other works that apply fully convolutional networks to infer class-agnostic segmentation masks, along with their objectness scores (Pinheiro et al., 2015, 2016; Dai et al., 2016). More detailed discussion and evaluation on object proposal generators can be found in (Chavali et al., 2016). There are also some works that exploit the richness of internet images for locating objects, such as Tang et al. ’s object co-localization (Tang et al., 2014), or the detection models trained with internet images, such as those in Chen et al. ’s work (Chen et al., 2013b) and Divvala ’s work (Divvala et al., 2014).

In general, many object proposal generators are designed to serve as pre-processing tools for object detection which aims at locating objects by specific category labels. Achieving a high object recall is thus more important than the accuracy of proposal windows, as missing objects in this stage cannot be rediscovered in the next stage of object detection. However, from most recent successful data-driven image applications, we see an increasing requirement on the quality of the database, that accuracy of the detected objects is relatively more important than recall. Using most existing methods, proposals that are chosen may enclose incomplete objects or too much background contents that can interfere with critical image editing operations like segmentation, blending, etc.

3. Overview

Our pipeline for building an object database is illustrated in Figure 1. We first collect images from a widely-used photo sharing website, Flickr (fli, [n. d.]). All downloaded images go through a screening process that discards images with no clean foreground objects. The screening is done by applying a binary classifier that separates desired images from the rest. The next step is the generation of object proposals from all remaining images. We leave this task to many state-of-the-art methods such as MCG (Arbeláez et al., 2014), RPN (Ren et al., 2015), or COB (Maninis et al., 2016), etc. The proposal objectness assessment step that comes after (enclosed by red rectangle in Figure 1) is one of the major contributions of this paper. All object proposals are rated with objectness scores by a deep convolutional neural network that makes inferences on multi-scale object-oriented and edge-oriented features. After objectness assessment, we screen the object proposals by thresholding with respect to their scores, then sort the remaining proposals in descending order. A non-maximal suppression (NMS) is then used to reduce duplicated proposal boxes. Object proposals surviving all the above steps are used to build the database, which now contains more than 1.2 million individual visual objects.

The paper is organized as followed. Section 4 describes image collection and pre-processing steps. Section 5 defines network architecture and training process. Section 6 reports experimental results related to performance of the network. Section 7 lists some data-driven applications that can make use of the database.

4. Image Collection and Pre-processing

In this work, images are collected from Flickr. We search for images using preset 36 city geolocations, approximate search radius of 20 km and timespan between January 2005 and January 2015. To respect the rights and privacy of other internet users, we only download images licensed with the permission to redistribute derived works, such as the license of Creative Commons. The result of this process is a collection of approximately 3 million images, taking storage space of 300GB. These images should cover good geographical and cultural diversities around the world.

However, not all downloaded images can be useful for image editing applications. Some of the images, such as photos of the sky and distant mountains, appear to contain no meaningful objects. Images with crowded people, where severe occlusion often occur, can hardly be useful either. To reduce unnecessary processing that will not produce useful objects, we perform a screening process using a binary classification network that decides whether to keep a given image. The structure of the network is the same as the VGG-16 network for image classification (Simonyan and Zisserman, 2014) except that the number of neurons in the original softmax layer is changed to two, giving two probabilistic outputs (positive and negative) that indicate whether or not to keep an image. The weights of original VGG-16 network pre-trained on ImageNet are used to initialize this network, and further fine-tuned with our own training data. The training data consists of approximately 5000 images, hand-picked from the training sets of ImageNet (Krizhevsky et al., 2012), PASCAL VOC2007 (Everingham et al., [n. d.]a) and PASCAL VOC2012 (Everingham et al., [n. d.]b). We label half of these images as positive (having clear foreground objects) and the other half as negative (not having clear foreground objects). We remove those images predicted as negative by this binary classifier. After this screening step, we have approximately 1/3 of originally downloaded images left. It is possible that the binary classification can be over-fitting. However, in this work, the accuracy of the binary classifier is not important. The key point of this step is to remove as many useless images as possible, while the objects in some falsely rejected images can be easily compensated by those in other images since the whole collection of images is huge.

The space of all possible window locations within an image can be huge. Instead of directly searching for optimal windows, we use off-the-shelves object proposal generators for proposal box generation. Several methods are tried, including Selective Search (Uijlings et al., 2013), Edge Box (Zitnick and Dollar, 2014), MCG (Arbeláez et al., 2014), RPN from Faster R-CNN (Ren et al., 2015), and Deep Proposal (Ghodrati et al., 2015). In this work, we prefer fast proposal generation methods with good precision so that later our assessment network can indeed find optimal object proposals. It is worth mentioning that in this step, precision is relatively more important than recall since our method only re-ranks existing proposals. The problem of relatively low recall can be ignored due to the huge number of internet images, while poor precision will make the entire pipeline less effective. In our experiments, we use MCG (Arbeláez et al., 2014), COB (Maninis et al., 2016) and RPN (Ren et al., 2015) due to their relatively good precision and execution efficiency.

5. Objectness Assessment Network

We design a regression network that rates proposals based on objectness. For any given image and its proposal windows, the network will output scores that indicate probabilities of proposals being optimal in regard of enclosed objects. Note that the whole pipeline assumes that there are optimal proposals being produced by proposal generators, as our network does not generate new object proposals. This is actually a reasonable assumption due to the existence of many good object proposal generators (Uijlings et al., 2013; Arbeláez et al., 2014; Kuo et al., 2015; Maninis et al., 2016; Ren et al., 2015). The only problem is to find optimal ones among all generated proposals.

5.1. Objectness Assessment Criteria

The optimality of a given object proposal window is quantitatively measured with respect to two previously mentioned criteria: completeness and fullness. Completeness requires a foreground object to be entirely located within the proposal window, while fullness requires the background area to be relatively small compared to the foreground.

Denote proposal window as $P$, corresponding ground-truth box as $G$, and their intersected region as $I$. The completeness index $C_{c}$ and fullness index $C_{f}$ are calculated as Equation 1,

[TABLE]

where $Area(P)$, $Area(G)$, $Area(I)$ are the area of proposal window, ground-truth box and intersected box, respectively. The calculation is also illustrated in Figure 2. For both $C_{c}$ and $C_{f}$, the more intersected area within the ground-truth box, the higher quantity they take, with the worst case being both terms take [math] for no intersection, and the best case that both terms are $1$ for complete overlapping. However, although their calculation is similar, these two terms measure different aspects of proposal optimality and complement each other in various cases. For example, when the proposal box entirely encloses the ground-truth box, $C_{c}=1$, indicating good completeness, while $C_{f}$ measures the percentage of area within proposal box that is occupied by an actual object. Similarly, when the ground-truth box entirely encloses the proposal box, $C_{f}=1$, meaning good fullness, while $C_{c}$ measures how much of the actual object is enclosed by the proposal window. The separated calculation of completeness index and fullness index also enables handling completeness and fullness differently by using different “transfer functions” on them.

The completeness score and fullness score are computed based on previously obtained completeness index and fullness index, by using “transfer functions” to control the contribution of each index to the score. The calculation is illustrated in Figure 3. Completeness score and fullness score are denoted as $S_{c}$ and $S_{f}$, respectively. For fullness score, we are relatively tolerant when there is only a small background area within proposal window, but make the score drop quickly when the index is below certain threshold. Generalized logistic functions are ideal for this purpose. We use a simplified logistic function,

[TABLE]

where $\alpha$ and $\beta$ are scaling parameters that map the desired portion of logistic function to the range of $0.0-1.0$. $\gamma$ controls the slope of the curve, and $q$ controls the threshold where the curve starts to drop rapidly. Figure 3(a) illustrates the logistic function we use. It can be seen in Figure 3(a) that $q$ generally controls the tolerant threshold of fullness index. The score drops relatively slower when $C_{f}$ is near $1$, but decreases quickly to [math] once $C_{f}$ is below the approximate threshold of $0.5$. In all our experiments, $\alpha=0.5$, $\beta=12$, $\gamma=0.6$, $q=1$.

As for completeness score, we prefer to be less tolerant about objects being cut off by proposal window borders. Thus, we let completeness score drop rapidly even when a small part of the annotated object is cut off. This can be done by quadratic function,

[TABLE]

It can be seen in Figure 3(b) that near $1.0$ even a small dropping of completeness index will result in large decreasing of completeness score. This enforces a large penalty for missing object parts within the proposal window.

The final ground-truth objectness score is a weighted score of completeness score and fullness score:

[TABLE]

where $w$ is a weight parameter. It generally reflects how we treat a proposal box regarding the satisfaction of “completeness” and “fullness”. Smaller values of w indicate that we value “fullness” more over “completeness”, and vice versa. $w$ is tuned by a training process described in Section 6.2.

5.2. Network Architecture

We aim to design an end-to-end assessment method as a deep regression network, which takes an image and its associated object proposals as input, and predicts objectness scores on the scale of $0.0-1.0$. These scores should reflect how likely each of the proposal windows is in optimal location. The output of the network is a vector, with each element corresponding to one score of an input object proposal.

To conceive such an end-to-end architecture, we have the following considerations. First, the network should utilize both object-oriented and edge-oriented features, as we believe both region and edge features to be important clues for optimal proposal box locations. Object-oriented features can tell whether a proposal window contains an object while edge-oriented features provide additional evidence related to completeness and fullness (for example, a salient edge intersecting the border of a proposal window is a clear indication of missing some object parts). Second, the network should consider high-level features as well as mid-level features when inferring objectness as the former supplies semantic information at the scale of whole objects while the latter supplies semantic information at the scale of object parts. Last but not the least, the network should be very efficient and end-to-end trainable, meaning that only necessary computation is performed, and the interface for applications should be simple.

As shown in Figure 4, our proposed network architecture is composed of two parallel convolutional layer groups for feature extraction, and two fully connected layers for objectness score regression. We modify the original VGG network by removing its fully connected layers and attaching an ROI pooling layer to each of the last three convolutional layers. An ROI pooling layer basically performs single-scale spatial pyramid pooling (He et al., 2014) that divides each region of interest into a uniform grid of $H\times W$ cells and performs pooling independently within each grid cell. In this work, we use the grid size of $7\times 7$ for ROI pooling, following Faster R-CNN (Ren et al., 2015). The outcome of ROI pooling is a fixed-length feature vector, which is the concatenation of max-pooling responses at all grid cells.

The two modified VGG networks in our architecture are used for extracting different types of features. One is for object-oriented features (blue parts in Figure 4), the other is for edge-oriented features (green parts in Figure 4). It is important to include edge detection layers (green layers in Figure 4) as features extracted with the aim of edge detection contain information of potential object boundary locations, which is closely related to the criteria of completeness and fullness and the inference of the final objectness score. For each proposal window, we concatenate the results of six ROI pooling layers and feed them to two fully connected layers for final score prediction. Note that one forward pass of our network can compute the scores for all proposal windows associated with a single input image. This architecture maximizes the throughput of the network, avoids redundant feature map computation, and provides simple interface for practical applications.

Note that a modified VGG with an ROI pooling layer has been used in (Ren et al., 2015). However, in their work ROI pooling is only applied to a single convolutional layer (“conv5_3”), followed by a simple softmax layer. Although the features computed from “conv5_3” can well characterize semantic information, it is of very low resolution and cannot identify proposal bounding boxes with high-precision. Table 1 gives the configuration of all layers in our network.

5.3. Network Training

The training data for our proposal assessment network includes a set of training images along with a list of annotated ground-truth bounding boxes associated with training images. Each ground-truth bounding box optimally encloses a single visual object. For each training image, we empirically generate 1000 object proposals using an object proposal generator. The ground-truth scores of these object proposals are calculated according to methods described in Section 5.1. In practice, for each object proposal, we compute its score with respect to every annotated ground-truth bounding box within the image and take the highest one as its final ground-truth score.

The loss function during network training is defined as the mean squared difference between predicted scores and ground-truth scores, averaged over a training batch. Given a mini-batch containing $N$ proposal windows, the training loss is computed as,

[TABLE]

where $S_{i}^{p}$ and $S_{i}^{g}$ are respectively the predicted score and ground-truth score of the $i$-th proposal window within the batch. $S_{i}^{g}$ is calculated according to Equation 4.

In this work, all experiments are carried out using Caffe (Jia et al., 2014), with a few of our own customized layers. Note that the assessment of object proposals has stringent criteria about completeness and fullness, and is generally more challenging than conventional object detection, which only requires a positive proposal window to have more than 50% overlap with a ground-truth bounding box. Yet, we only have limited training data.

Instead of training the entire network from scratch, we make use of existing models by fine-tuning their pre-trained weights. Two pre-trained models are used in this work. One is for object detection (Ren et al., 2015), and the other is for edge detection (Xie and Tu, 2015). We only take the weights of the convolutional layers in these two pre-trained networks, and the weights of fully connected regression layers are randomly initialized. In the beginning, all weights in the convolutional layers and fully connected layers are trained with respect to the training loss of Equation 5. However, through our experiments, we find out that fine-tuning convolutional layers along with fully connected layers does not give better performance. In fact, as the result of our experiments suggests, tuning convolutional layers results in slightly worse performance. On VOC2012, approximately 0.6% worse precision and 0.3% worse recall are observed. We believe the small drop of performance is due to some over-fitting in convolutional layers that worsen the feature extraction capabilities on different groups of layers. This is a reasonable assumption due to the fact that the training data used is far from sufficient compared to the network parameters.

The training data is prepared as following. First, we extract top 1000 object proposals within each image. The proposal boxes are then augmented with random shifting or magnifying/reducing along two dimensions by maximum 20%, resulting in additional 1000 object proposals for each image. Second, for all generated proposals, their ground-truth scores are calculated according to Section 5.1. Third, the proposals within each image are randomly sampled to be used in network training. Note that the scores may concentrate around certain regions, depending on the performance of specific proposal generators. For example, proposal windows produced by better generators may contain more boxes with ground-truth objectness scores over 0.5 than those scored below 0.5. This requires us to do sampling carefully such that the training data is evenly distributed in different ground-truth score ranges. In this work, we sample proposals according to their respective ground-truth score ranges. For each image, we calculate the histogram of ground-truth scores over all proposals, then randomly sample boxes within each histogram bin to maintain a generally even distribution of scores for training. The training images are randomly divided into 5 disjoint sets, one of which is used as validation set during training.

During the training stage, each mini-batch contains one image and at most 256 proposal windows. For the sake of correctness and efficiency of training, the proposal windows included in a mini-batch are always generated from the same image. Gradients of layer weights with respect to the training loss are calculated using finite difference and backward propagation, while weights updating is through stochastic gradient descent. In addition, we use a batch normalization layers (Ioffe and Szegedy, 2015) for larger base learning rate and faster convergence. The initial learning rate is set to 0.001, momentum parameter is 0.9 and the weight decay is 0.0005. We test the model performance with respect to validation set at the end of each epoch. After each epoch, the order of images and proposal boxes are randomly shuffled. A k-fold cross-validation with $k=5$ is used here. The configuration of our deep-learning server: Ubuntu 14.04 64-bit (OS), Intel Xeon E5-2699-v3 2.30GHz (64 CPUs), Nvidia GTX Titan X 6GB (1 GPU), 128GB (RAM).

6. Experimental Results

6.1. Datasets and Evaluation Criteria

We evaluate our method on three public datasets: PASCAL VOC 2007 (Everingham et al., [n. d.]a), PASCAL VOC 2012 (Everingham et al., [n. d.]b) and SOS (Zhang et al., 2015). PASCAL VOC 2007 and PASCAL VOC 2012 contain 9963 and 11540 images respectively with fully annotated bounding boxes for 20 object categories. As we focus on class-agnostic object locating, we only use bounding box locations in these datasets for training and evaluation. To conduct fair comparison, we train our network on the same training data that is used by the other object proposal generators. To evaluate the generalization performance of our trained networks, we also test their performance on the SOS dataset, a group of 5244 images hand-picked from COCO (Lin et al., 2014), ImageNet (Russakovsky et al., 2015), SUN (Xiao et al., 2010), and PASCAL VOC (Everingham et al., [n. d.]a, [n. d.]b). 3951 images in the SOS dataset have been annotated with class-agnostic object windows. Since we train our networks on PASCAL VOC datasets, we remove images in SOS dataset that come from VOC datasets. In the end, 3086 annotated images are left in the SOS dataset for our experiments.

When we compare our method with other state-of-the-art proposal generators, we adopt three criteria, precision rate, recall rate and mean ground-truth score. The precision rate is the percentage of detected objects among all object proposals, while the recall rate is the percentage of detected objects among all ground-truth objects. One important factor in calculating precision and recall is to decide whether or not an object proposal is selected. In our experiments, a proposal is selected to be any proposal window with intersection-over-union (IOU) between it and a ground-truth box reaches 0.7. Note that this is relatively a high IOU threshold, compared to what is commonly used in object detection applications. In this work, precision and recall are discussed separately with respect to different numbers of top proposals. For some models trained with specific settings, the performance of area-under-curve (AUC) is also reported. In addition, we adopt the mean ground-truth score as the third criterion, which also reflects the general quality of top-ranked proposals. The ground-truth score of a proposal window is calculated using methods described in Section 5.1.

6.2. Optimizing Ground-truth Scoring Schemes

In this work, The weighting parameter $w$ in Equation 4 is decided according to the network performance on the validation set of PASCAL VOC2012. We use the same network structure in Section 5.2 and the same training parameters in Section 5.3. The $w$ is selected such that the network gives the best precision on validation data. In our experiments, several $w$ values are tested. Table 3 shows the performance comparison on testing data among models trained with different weights. In our experiments, the optimal $w$ turns out to be dependent on proposal generators (Table 3). In the rest of the paper, we report the performance of the network trained on proposals generated by COB, unless specified otherwise.

We also try linear transfer functions for calculating completeness score and fullness score, namely, $S_{linear}=wC_{c}+(1-w)C_{f}$, as plotted by grey dashed lines in Figure 3. The results are in Table 2 (“Linear”). On all testing data (VOC2012, VOC2007, SOS), the precision and recall of the network trained using linear transfer functions are generally worse than those trained with non-linear transfer functions described in Section 5.1, by approximately 1%-3% regarding precision and by up to 3% regarding recall. The reason should be that the non-linear transfer functions used in this work enlarge the gap between the scores of high-objectness and low-objectness proposals, giving rise to improved precision and recall when top-ranked proposal windows within each image are considered. The using of non-linear transfer functions also offers flexibility in dealing with completeness and fullness differently, such as tolerating insignificant violation of fullness (using generalized logistic function) and penalizing any violation of completeness (using quadratic function).

Intuitively, instead of using methods described in Section 5.1, a straightforward idea of calculating ground-truth scores is to directly use IOU between proposal box and ground-truth box in network training. However, in our experiments, we find that using IOU instead of our proposed method leads to up to 3% worse precision and up to 2% worse recall, as suggested by Table 2. The reason should be that IOU only captures limited information (i.e., the percentage of overlap area between two boxes), but does not reflect the positional relationship between them.

6.3. Comparison with State of the Art Methods

Our proposal objectness assessment network takes an image and its object proposals as input and returns objectness scores, which are used to re-rank the original object proposals. We have tried several proposal methods in building the network. In the rest of the paper, each proposal objectness assessment network is denoted as “¡Proposal Generator Name¿+OA”. For example, network trained on COB proposals is denoted as “COB+OA”. We compare COB+OA against nine state-of-the-art object proposal generators, including Objectness Measure (Alexe et al., 2012), Contour Box (Lu et al., 2015), Selective Search (Uijlings et al., 2013), Edge Box (Zitnick and Dollar, 2014), MCG (Arbeláez et al., 2014), COB (Maninis et al., 2016), Deep Box (Kuo et al., 2015), Deep Proposal (Ghodrati et al., 2015), and RPN (Ren et al., 2015). The last four are the latest deep learning based methods. We use their publicly released models and suggested parameters for the reproduction of their best results. We evaluate the precision and recall rates over three datasets: the validation set of PASCAL VOC 2012, the testing set of PASCAL VOC 2007 and our customized SOS dataset.

As shown in Figure 5, when at most 50 top-ranked proposal windows per image are considered, our method (COB+OA) significantly outperforms all other participating methods across all testing datasets in terms of both precision and recall. Specifically, Figures 5(a), 5(b) and 5(c) respectively report precision with respect to the number of top proposals. The AUCs (Areas Under Curve) of our hybrid method (COB+OA) are 31.15%, 29.12% and 30.34%, which improve those achieved by the best-performing existing algorithm by 11.78%, 11.11% and 8.72%, respectively, on PASCAL VOC 2012, PASCAL VOC 2007 and our customized SOS dataset. When the number of considered proposal windows further increases, the advantage of our method in terms of precision rate diminishes. However, in our case, each image can hardly contain too many useful objects. Therefore, with a proper non-maximal suppression threshold, checking only highly-ranked proposals is enough for extracting good objects. The precision of our method also confirms that a significant improvement can be achieved through re-ranking existing object proposal windows. As for the recall rate, as shown in Figures 5(d), 5(e) and 5(f), our method also noticeably outperforms all other participating methods. The AUCs of our method (COB+OA) are 4.42%, 4.21% and 10.31% higher than those achieved by the best-performing existing algorithm, respectively, on PASCAL VOC 2012, PASCAL VOC 2007 and the screened SOS dataset. This implies that our method can include more ground-truth objects into the database than other methods when highly-ranked proposals are considered.

6.4. General Effectiveness of Proposal Objectness Assessment

In this section, we verify that our network has performance gains on top of most object proposal methods. To this end, we check the performance of a few object proposal methods and their respective assessment networks. For each of the object proposal methods, we train a new objectness assessment network using proposal windows generated by that method. To conduct a fair comparison, only the original training data used for an object proposal method is used to train its associated network. For example, if the image set “trainval” in PASCAL VOC 2007 is used in training MCG, we only use the same image set in training our corresponding network. All the networks are trained using the same settings as described in Section 5.3.

We evaluate the effectiveness of our method on three state-of-the-art object proposal methods, RPN (Ren et al., 2015), MCG (Arbeláez et al., 2014) and COB (Maninis et al., 2016), and report the precision, recall and mean ground-truth score on the same testing set used in Section 6.3. As shown in Figure 6(a), 6(b), and 6(c), our method significantly improves the precision of all three original object proposal methods. Specifically, as reported in Table 4, our method boosts AUCs of the original COB, MCG and RPN by 22.90%, 7.57% and 18.88%, respectively, on the validation set of PASCAL VOC 2012. Meanwhile, as shown in Figures 6(d), 6(e) and 6(f), our method also improves the recall rate of all three original object proposal methods, increasing their AUCs by 4.42%, 2.92% and 12.28%, respectively, on PASCAL VOC 2012. We can observe similar performance gains on the other two datasets from Table 4.

Figure 6(g), 6(h), and 6(i) show the mean ground-truth scores evaluated on different methods. Our method significantly improves the mean ground-truth scores of all three original object proposal methods using our own standards. These results confirm that our objectness assessment network can be used as a generic tool for improving the accuracy of object proposal methods.

6.5. Ablation Study of Network Architecture

An ablation study is conducted to verify the effectiveness of the proposed network architecture. We replace the two parallel sub-networks in our architecture with simpler versions. One of them has the same convolutional layers as Faster R-CNN (Ren et al., 2015), but has only one sub-network for feature extraction. The ROI pooling is only applied on “conv5-3” layer, further followed by fully connected layers. The other simpler version does not have the second sub-network for edge-oriented feature extraction but keeps multi-scale ROI pooling. The fully connected layers receive concatenated features from the ROI pooling layers associated with “conv3-3”, “conv4-3” and “conv5-3” respectively. These three networks are trained on the PASCAL VOC 2012 training set using the same settings described in Section 5.3. The testing results on PASCAL VOC 2012 are shown in Figure 7, which includes precision (Figure 7(a)), recall (Figure 7(b)) and the mean ground-truth score. It is clearly shown that our network architecture delivers better performance than the two simpler alternatives.

6.6. Number of Object Proposals Generated during Training

We investigate how the number of proposals generated during the training stage can affect the performance of assessment network. In data preparation, we empirically generate 1000 proposal windows per image. However, this number can vary in practical cases, depending on the fact that how many proposals are enough for achieving good precision and recall. As it is obvious that less generated proposals mean better efficiency of the whole pipeline. However, reducing generated proposals also reduces the richness of training data. Although we have data augmentation, the richness of training data can only be improved to a certain extent. Table 5 shows the performance when different numbers of proposal windows (per image) are generated during training stages. It can be seen in Table 5 that changing the number of bounding boxes from 1000 to 500 does not negatively affect the performance much (approximately within 1% difference regarding precision and recall). However, if the generated proposals are too few, the performance can decrease significantly, with the precision dropping by around 2%-3%. In our experiments, increasing the number of proposals from 1000 to 2000 does not significantly affect the performance, with precision and recall within 1% difference.

6.7. Non-maximal Suppression

Non-maximal suppression (NMS) is a useful technique for removing similar proposal boxes. In this work, several NMS-related experiments are conducted. First, we check how NMS will affect the performance of original proposal methods. Second, we apply NMS on the re-ranked proposals by our assessment network and check the performance again.

6.7.1. NMS on Object Proposals Generated Using Existing Methods

Table 6 shows the performance when NMS with different intersection-over-union (IOU) thresholds are applied on object proposals. Here we use COB (Maninis et al., 2016) and RPN (Ren et al., 2015) for proposal generation. It can be seen clearly that both precision of COB and RPN drop quickly as the threshold decreases (Table 6). This is due to that some inaccurate proposal boxes are falsely rated with high scores, misleading NMS to remove many high-objectness proposals near them. This is not desirable by our method, since it does not create new proposals. If the proposals are generally of low objectness, it is less-likely that our method can do any better. In this work, we recommend using NMS with larger thresholds (such as $>=0.7$) on proposals before performing assessment on object proposals.

6.7.2. NMS on Object Proposals Re-ranked by Proposal Objectness Assessment

Table 7 shows the performance of our method, with NMS being applied on re-ranked proposals. Compared to COB and RPN, our model still clearly outperforms them under the same IOU thresholds. When the threshold decreases, the precision drops quickly. The selection of the IOU threshold is empirical and subject to specific applications. In our pipeline of object mining, we use the threshold of 0.5 in building the object database.

6.8. User Studies

Although quantitative results in the previous section have demonstrated the effectiveness of our method, it still needs to be confirmed that such improvement does have positive impact on obtained object database and visual searching results.

From the same image collection downloaded from Flickr, we build three object databases using our method and other state-of-the-art object proposal methods. As we are more concerned about precision, we choose two existing object proposal methods with good precision performance, MCG (Arbeláez et al., 2014) and RPN (Ren et al., 2015). For MCG and RPN, top 50 proposal windows are generated for each image and are screened by non-maximum suppression, removing duplicated objects. For our method, the object mining pipeline described in Section 3 is used.

During this user study, each user is given a series of test cases. Within each test case, a query image is used to retrieve top-ranked 50 images from each of the three databases. Three groups of retrieved images are shown to each user in a random order, and the user is asked to pick all “good” objects. For the selection of “good” objects, the user is told to select those images having objects in good condition (satisfying completeness and fullness). We choose 30 query images as 30 test cases, which are evenly distributed to 30 participants. Each participant receives 3 test cases consisting of 9 groups of images in total. Among all participants, 15 people have certain level of knowledge of image editing, while the rest 15 people have not.

Given a participant and an object database, we quantify the score of the database as the percentage of objects picked by user,

[TABLE]

where $N_{picked}$ and $N_{total}$ are the number of objects picked by the participant and the total objects within the database, respectively. The quantity indicates the “purity” of good objects within a given database. For all three databases, we calculate their averaged scores over results obtained from 30 participants. According to records of the user study. The database built using our method has significantly better quality. Specifically, 57.58% of objects from our database are picked in comparison to 34.50% for MCG and 19.15% for RPN.

7. Application

7.1. Accessing Object Database

Figure 8 shows some of the objects obtained from Flickr using our method. Since our method performs class-agnostic visual object discovery and locating from internet images, objects in our object database are not associated with any specific category labels. Therefore, locating a desired object relies on visual search. To make our object database easy to access, we provide two types of query interfaces, one is content based image retrieval, and the other is sketch-based image retrieval.

For the interface of content based image retrieval, the user first supplies an image of an object, which is used to retrieve a list of images containing similar objects. Image retrieval is implemented using deep feature extraction with a pre-trained VGG16 network (Simonyan and Zisserman, 2014) and nearest neighbor searching based on the cosine distance metric (Wan et al., 2014; Wang et al., 2014b). If a background image is also provided, we can further apply a refinement process to re-rank retrieved visual objects with respect to the context of background image. In this step, the background image is used as the query image to re-rank already retrieved image list.

For the interface of sketch-based object retrieval, our system provides a panel for the user to draw a sketch. Our system searches the database to retrieve a list of objects which can be associated with the sketch. Sketch-based image retrieval is based on the deep CNN model provided in (Sangkloy et al., 2016). Similarly, given a background image, our system can also re-rank retrieved objects using the same method regarding background similarities, as provided in the first type of user interface.

7.2. Image Compositing

Image compositing can be performed conveniently using our object database. Here we look at an application of blending objects into a given background image.

Given a background image and some foreground object images found within our database, we firstly apply automatic or semi-automatic image segmentation (such as (Rother et al., 2004)) on foreground object images, and alpha matting (such as (Chen et al., 2013a)) to cut out foreground objects. We further apply improved Poisson blending and alpha blending as proposed in (Chen et al., 2009) to generate a high-quality composition. Some image compositing examples are shown in Figure 10.

7.3. Automatic Segmentation

The selection of high objectness proposals can be potentially useful in fully-automatic segmentation. Figure 9 shows some of the results on object images obtained from Flickr. The method from (Wu and Yu, 2018) is used. Please note that although not all object images obtained from Flickr can be processed well by this method, there are still a large number of acceptable results.

8. Conclusions and Discussion

In this paper, we present an effective pipeline for discovering and locating visual objects from internet images. This pipeline is based on dense object proposal generation and objectness assessment. A deep neural network is designed for the inference of proposal objectness score, based on the criteria of completeness and fullness. Objectness scores returned from this network are used to re-rank pre-generated object proposals to choose optimal object proposal windows. Our experiments confirm the effectiveness of the proposed method, showing its relatively higher precision and recall when compared to existing state-of-the-art methods.

From the perspective of building an object database, our pipeline and the assessment network can be useful in many applications, such as building a photo gallery of visual objects for a specific image collection, performing image editing with diversified choices of visual objects, enriching existing public visual object databases, etc. More interestingly, the proposal objectness assessment can potentially be useful in improving the performance of an object detector, as proposals that are less-likely to contain any objects can be safely removed using this method. This could be an interesting future work.

Limitation Our method is dependent on the performance of existing object proposal generators. If an object is not detected by the proposal generator, our method is not able to find it as well. In the future, we intend to combine object proposal generation and proposal objectness assessment in a unified framework, and improve the performance of proposal generation.