Search tips
Search criteria 


Logo of nihpaAbout Author manuscriptsSubmit a manuscriptHHS Public Access; Author Manuscript; Accepted for publication in peer reviewed journal;
Bull Tech Comm Data Eng. Author manuscript; available in PMC 2017 September 24.
Published in final edited form as:
Bull Tech Comm Data Eng. 2016 December; 39(4): 26–37.
PMCID: PMC5610657

Optimizing Open-Ended Crowdsourcing: The Next Frontier in Crowdsourced Data Management


Crowdsourcing is the primary means to generate training data at scale, and when combined with sophisticated machine learning algorithms, crowdsourcing is an enabler for a variety of emergent automated applications impacting all spheres of our lives. This paper surveys the emerging field of formally reasoning about and optimizing open-ended crowdsourcing, a popular and crucially important, but severely understudied class of crowdsourcing—the next frontier in crowdsourced data management. The underlying challenges include distilling the right answer when none of the workers agree with each other, teasing apart the various perspectives adopted by workers when answering tasks, and effectively selecting between the many open-ended operators appropriate for a problem. We describe the approaches that we’ve found to be effective for open-ended crowdsourcing, drawing from our experiences in this space.

1 Introduction

We are on the cusp of a new data-enabled era, where machine learning algorithms, trained on large volumes of labeled training data, are enabling increasing automation in our daily lives—from driving, robotics, and manufacturing, to surveillance, medicine, and science; a recent New York Times article calls this “a transformation that many believe will have a payoff on the scale of the personal computing industry or the commercial internet” [1]. Although considerable effort has gone into the development of machine learning algorithms for these applications, the generation of labeled training datasets, done at scale using crowdsourcing [2]— while equally important [3, 4]—is often overlooked. Recent work has demonstrated that optimizing crowdsourcing can often yield orders of magnitude more high-quality labeled data at the same cost, spurring the development of increasingly sophisticated machine learning algorithms, and providing immediate benefits via substantial increases in accuracy for existing algorithms.

From Boolean Crowdsourcing to Open-Ended Crowdsourcing

However, most of the past research on optimizing crowdsourcing has focused on what we call boolean crowdsourcing, e.g., [5, 6, 7, 8, 9, 10, 11], where human involvement can be abstracted as tasks or operators whose answers come from a small, finite domain, e.g., evaluating a predicate, comparing a pair of items, or rating an item on a scale from 1–5. In the former two cases, the domain of possible answers is boolean, while in the last case, the domain is finite and has cardinality five. Boolean crowdsourcing operators have natural analogs in computer operators, and are easier to reason about and develop algorithms with. This research has largely ignored open-ended crowdsourcing, where the answers to the tasks have no similar restriction. Anecdotal evidence indicates that open-ended crowdsourcing tasks are at least as popular as traditional boolean crowdsourcing tasks on crowdsourcing marketplaces. As one data point, an analysis of Mechanical Turk’s log data [12] reported that content creation—including open-ended tasks like transcription—was by far the single largest category of tasks in the period from 2009–14. As another example, a survey of industry users of crowdsourcing reports similar findings [2].

Examples of Open-Ended Crowdsourcing

We now describe some canonical open-ended crowdsourcing problems that we use as examples for this paper. One example is transcription: the goal of transcription is to transform a piece of audio or video to text. This could be done, for example, using unit tasks where we provide workers a portion of the audio or video, along with a text box where they can type a sequence of words to match the contents of the portion. Another example is clustering: the goal of clustering is to subdivide a collection of items (images, pieces of text) into clusters. This could be done, for example, using unit tasks where workers place items into an arbitrary number of buckets determined by them. Yet another example is detection: the goal of detection is to identify where in an image an object is located. This could be done, for example, using unit tasks where workers draw a bounding rectangle or polygon around the location of the object of interest.

Open-Ended Crowdsourcing: A Pressing Need

Beyond the popularity, there are several reasons why open-ended crowdsourcing is crucially important. First, some tasks are near-impossible with just boolean crowdsourcing. For example, using boolean crowdsourcing to locate the position of an object in an image is near-impossible. If we use a task like: “is the object in this portion of the image (yes/no)”, we may be able to get close to the actual location of the object by repeatedly using this task on various portions of the image, but getting an accurate bounding box around the object may require hundreds or thousands of such tasks. On the other hand, asking workers to simply draw a bounding box is a lot more effective in terms of time, cost, and accuracy. Second, open-ended crowdsourcing lets us get more fine-grained data, since workers provide answers from a potentially unbounded set. If we were to use an entropy argument, the number of bits provided by workers for an open-ended question or task is considerably larger than that provided for a boolean question. Third, recent computer vision and text processing papers argue that fine-grained training data is essential for developing sophisticated machine learning models [13, 14, 15, 16]. Specifically, our best hope for improving the accuracy of present machine learning models is by using training data that reveals more information about how humans think, as opposed to training data that is more akin to how computers operate (i.e., via boolean operations).

Despite these compelling reasons, research on optimizing open-ended crowdsourcing is still in its infancy. Open-ended crowdsourcing is presently leveraged in an unoptimized fashion, with resources wasted and inaccurate data collected, or even worse, not at all, leading to severe impediments to machine learning.


