Conventional methods to solve complex tasks involves requesters to break tasks down into micro-tasks that can solved by workers. Results are collected and combined using stitching algorithms. Lesser worker qualification requirements lead to access to a larger worker pool that ultimately results in quicker solutions. However, this limits the complexity of tasks and requires quality checks in place.
Furthermore, fixing the task break up structure sometimes may not be feasible due to inter-dependencies and sub-task contexts may require updating based on the incoming solutions.
A thorough understanding of the crowd-platform in addition to the nature of the task is hence required to effectively solve complex tasks. More often than not, this becomes an entry barrier for requesters.
The price-divide-solve-merge algorithm in turkomatic is a paradigm shift in the way complex tasks are handled on crowd-based systems. Complex tasks are broken in itself and made initial attempts at solving complex tasks through crowd-based division of tasks where requester supervision was possible and lead to higher quality. The authors acknowledge that workers at the top of the task tree must be able to micro-manage sub-trees for higher quality. This also removes the burden and dependency on the requester to frequently check on the tasks. Also, branches are created dynamically without checks and entire sub-trees can be invalidated if the requester chooses to do so.
Tidal combines the task structuring concepts described in ,  and the worker retainer model in  to yield a self-regulatory task framework that can send out tasks to a synchronous active worker pool.
The framework eases the barrier for a requester to submit complex tasks. The framework can handle multiple requests from multiple requesters and all resulting sub-tasks are maintained on a priority queue for assignment to workers who're also on a priority queue.
One of the unique features of our implementation is the self-regulatory task structure. Task structures are dynamically formed by Turkers. The structures aren't formed until approval is provided by a parent branch. Each task can independently request a different kind of worker.
The retainer model presented in  is proven to bring workers to tasks faster than waiting for workers from a larger pool to sign-up to the task. The retainer model works by paying to maintain an active pool within a larger worker pool. This project implements a basic version of this retainer model where workers are rewarded based on the number of tasks they've done.
Workers are of three types viz. Branchers, responsible for dividing and monitor sub-trees created; Leafers, solve sub-tasks; and Sappers, verify and combine information. Each worker type has it's own priority queue implementation based on a ranking system.
Overall Process For a Requester:
- Login into the Tidal website.
- Fill up a few forms and set budget.
- Create request.
- Wait till results are tabulated.
- Check back to see results.
Overall Process For a Worker:
- Worker accepts a HIT on AMT and chooses a preference for the kind of work they're interested in Eg: branch, leaf or sap
- They are put on an idle pool. The worker leaves their web tab open and can do other tasks.
- When a task becomes available, it is sent over to the worker over secure websockets. The worker is notified of these tasks on their screen.
- Worker may choose to accept it or reject it. Upon rejection, tasks are returned back into the pool.
- Once a task is accepted, the worker may choose to further divide the task or complete it themselves.
- The submitted task is then sent to the parent node for approval.
- If a divide in the structure is allowed, then the originating user will be required to monitor and supervise the resulting sub-nodes.
- The worker is released back into the idle pool when all of the children have been approved.
- While the workers are waiting for tasks, they are paid.
- All payments are dynamically managed within the framework and are tracked based upon the tasks and worker idle time.
- Worker rewards are currently tracked based on the number of tasks they perform.
Special Note on Authorization Manager:
Security cookies are set on worker browsers. This allows for tracking and authentication of workers. Also, worker login requests are only allowed from AMT to prevent unauthorized of the website. An additional layer of security is added at all the methods that handle client interactions to improve overall security of the framework.
The three main modules Authorization Manager, Work Manager and Task Manager take up the tasks of security; worker pool, rewards and payment tracking; and task structure, supervision and results. The framework was built and setup. There was an overwhelming amount of dataflow dependencies within the three modules and each worker. We would like to simplify this further in the v2.0 of the project.
Improve upon the retention model, reward system and task manager. In addition, provide support for different kinds of applications such as programming, travel planning etc. Ease asynchronous communication protocols between server and workers. Overall simplification of dataflow. Also, priority based scheduling of workers to different parts of a task tree. Nodes higher up the task tree are given the best of workers.
We would like to thank Dr. Alexander J. Quinn, Department of ECE, Purdue University, for his key contributions and support in helping us conceptualize this project. We can't thank him enough for introducing and guiding us through the vast world of crowd-powered systems. His insights have truly inspired us to further our pursuit in the human computation and crowd-sourcing. We look forward to a continued collaboration with him.