Is there an online resource that lists cooperative multi-agent system problem domains and perhaps compares them along some dimensions? I can't seem to find one.
The best resources I found were from the International Planning Competition Domains. These follow different 'tracks' depending on the type of problem:
International Probabilistic Planning Competition Discrete Track:
https://cs.uwaterloo.ca/~mgrzes/IPPC_2014/index.html
Probabilistic Planning Competition Continuous Track:
http://users.cecs.anu.edu.au/~ssanner/IPPC_2014/index.html
Learning Track:
http://www.cs.colostate.edu/~ipc2014/domains.html
Deterministic Track:
https://helios.hud.ac.uk/scommv/IPC-14/domains.html
I also found DEC-POMDP domains here:
http://masplan.org/problem_domains
Related
Traditionional software metrics deal with quality of software. I'm looking for metrics that can be used to identify developers by their code, in the same vein as plagiarism software and stylometry can be used to identify authors by their writing style. I can imagine that certain existing metrics can be used here as well, such as comment ratio. I can also imagine metrics that would irrelevant from a quality point of view, such as the (over)use of certain methods or design patterns, average length of variable names, etc.
I'm interested either in a pointer to a collection of such metrics or studies, or individual metrics. They may be language-agnostic or related to a language or programming paradigm.
I want to use it to understand and analyze different coding styles, not to detect plagiarism.
I see there are already a couple of studies that looked into this. They might help.
Kothari, J., Shevertalov, M., Stehle, E., Mancoridis, S., "A probabilistic approach to source code authorship identification", In Proceedings of the International Conference on Information Technology, pp.243-248, IEEE, 2007.
Available online here
Quoting from the abstract:
We begin by computing a set of metrics to build profiles for a population of known authors using code samples that are verified to be authentic. We then compute metrics on unidentified source code to determine the closest matching profile. [...] In our case study we are able
to determine authorship with greater than 70% accuracy in choosing the single nearest match and greater than 90% accuracy in choosing the top three ordered nearest matches.
Shevertalov, M., Kothari, J., Stehle, E., Mancoridis, S., "On the use of discretized source code metrics for author identification", In Proceedings of the 1st International Symposium on Search Based Software Engineering, pp.69-78, IEEE, 2009.
Available online here, this is a follow-up of the previous study.
Lange, R., Mancoridis, S., "Using code metric histograms and genetic algorithms to perform author identification for software forensics", In Proceedings of the 9th Annual Conference on Genetic and Evolutionary Computation, pp.2082-2089, ACM, 2007.
Available online here
This is also related to the first reference (common author), and discusses the metrics in more detail. Again quoting from the abstract:
Our method involves measuring the differences in histogram distributions for code metrics. Identifying a combination of metrics that is effective in distinguishing developer styles is key to the utility of the technique. Our case study involves 18 metrics.
You can also use Google Scholar for other references, and for finding other papers based on the ones above (using the "cited by" option).
If you're looking for potential metrics, you might try reviewing some coding standards. Since these dictate a particular style, it follows that the things they talk about (spacing, placement of braces, identifier lengths, mandatory comments, etc.) are things that might be used to identify developers from their code.
Also, if you're interested in .NET code, you might find NDepend to be a useful tool. It enables you to run queries against a code base, and supports 82 metrics.
I have always been fascinated by the algorithm airlines use when we book the tickets. I am an undergraduate CS student and I am really interested in knowing how this works. For example, how does it figure out connecting flights? How does the fare allocation work?
Is it all handled by a single company or each airlines uses its own system?
If you can point me to some links to read, it would be wonderful.
I don't have any specific literature to point to, but to help get you thinking about the various problems, here are a few thoughts.
You can think of the airline network as a huge graph, with cities at the nodes and flights as edges. There's an edge between two cities if there is a connecting flight. Now, you can ascribe various weights to these edges, such as the time of flight, the minimal ticket cost, the number of remaining seats, etc. and use graph algorithms like Dijkstra's or A* to optimize on your metric of choice. Since there are likely to be multiple flights connecting the same cities at different times/prices/etc., you'll likely have to iterate these algorithms to find compatible itineraries (e.g. layovers not too short/long) etc. But fundamentally, these are graph algorithms.
Pricing is a highly complex endeavour and whole branches of Operations Research are devoted to it. Unlike routing, pricing is essentially a game--the service provider (airline) is trying to maximize revenue globally (not just for single flights), and so they have to balance passenger loading vs. ticket costs. Airlines have incredibly complex pricing structure, where the cost for a given seat varies dramatically with time, and may be wildly different than the cost for the seat right next to it, particularly depending on if is sold to a business or pleasure traveler.
The big name in airline reservation systems used to be SABRE. I don't know if that's still true, but they do seem to still be a major player.
Good luck & happy reading.
This is regulated via IATA
http://www.iata.org/Pages/default.aspx
http://en.wikipedia.org/wiki/International_Air_Transport_Association
Scheduling standards are maintained by this org too
http://www.iata.org/whatwedo/passenger/scheduling/Pages/index.aspx
Almost all travel sites use ITA software, who provide a service that does flight planning and search. They have an excellent annotated presentation on the 'Computational Complexity of Air Travel Planning', which describes the challenges involved, and how they deal with them.
I am not so familiar with the domain but I know airline booking is a fairly complex process with multiple parties involved. I did some quick search and found this useful presentation.
I'm trying to learn more about trust metrics (including related algorithms) and how user voting, ranking and rating systems can be wired to stiffle abuse. I've read abstract articles and papers describing trust metrics but haven't seen any actual implementations. My goal is to create a system that allows users to vote on other users and the content of other users and with those votes and related meta-data, determine if those votes can be applied to a users level or popularity.
Have you used or seen some sort of trust system within a social graph? How did it work and what were its areas of strength and weaknesses?
I'm reading the book Programming Collective Intelligence.
From the description:
Want to tap the power behind search rankings, product recommendations, social bookmarking, and online matchmaking? This fascinating book demonstrates how you can build Web 2.0 applications to mine the enormous amount of data created by people on the Internet.
The algorithms in the book are implemented in python.
I've just started reading the book so I don't know if it can help solve your problem, but it's worth taking a look.
I need to find and algorithm to find the best matches in a social network. The system is a college student social network, and basically the main idea is to find a study partner for a class. The idea it's to suggest to the user what are the potential best partners based on different criteria, such as common class, GPA, rating, common schedule, etc. I wonder what would be the best algorithm to use.
Such problem is called collaborative filtering. Collaborative filtering systems can produce personal recommendations by computing the similarity between your preference and the one of other people.
There are a lot of information about such teqniques. You might start with good presentation.
Maybe some sort of clustering algorithm could help. Those whose vectors (Common class, GPA etc...) are similar would be clustered together.
You might want to start off by looking at recommendation systems and nearest neighbor search.
I've always been curious as to how these systems work. For example, how do netflix or Amazon determine what recommendations to make based on past purchases and/or ratings? Are there any algorithms to read up on?
Just so there's no misperceptions here, there's no practical reason for me asking. I'm just asking out of sheer curiosity.
(Also, if there's an existing question on this topic, point me to it. "Recommendations system" is a difficult term to search for.)
At it's most basic, most recommendation systems work by saying one of two things.
User-based recommendations:
If User A likes Items 1,2,3,4, and 5,
And User B likes Items 1,2,3, and 4
Then User B is quite likely to also like Item 5
Item-based recommendations:
If Users who purchase item 1 are also disproportionately likely to purchase item 2
And User A purchased item 1
Then User A will probably be interested in item 2
And here's a brain dump of algorithms you ought to know:
- Set similarity (Jaccard index & Tanimoto coefficient)
- n-Dimensional Euclidean distance
- k-means algorithm
- Support Vector Machines
This is such a commercially important application that Netflix introduced a $1 million prize for improving their recommendations by 10%.
After a couple of years people are getting close (I think they're up around 9% now) but it's hard for many, many reasons. Probably the biggest factor or the biggest initial improvement in the Netflix Prize was the use of a statistical technique called singular value decomposition.
I highly recommend you read If You Liked This, You’re Sure to Love That for an in-depth discussion of the Netflix Prize in particular and recommendation systems in general.
Basically though the principle of Amazon and so on is the same: they look for patterns. If someone bought the Star Wars Trilogy well there's a better than even chance they like Buffy the Vampire Slayer more than the average customer (purely made up example).
The O'Reilly book "Programming Collective Intelligence" has a nice chapter showing how it works. Very readable.
The code examples are all written in Python, but that's not a big problem.
GroupLens Research at the University of Minnesota studies recommender systems and generously shares their research and datasets.
Their research expands a bit each year and now considers specifics like online communities, social collaborative filtering, and the UI challenges in presenting complex data.
The Netflix algorithm for its recommendation system is actually a competitive endeavor in which programmers continue to compete to make gains in the accuracy of the system.
But in the most basic terms, a recommendation system would examine the choices of users who closely match another user's demographic/interest information.
So if you are a white male, 25 years old, from New York City, the recommendation system might try and bring you products purchased by other white males in the northeast United States in the age range of 21-30.
Edit: It should also be noted that the more information you have about your users, the more closely you can refine your algorithms to match what other people are doing to what may interest the user in question.
This is a classification problem - that is, the classification of users into groups of users who are likely to be interested in certain items.
Once classified into such a group, it is easy to examine the purchases/likes of other users in that group and recommend them.
Therefore, Bayesian Classification and neural networks (multilayer perceptrons, radial basis functions, support vector machines) are worth reading up on.
One technique is to group users into clusters and recommend products from other users in the same cluster.
There're mainly two types of recommender systems, which work differently:
1. Content-based.
These systems make recommendations based on characteristic information. This is information about the items (keywords, categories, etc.) and users (preferences, profiles, etc.).
2. Collaborative filtering.
These systems are based on user-item interactions. This is information such as ratings, number of purchases, likes, etc.
This article (published by the company I work at) provides an overview of the two systems, some practical examples, and suggests when it makes sense to implement them.
Ofcourse there is algorithms that will recommend you with prefered items. Different data mining techniques have been implemented for that. If you want more basic details on Recommender System then visit this blog. Here every basics has been covered to know about Recommender System.