The reason why open-ended crowdsourcing is leveraged in an unoptimized fashion is that optimizing open-ended crowdsourcing is substantially harder than optimizing boolean crowdsourcing:

  1. Hard to aggregate. Due to the many possible answers to open-ended tasks, distilling the ‘right’ answer from this set is non-trivial. For example, when drawing a box around an object in an image, or transcribing audio into text, no two workers will provide the same box or transcription. This is because the number of possible answers is very large, and there are many ways of making mistakes. In boolean crowdsourcing, we could simply resort to the majority opinion, but those techniques do not apply, especially when all of the answers are different from each other.
  2. Sparsity of quality measurements. In trying to characterize the error rates of workers, due to the large number of possible answers, it is hard to get reliable estimates of the probability that a worker provides an answer a, when the true answer is b. In order to estimate these probabilities, it would take a lot of tasks to be issued on crowdsourcing marketplaces to ensure adequate coverage (and therefore accurate estimates) for every (a, b) pair.
  3. Many right answers. To further complicate matters, open-ended tasks often have many ‘right’ answers, due to different underlying perspectives or beliefs, making it challenging to distinguish between the case when a worker is making mistakes, or the case when the worker is simply adopting a different perspective. For instance, when clustering items—say a collection of images of everyday objects, workers may use different criteria—size, color, geometric shape—to cluster the items, while also inadvertently introducing errors.
  4. Multiple scales. While boolean crowdsourcing typically operates on items (images, text) as a whole, open-ended crowdsourcing can additionally operate on portions of items. For example, when counting objects in an image, we may ask workers to count within portions of the image for less error-prone counts. There are an unbounded number of such portions that can be counted, making it hard to pick between them when selecting tasks to be assigned to workers.
  5. Many open-ended operators. Unlike boolean crowdsourcing which is limited to a small number of operator types, there is a wide variety of open-ended operators, even for the same problem (including boolean ones as a subset). For example, for detecting where an object is present in an image, workers could draw a box around an object, fix a box, or compare boxes. The large number of alternatives makes it hard to design algorithms.

In short, these issues (1–3) lead to an increased complexity in reasoning about the underlying algorithms, and (4–5) an overwhelming number of design choices when it comes to designing algorithms.

This Paper

While there has been a large body of work on open-ended crowdsourcing, primarily from the HCI (Human-Computer Interaction) community, most of this work has been on creatively using open-ended crowdsourcing operators in workflows as opposed to understanding how to model and reason about them, and develop optimal algorithms. While there has been a deep, interesting, and important body of work from the database community (and to a certain extent from the AI and machine learning communities) on optimizing boolean crowdsourcing, our hope is to bring open-ended crowdsourcing the same kind of attention, especially given its importance as articulated above.

Therefore, in this paper, we aim to outline an emerging body of work in optimizing open-ended crowdsourcing from us and from other groups by developing a set of design principles that we have found to be effective for algorithm development, and by describing how these design principles were applied for a few papers that we have been working on in this space. Note that our survey of the emergent work on open-ended crowdsourcing will necessarily be biased by our own work that we’re most familiar with; this is not to indicate that the other work is not as important or as interesting, but merely indicates our lack of familiarity with them. We will attempt to categorize all of the open-ended crowdsourcing work from the database community that we are aware of, along with work from other communities in Section 4.

2 Design Principles for Open-Ended Crowdsourcing

We now describe some approaches that we’ve found to be successful in dealing with the increased modeling complexity (issues 1–3 above) and increased number of design choices (issues 4–5 above), followed by a solution scaffold or recipe for open-ended crowdsourcing.

2.1 Dealing with the Modeling Complexity

The challenges in modeling worker performance stems from the fact that there are far too many possible answers that workers can provide even for a single question or task. This means that we do not have a clear mechanism to aggregate worker answers, and nor do we have the ability to estimate error rates of the form Pr[worker answers a|true answer is b] for all (a, b) pairs. We have identified two ways of dealing with this modeling complexity, both of which essentially allow us to transform the worker answer into one or more boolean crowdsourcing answers, following which we can apply standard techniques from boolean crowdsourcing.

The first approach is to project the answer down to a finite set of choices. For example, if the worker provides an answer that is any rational number in a range, we can project this answer down to a finite set of integers; yet another way is to project it down into a binary choice: ≤ a or > a. Note that this approach is wasteful in that we lose some of the fine-grained information that workers are providing, and begs the question of why we didn’t simply ask the boolean crowdsourcing question in the first place. Nevertheless, this simple approach is commonly used: we provide an example of this approach in Section 3.1.

The second approach is to decompose the answer down to answers to a collection of boolean crowdsourcing questions. As an example, if a worker is providing a transcription to a piece of audio, instead of treating the entire transcription as one open-ended crowdsourcing task, we can break it down into the sequence of individual words, each of which can be considered a response or a non-response to a word transcription task, which is much more manageable. By doing so, we can now model and reason about workers making mistakes at the level of words, rather than complete transcriptions. In transcription, at least, an additional challenge remains, which is to identify which words across workers were meant to be provided as output for the same portion of the audio piece. As another example, if a worker is providing a bounding box as an answer to a detection task, instead of treating the bounding box as a whole, we can decompose it down into boolean crowdsourcing answers for individual pixels: where if a pixel is part of the box drawn by a worker, the pixel gets a “yes” answer for the corresponding boolean crowdsourcing question, while it gets a “no” answer if it is not. This approach has the downside that the answers to the “pixel-level” boolean crowdsourcing questions are in fact not independent—if the answer to a specific pixel is “yes”, then it is more likely than the answer to a neighboring pixel is “yes” rather than no. By decomposing the open-ended crowdsourcing task to boolean crowdsourcing ones, we lose this information.

We also employ a third approach which is fundamentally different from the previous two. This last way of dealing with open-ended crowdsourcing tasks is a bit more ad-hoc, and problem dependent, but does not require us to discard any information. Here, we operate on the answers provided to the open-ended crowdsourcing tasks directly. Consider the answers to a single open-ended crowdsourcing task. We can represent each of these task answers as nodes in a graph, and connect nodes that are similar to each other (on some similarity metric, such as overlap) with an edge annotated by the degree of similarity. Once this graph of answers is constructed, we can apply standard graph clustering algorithms to identify various view-points among the open-ended task answers: the largest cluster or clique may represent the “consensus” answer. What can be done with these clusters is dependent on the problem. We provide an example of this approach in Section 3.2.

2.2 Dealing with the Increased Design Choices

As described previously, open-ended crowdsourcing brings with it a considerable increase in the number of alternative tasks that can be issued at each step. The increase is due to the large number of open-ended crowdsourcing task types available, and also because these tasks can be applied to portions of items and not just the items directly. We now describe our approaches to deal with these increased design choices.

Our first approach is one that has been applied in the past for boolean crowdsourcing, which is to estimate the information gain for issuing a specific task: here, an additional challenge is that the information gain may be hard to estimate because we do not have a good model to reason about worker performance. Nevertheless, we may be able to use proxies for information gain, e.g., prioritizing items or portions of items for which we have fewer answers than others, or more ambiguity, perhaps measured by projecting or decomposing the answer down to boolean tasks (as described in the previous section).

The second approach is to start at a coarser granularity and then drill-down only when needed. For instance, in transcription—we can have workers first transcribe the entire audio piece, and then have additional workers transcribe the portions that are were found to be ambiguous. We will describe another example of this approach in Section 3.1.

A last approach is to incorporate information from primitive machine learning algorithms to “direct” attention to specific items or portions of them. For example, if we know for certain that an object does not lie in a given portion of the image, we can remove those portions when providing workers the open-ended task where they are asked to draw a bounding box about the object of interest. Once again, we describe how this approach is used for counting in Section 3.1.

2.3 Solution Scaffold

We have developed an open-ended crowdsourcing problem-solving approach drawing on our mechanisms to deal with additional modeling and design choice complexity. While the specific instantiation may differ across problems, the overall principles still apply, and the insights transfer across. For each problem, we apply MARQED, short for Model-Aggregate-Reason-Quantify-Estimate-DrillDown: the first three (MAR) are tailored to managing modeling complexity, while the last three (QED) are tailored to managing design choice complexity.

In particular, MARQED stands for the following: (1) Model the performance of workers on open-ended operators; (2) Develop methods to Aggregate across their responses to identify one or more ‘right answers’; (3) Identify techniques to Reason about whether the workers are generating their answers based on the same or different underlying perspective; (4) Develop procedures to Quantify the information gain of different open-ended operators, and the same operator operating on different items; (5) Design schemes to incorporate prior Estimates from automated algorithms to reduce costs; and (6) Develop Drill-Down techniques on the items to enable workers examine an item more closely. Then, we design the open-ended crowdsourcing algorithm that can leverage (1–6) (if available)—see Figure 1; boxes in blue did not exist in boolean crowdsourcing, while boxes in gray are substantially different. Note that it is not necessary to develop solutions for all of (2–6) before we can reap considerable benefits in practice. In the next section, we describe how we applied MARQED in practice.

3 Example Problems in Open-Ended Crowdsourcing

In this section, we describe our results for two problems that we believe are representative of the challenges in open-ended crowdsourcing, along with our solution approach, in addition to other problems in this space.

3.1 Counting

The goal of counting is to estimate the number of objects of a given type in an image at low cost; it is a basic computer vision primitive, with applications in security, medicine, and biology. Counting is a hard problem due to occlusion—the partial obscuring of objects behind other objects, with state-of-the-art automated techniques having accuracies less than 50% [17, 18].

In our paper [19], we develop cost-effective techniques to use crowds to accurately count the number of objects in images from two completely different domains—cell colonies in microscope photos, and people in Flickr photos. We now describe the various components of our solution, drawing parallels to the MARQED methodology.


Our open-ended operator is simple—we display an image or a portion of an image, and ask workers to provide the count of the number of objects in that portion. We find that workers do not make mistakes in counting when the number of objects in the image is less than a certain number k (20 in our experiments); after that, workers start introducing errors, with the errors growing superlinearly as the number of objects increases. This may be because workers are not able to keep track of the objects they have already counted, or because they get fatigued beyond a certain point and start introducing errors. Using this insight, we model worker error by projecting down worker answers to boolean ones: if the answer is < k, then it is assumed to be correct; if the answer is ≥ k, then it is assumed to be incorrect i.e., given a worker provides a count ≥ k, the only information we can deduce is that it is ≥ k, but no additional information can be inferred.

While this simple model provides reasonable results, we are indeed wasting information by ignoring worker answers if they are ≥ k. Using a more fine-grained error model along with maximum-likelihood estimation can help identify a current best estimate for an image or a portion of an image, allowing us to “skip ahead” to the portions that need more attention. That said, this fine-grained error model requires more expensive training data to estimate accurately.


Based on the simple error model, we can already develop a strategy for counting objects in images, by repeatedly splitting images and drilling-down. We model this process as a segmentation-tree, where the root node represents the original, complete image, and children of any node represent the segments obtained by splitting the parent image (using some splitting scheme, horizontal or vertical). Figure 2 shows one such example segmentation tree where the original image, V0, is split into segments {V1, V2}, which are respectively split into {V3, V4} and {V5, V6, V7}.

We refer to any set of mutually exclusive nodes (i.e. image segments) that when put together reconstruct the original complete image as a frontier of the segmentation-tree. We start by asking workers to count the number of images in the root node (i.e. the complete image). If they reply with a count greater than or equal to k, then we traverse down the segmentation tree by splitting the image and asking workers to provide the count for the children segments. If the count on all segments is smaller than k, then we are done. If not, we again split and repeat this process for every segment that still has a count ≥ k, until we reach a frontier of image segments such that every one of them has a smaller count than k. This simple strategy has optimal competitive ratio for any given segmentation tree, and also returns counts with reasonable accuracies of 93% when counting people on a standard dataset [20]. This approach does come with one challenge: objects often span multiple sibling segments in the segmentation tree, and therefore have a danger of being double-counted. In our paper, we take the easy-way-out by asking workers to only count an object if more than half of it appears in the image segment. Further improvements may be possible.

Reason and Aggregate

Using our simple error model, reasoning about perspectives, and aggregation is not necessary—workers are expected to agree and provide correct answers as long as the true count is < k—thus we can simply ask one worker to count each image or portion of the image, and additional answers are not necessary. In practice, however, we find that sometimes workers may still introduce errors: to handle this, in our paper, we take three worker answers per question and take the median—this simple aggregation scheme is sufficient to resolve worker differences and obtain high accuracy count estimates. Finally, we sum up all the aggregated counts from the different constituent image segments to obtain the count for the original, whole image. Changes to the worker error model, for instance, using a fine-grained probabilistic model for maximum-likelihood count estimation, will open the road to more interesting aggregation challenges.


While we did not implement other operators for this problem, there are a number of interesting alternatives that yield more information, at the expense of a little extra worker effort. For instance, we could ask workers to tag objects that they have already counted, say with a dot, to help eliminate double-counting as well as avoid missing objects. Tagged objects could serve as references for other workers, who could then mark additional objects missed by previous workers, or eliminate redundant instances.


Even if the number of objects is in the hundreds, our algorithm on the segmentation tree may end up asking several “useless” questions at the higher levels all with count ≥ k, while the “useful” questions (whose answers are actually used to compute the final count at the root) are at the frontier of the tree where the count is just k. However, it may be possible to use feedback from a primitive automatic segmentation algorithm to craft a segmentation tree where there are no useless levels, and where objects do not span multiple sibling segments. Consider the problem of counting cells in biological images. Even though automated counting may be hard due to occlusion, we can partition the image into non-overlapping portions using the watershed algorithm [21] and learn prior counts for each partition using an SVM [22]. Note that these prior counts may be much smaller than expected (due to occlusion), but it suffices as a starting point.

Given these partitions and prior counts, we can construct a segmentation tree that groups multiple contiguous partitions together until they hit up to k objects each (based on the prior counts, which may be underestimating). This allows us to construct a segmentation tree where all levels are “useful” given our prior information. Since merging partitions together optimally is NP-HARD via a reduction from planar partitioning [23], we employ other heuristic techniques in our paper, such as first-fit [24]. We then traverse the tree asking workers as before. By using the prior machine-learned estimates in this fashion, we are able to skip several “useless” questions providing a 2x reduction in cost. It should be noted that the images of cell colonies are much more amenable to automated prior estimation techniques. It is an open challenge to explore whether similar techniques could be applied to other kinds of objects, where it is a lot harder to get accurate prior counts.

3.2 Clustering

Given a collection of items (e.g., images, documents), the goal of clustering, is to organize them into coherent groups. Collections of images or documents are commonplace; organizing them is essential before one can understand the themes in the collection, or improve search or browsing. Clustering embodies all the challenges faced by open-ended crowdsourcing: workers can have different perspectives leading to multiple “right” answers making worker responses hard to aggregate. The space of possible responses is also extremely large, since workers operate on multiple items simultaneously. The open-endedness of the problem also means that there are a number of different interfaces and operators that could conceivably be used. We shall now see how applying the MARQED approach allows us to reason about this challenging open problem in a principled fashion.


Prior work has considered crowdsourced clustering, limited to the boolean operator where pairs of items are compared [25, 26]—as a result, crowd workers do not have any context to compare items. Also, the eventual clusterings end up having “mixed” perspectives, resulting in low accuracies. Instead we used a basic open-ended clustering operator, where a set of items are provided to workers, and they are asked to group them into an arbitrary number of disjoint clusters. Using this operator, we had multiple workers cluster a stylized image dataset with each image containing a shape with different sizes and colors, as a running example. First, we introduce the notion of concept hierarchies to capture the notion of worker cluster perspectives. One concept hierarchy for the concept of shapes, could be to have {All Shapes} divided into {Quadrilaterals, non-Quadrilaterals}, the latter of which is subdivided into {Triangles, Circular Shapes}. For any given dataset, the concept hierarchy need not be unique. For instance, another hierarchy would have {All Shapes} divided into {Circular Shapes, Straight-Edged Shapes}. When clustering, each worker answer can be seen to draw from one or more inherent concept hierarchies.

Figure 3 shows examples of real worker clusterings on our dataset. While workers 1 and 2 clustered based on color alone, workers 3, 4 and 5 clustered based on shape. We focus on the latter for the time being. One conceptual hierarchy, C, “consistent” with workers 3, 4, and 5 is {All Shapes} divided into {Quadrilaterals, Triangles, Circular Shapes}, which are respectively subdivided into {Squares, Rectangles}, {Scalene Triangles, Equilateral Triangles}, and {Circles, Ellipses}. We additionally introduce the notion of frontiers on a given concept hierarchy to capture the notion of granularities: a frontier in a hierarchy is a set of nodes that do not have any ancestor-descendent relationship between them, and together cover all paths to the leaves. Each frontier corresponds to one valid granularity of clustering consistent with the concept hierarchy. Representing the concept hierarchy, C, as a tree, we have worker 3 operating at the leaf nodes, or at the finest granularity of the tree, corresponding to the frontier {Squares, Rectangles, Scalene Triangles, Equilateral Triangles, Circles, Ellipses}. Similarly, worker 5 is operating at a depth of one in the tree, which is the coarsest non-trivial granularity and corresponds to the frontier {Quadrilaterals, Triangles, Circular Shapes}.

Reasoning and Aggregation

From our experiments on the stylized dataset, we make the following observations: (a) Workers cluster using different perspectives, e.g., some workers clustered using shape, and others clustered using color. That said, there was a dominant, popular clustering perspective, in this case, shape. (b) Even within a perspective, workers cluster at various granularities, e.g., some workers clustered shapes into rectangles and non-rectangles, while others broke up non-rectangles into fine-grained clusters. (c) Sometimes, there are confusing items that end up being placed in different clusters by different workers even if they agree on the perspective and the granularity.

To reason about worker’s perspectives, we can develop a notion of consistency: two worker clusterings (i.e., a set of clusters formed by each worker) are consistent if for any two pairs of clusters C, C′, one from each worker, either C [subset, dbl equals] C′, C[subset, dbl equals] C, or CC′ = [empty] i.e., each cluster from one worker generalizes, specializes, or does not overlap with another worker’s clusters. This definition allows consistent workers to cluster at different granularities.

Given the notion of consistency, we can now directly operate on worker responses to identify whether there are any “consensus” clusterings, i.e., consensus concept hierarchies (perspectives), and frontiers within them (granularities), that emerge. This allows us to have a starting point to cluster the rest of the items. To do this, we generate a clustering graph, with one node per worker, with consistent pairs having an edge between them. Figure 4 shows the clustering graph corresponding to the workers from Figure 3. Workers 1 and 2 both clustered based on color alone and were consistent with each other, while workers 3, 4, and 5 clustered by shape alone with no inconsistencies among themselves. We can show that under multinomial worker perspective selection models, the maximum likelihood worker perspective is the MAX-CLIQUE in the graph. Despite MAX-CLIQUE being NP-HARD, the clustering graph is often not large, making the problem tractable. In our paper, we additionally describe how we can incorporate worker error models, which introduce additional complexity to the problem.

Quantify and Drill-Down

So far, we have described how to use a single open-ended clustering operator and aggregate responses from it for a small number of items. However, if we have a large number of items, workers might not be able to cluster all of them in one go. This suggests the need for drilling-down, or splitting the set of items, and asking workers to cluster the resulting subsets. This raises the challenge of aggregating partial clusterings. For this purpose, we maintain a kernel of items across clustering tasks, akin to pivots in Polychronopoulos et al. [9], to be able to relate partial clusterings across each other, for aggregation. We design techniques to extend the current maximum likelihood hierarchy by merging worker responses on new items to the existing hierarchy—we leverage these techniques to design a merging algorithm which aggregates clusterings from separate subsets together to output a consensus hierarchy on the original, complete set of items.

We additionally incorporate a categorization-based operator, once the consensus clustering is identified, to provide additional cost benefits, by categorizing the remaining items into the discovered clusters [27]. Instead of having workers repeatedly cluster many items (implicitly a many-to-many comparison), they only need to identify which cluster or category is appropriate for one item at a time, with the clusters being fixed.

Overall, our techniques lead to up to 3× better recall and 1.9× better accuracy than boolean clustering schemes using pairwise judgments [25, 26] on their datasets, for the same crowdsourcing cost.

3.3 Other Problems

We’ve applied the MARQED approach to other open-ended crowdsourcing problems. We describe some of these problems briefly here, followed by work done by others.


The goal of extraction is to use crowdsourcing to gather entities of a specific type [28]. We considered a broad space of open-ended operators for this problem, leveraging the attributes of the entity set [29]. For example, musicians in Chicago can be categorized as guitarists, drummers, and so on, and may play music of various types. By considering these attributes, we can ask workers to answer more fine-grained open-ended questions: e.g., provide a jazz drummer in Chicago. This allows us to target the questions at the attribute combinations where we lack entities. However, the number of possible open-ended questions increases exponentially in the attributes, making the problem challenging. We showed that picking the best questions is NP-HARD, and found that a drill-down based technique works well, where we ask generic questions first (e.g., provide a musician), and then drill down and ask more specific questions later (e.g., provide a drummer in Lincoln Park).


The goal of crowd-assisted search [30, 31], is to return relevant results from a corpus given a search query with embedded images, video, and/or text. Here, we once again found that the following open-ended problem solving aspects are helpful: (a) multiple open-ended operators; (b) starting at a coarser granularity and drilling down into more promising candidates; and (c) incorporating prior information – in this case from regular text search engines.


Boolean tasks are typically grouped into batches of 10s to 100s of tasks that are attempted by workers together—to reduce cost and effort—making it essentially one large open-ended task. However, these tasks are assumed to be answered independently, which is not the case. We developed a probabilistic model to reason about the answers incorporating two forms of judging: independent, where workers answer each question independently, or correlated, where workers implicitly rank the items and then pick the top-k to be positive, with the rest negative (i.e., the Plackett Luce model). We found that this model, let to substantial accuracy improvements over schemes that ignored these correlations [32].

In addition, there has been work by others on optimizing other open-ended crowdsourcing problems. We describe some of them below.

The goal of transcription is to transcribe a sequence of words into text; it is a very challenging problem, with automated techniques performing very poorly [33, 34]. By decomposing worker answers down into individual words, one can apply standard multiple sequence alignment algorithms from the bioinformatics literature to align worker answers and identify consensus answers, leading to substantial improvements [34]; other work tries combining crowd answers with automated techniques [35, 36]. Some prior work has also looked at the problem of detection — finding the location of objects in images, applying computer vision models and human input via a Markov Decision Process [37].

Other open-ended crowdsourcing work exists as well, for various purposes, including designing plans [38], rule mining [39], and pattern matching [40].

4 Related Work

The work on open-ended crowdsourcing is related to work in many areas.

Area 1: Optimized Boolean Crowdsourcing

There has been quite a bit of work on optimizing boolean crowdsourcing, targeting basic algorithms, including filtering [5, 6, 41], sorting [7], max [42, 43, 11], categorization [27], top-K [9, 44, 8], spatial crowdsourcing [45, 46], and entity resolution (ER) [10, 47, 48, 49, 50, 51, 52, 53, 54].

Area 2: Crowdsourcing Systems and Toolkits

Many groups have been building crowdsourcing systems and toolkits to harness crowdsourcing in a “declarative” manner [55, 56, 57, 58], as well as several domain-specific toolkits [59, 60, 30, 31]. All these systems and toolkits could benefit from the design of optimized algorithms as building blocks.

Area 3: Quality Estimation

A number of papers perform simultaneous worker quality estimation and most accurate answer estimation, typically using the EM algorithm, sometimes providing probabilistic or partial guarantees, and sometimes modeling difficulty, bias, and adversarial behavior, e.g., [61, 62, 63, 64, 65, 66, 67, 68, 69]. To our knowledge, there is no work on applying EM to open-ended crowdsourcing tasks.

Area 4: Decision Theory

Recent work has leveraged decision theory for improving cost and quality in simple workflows, typically using POMDPs (Partially Observable MDPs), to dynamically choose the best decision to make at any step, e.g.. [70, 71]. While some of this work could be applicable to some open-ended tasks, there are no optimality guarantees associated with any of these techniques.

5 Conclusion

Open ended crowdsourcing is not only challenging and interesting, but also necessary to meet the demands of the new generation of data-hungry applications. We hope that the next wave of crowdsourcing research from the database community will tackle more problems in this space, expanding the frontier of our understanding.

Figure 1
Algorithm Flow: Boxes in blue did not exist in boolean crowdsourcing, while boxes in gray are substantially different
Figure 2
Segmentation Tree
Figure 3
Examples of real worker clusterings
Figure 4
Clustering graph


1. Artificial Intelligence Swarms Silicon Valley on Wings and Wheels. (Retrieved 18 July 2016)
2. Marcus A, Parameswaran A. Crowdsourced data management: Industry and academic perspectives. Foundations and Trends in Databases Series. 2016
3. Halevy A, Norvig P, Pereira F. The unreasonable effectiveness of data. Intelligent Systems, IEEE. 2009;24(2):8–12.
4. Domingos P. A few useful things to know about machine learning. Communications of the ACM. 2012;55(10):78–87.
5. Parameswaran AG, Garcia-Molina H, Park H, Polyzotis N, Ramesh A, Widom J. Crowdscreen: algorithms for filtering data with humans. SIGMOD Conference. 2012:361–372. Online:
6. Parameswaran AG, Boyd S, Garcia-Molina H, Gupta A, Polyzotis N, Widom J. Optimal crowd-powered rating and filtering algorithms. VLDB. 2014
7. Marcus A, Wu E, Karger DR, Madden S, Miller RC. Human-powered Sorts and Joins. PVLDB. 2011;5(1):13–24.
8. Sarma AD, Parameswaran A, Garcia-Molina H, Halevy A. Crowd-powered find algorithms. ICDE. 2014
9. Polychronopoulos V, de Alfaro L, Davis J, Garcia-Molina H, Polyzotis N. Human-powered top-k lists. Proceedings of the 16th International Workshop on the Web and Databases 2013, WebDB 2013, New York, NY, USA, June 23, 2013. 2013:25–30.
10. Wang J, Kraska T, Franklin MJ, Feng J. CrowdER: Crowdsourcing Entity Resolution. PVLDB. 2012
11. Guo S, Parameswaran A, Garcia-Molina H. So who won? dynamic max discovery with the crowd. SIGMOD. 2012
12. Difallah DE, Catasta M, Demartini G, Ipeirotis PG, Cudré-Mauroux P. Proceedings of the 24th International Conference on World Wide Web. ACM; 2015. The dynamics of micro-task crowdsourcing: The case of amazon mturk; pp. 238–247.
13. Pavlick E, Bos J, Nissim M, Beller C, Van B, Callison-burch DC. Adding semantics to data-driven paraphrasing. In ACL, Citeseer. 2015
14. Bowman SR, Angeli G, Potts C, Manning CD. A large annotated corpus for learning natural language inference. Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing (EMNLP), Association for Computational Linguistics. 2015
15. Vedaldi A, Mahendran S, Tsogkas S, Maji S, Girshick R, Kannala J, Rahtu E, Kokkinos I, Blaschko MB, Weiss D, Taskar B, Simonyan K, Saphra N, Mohamed S. Understanding objects in detail with fine-grained attributes. The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 2014 Jun
16. Bell S, Bala K, Snavely N. Intrinsic images in the wild. ACM Transactions on Graphics (TOG) 2014;33(4):159.
17. Zhu X, Ramanan D. Face detection, pose estimation, and landmark localization in the wild. CVPR. 2012
18. Everingham M, Eslami SA, Van Gool L, Williams CK, Winn J, Zisserman A. The pascal visual object classes challenge: A retrospective. International Journal of Computer Vision. 2014;111(1):98–136.
19. Sarma AD, Jain A, Nandi A, Parameswaran A, Widom J. Jellybean: Crowd-powered image counting algorithms. HCOMP. 2015 [PMC free article] [PubMed]
20. Plummer L, Wang B, Cervantes C, Caicedo J, Hockenmaier J, Lazebnik S. Flickr30k entities: Collecting region-to-phrase correspondences for richer image-to-sentence models. CoRR. 2015 vol. abs/1505.04870.
21. Beucher S, Meyer F. The morphological approach to segmentation: the watershed transformation. OPTICAL ENGINEERING-NEW YORKMARCEL DEKKER INCORPORATED- 1992;34:433–433.
22. Nattkemper TW, Wersing H, Schubert W, Ritter H. A neural network architecture for automatic segmentation of fluorescence micrographs. Neurocomputing. 2002;48(1):357–367.
23. Dyer M, Frieze A. On the complexity of partitioning graphs into connected subgraphs. Discrete Applied Mathematics. 1985;10(2):139–153.
24. Coffman Jr EG, Garey MR, Johnson DS. Approximation algorithms for NP-hard problems. PWS Publishing Co.; 1996. Approximation algorithms for bin packing: a survey; pp. 46–93.
25. Gomes R, Welinder P, Krause A, Perona P. Crowdclustering. NIPS. 2011:558–566.
26. Yi J, Jin R, Jain AK, Jain S. Crowdclustering with sparse pairwise labels: A matrix completion approach. In AAAI Workshop on Human Computation. 2012
27. Parameswaran AG, Sarma AD, Garcia-Molina H, Polyzotis N, Widom J. Human-assisted graph search: it’s okay to ask questions. PVLDB. 2011;4(5):267–278.
28. Trushkowsky B, Kraska T, Franklin MJ, Sarkar P. Crowdsourced enumeration queries. Data Engineering (ICDE), 2013 IEEE 29th International Conference on. 2013:673–684.
29. Rekatsinas T, Deshpande A, Parameswaran A. CrowdGather: Entity Extraction over Structured Domains. ArXiv e-prints. 2015 Feb
30. Parameswaran A, Teh MH, Garcia-Molina H, Widom J. DataSift: An Expressive and Accurate Crowd-Powered Search Toolkit. HCOMP. 2013
31. Parameswaran AG, Teh MH, Garcia-Molina H, Widom J. Datasift: a crowd-powered search toolkit. International Conference on Management of Data, SIGMOD 2014, Snowbird, UT, USA, June 22–27, 2014. 2014:885–888.
32. Zhuang H, Parameswaran AG, Roth D, Han J. Debiasing crowdsourced batches. Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Sydney, NSW, Australia, August 10–13, 2015. 2015:1593–1602. [PMC free article] [PubMed]
33. Yu D, Deng L. Automatic Speech Recognition. Springer; 2012.
34. Lasecki W, Miller C, Sadilek A, Abumoussa A, Borrello D, Kushalnagar R, Bigham J. Proceedings of the 25th annual ACM symposium on User interface software and technology. ACM; 2012. Real-time captioning by groups of non-experts; pp. 23–34.
35. Williams JD, Melamed ID, Alonso T, Hollister B, Wilpon J. Automatic Speech Recognition and Understanding (ASRU), 2011 IEEE Workshop on. IEEE; 2011. Crowd-sourcing for difficult transcription of speech; pp. 535–540.
36. Van Dalen R, Knill K, Tsiakoulis P, Gales M. 2015 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP) IEEE; 2015. Improving multiple-crowd-sourced transcriptions using a speech recogniser; pp. 4709–4713.
37. Russakovsky O, Li L-J, Fei-Fei L. Best of both worlds: human-machine collaboration for object annotation. Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. 2015:2121–2131.
38. Lotosh I, Milo T, Novgorodov S. Crowdplanr: Planning made easy with crowd. ICDE. 2013:1344–1347.
39. Amsterdamer Y, Grossman Y, Milo T, Senellart P. Crowd mining. SIGMOD Conference. 2013:241–252.
40. Demartini G, Trushkowsky B, Kraska T, Franklin MJ. Crowdq: Crowdsourced query understanding. CIDR. 2013
41. Gao Y, Parameswaran AG. Finish them!: Pricing algorithms for human computation. PVLDB. 2014;7(14):1965–1976.
42. Venetis P, Garcia-Molina H. technical report. Stanford University; 2012. Aug, Dynamic max algorithms in crowdsourcing environments.
43. Venetis P, Garcia-Molina H, Huang K, Polyzotis N. Max algorithms in crowdsourcing environments. Proceedings of the 21st World Wide Web Conference 2012, WWW 2012, Lyon, France, April 16–20, 2012. 2012:989–998.
44. Davidson SB, Khanna S, Milo T, Roy S. Using the crowd for top-k and group-by queries. ICDT. 2013:225–236.
45. Deng D, Shahabi C, Demiryurek U, Zhu L. Task selection in spatial crowdsourcing from worker’s perspective. GeoInformatica. 2016;20(3):529–568.
46. To H, Shahabi C, Kazemi L. A server-assigned spatial crowdsourcing framework. ACM Trans. Spatial Algorithms and Systems. 2015;1(1):2.
47. Demartini G, Difallah DE, Cudré-Mauroux P. WWW ’12: Proceedings of the 21st international conference on World Wide Web. ACM; 2012. Apr, ZenCrowd: leveraging probabilistic reasoning and crowdsourcing techniques for large-scale entity linking.
48. Chu X, Morcos J, Ilyas IF, Ouzzani M, Papotti P, Tang N, Ye Y. Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data. ACM; 2015. Katara: A data cleaning system powered by knowledge bases and crowdsourcing; pp. 1247–1261.
49. Wang J, Li G, Kraska T, Franklin MJ, Feng J. Proceedings of the 2013 ACM SIGMOD International Conference on Management of Data. ACM; 2013. Leveraging transitive relations for crowdsourced joins; pp. 229–240.
50. Gokhale C, Das S, Doan A, Naughton JF, Rampalli N, Shavlik J, Zhu X. Corleone: Hands-Off Crowdsourcing for Entity Matching. SIGMOD 2014. 2014 Mar
51. Tong Y, Cao CC, Zhang CJ, Li Y, Chen L. 2014 IEEE 30th International Conference on Data Engineering. IEEE; 2014. Crowdcleaner: Data cleaning for multi-version data on the web via crowdsourcing; pp. 1182–1185.
52. Wang S, Xiao X, Lee C-H. Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data. ACM; 2015. Crowd-based deduplication: An adaptive approach; pp. 1263–1277.
53. Bellare K, Iyengar S, Parameswaran A, Rastogi V. Active sampling for entity matching with guarantees. ACM Transactions on Knowledge Discovery from Databases (TKDD) 2013
54. Bellare K, Iyengar S, Parameswaran AG, Rastogi V. Active sampling for entity matching. KDD. 2012:1131–1139. Online:
55. Franklin MJ, Kossmann D, Kraska T, Ramesh S, Xin R. Crowddb: answering queries with crowdsourcing. SIGMOD Conference. 2011:61–72.
56. Marcus A, Wu E, Madden S, Miller RC. Crowdsourced databases: Query processing with people. CIDR. 2011:211–214.
57. Parameswaran AG, Park H, Garcia-Molina H, Polyzotis N, Widom J. Deco: declarative crowdsourcing. CIKM. 2012:1203–1212.
58. Park H, Parameswaran A, Widom J. technical report. Stanford University; 2012. Sep, Query processing over crowdsourced data.
59. Bozzon A, Brambilla M, Ceri S. Answering search queries with crowdsearcher. WWW. 2012:1009–1018.
60. Deutch D, Greenshpan O, Kostenko B, Milo T. Using markov chain monte carlo to play trivia. ICDE. 2011:1308–1311.
61. Karger DR, Oh S, Shah D. Budget-optimal task allocation for reliable crowdsourcing systems. CoRR. 2011 vol. abs/1110.3564.
62. Whitehill J, Ruvolo P, Wu T, Bergsma J, Movellan JR. Whose vote should count more: Optimal integration of labels from labelers of unknown expertise. NIPS. 2009:2035–2043.
63. Liu X, Lu M, Ooi BC, Shen Y, Wu S, Zhang M. Cdas: A crowdsourcing data analytics system. PVLDB. 2012;5(10):1040–1051.
64. Dalvi N, Dasgupta A, Kumar R, Rastogi V. Proceedings of the 22nd international conference on World Wide Web. International World Wide Web Conferences Steering Committee; 2013. Aggregating crowdsourced binary ratings; pp. 285–294.
65. Zhang Y, Chen X, Zhou D, Jordan MI. Spectral methods meet em: A provably optimal algorithm for crowdsourcin. arXiv preprint arXiv:1406.3824. 2014
66. Ramesh A, Parameswaran A, Garcia-Molina H, Polyzotis N. technical report. Stanford University; 2012. Sep, Identifying reliable workers swiftly.
67. Joglekar M, Garcia-Molina H, Parameswaran A. Proceedings of the 19th ACM SIGKDD international conference on Knowledge discovery and data mining. ACM; 2013. Evaluating the crowd with confidence; pp. 686–694.
68. Joglekar M, Garcia-Molina H, Parameswaran A. Comprehensive and reliable crowd assessment algorithms. ICDE. 2015
69. Das Sarma A, Parameswaran A, Widom J. Proceedings of the 2016 International Conference on Management of Data. ACM; 2016. Towards globally optimal crowdsourcing quality management: The uniform worker setting; pp. 47–62. [PMC free article] [PubMed]
70. Mausam C.H. Lin, Weld DS. Crowdsourcing control: Moving beyond multiple choice. UAI. 2012:491–500.
71. Kamar E, Hacker S, Horvitz E. Combining human and machine intelligence in large-scale crowdsourcing. AAMAS. 2012:467–474.