Download projects-2015

yes no Was this document useful for you?
   Thank you for your participation!

* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project

Document related concepts
no text concepts found
CS 404
Project Signup: via SUCOURSE, by Dec 7th, 11pm
Project Submission: Dec 28 via SUCOURSE, 10am (late projects will be accepted until Jan 5
– submission and presentation)
Presentations: Dec 28, time TBA or Jan 5 (your choice)
Goal: Hands-on experience on a project incorporating some components of Artificial Intelligence,
such as search, heuristics, game playing, or logic programming.
Groups: 2-4 people
How to sign up: You can send a discussion item to Sucourse (to the Project forum) until Dec. 4.
Responsibilities: These apply to all the projects:
o Being on time
o Doing the work yourself: You can share the programming load (one writes the class library,
the other the visual interface etc.) within your group, but everyone is responsible knowing the
search, heuristic... parts. Also, you may find a heuristic on the web, but you have to understand
it fully and implement everything yourself. You may discuss results (e.g. in TSP) and play
with each oothers’ programs, w/o sharing code.
o Doing a good work: People working on the same problem will compete against one another.
Also having an organized, commented and modular code is required.
Doing a good presentation: up to 5 minutes to show a 3-4 slides, listing your group, your
problem, your approach, your code and demo of your program
Writing a report: You will write a report (5-6 pages, explaining your heuristic, depth of
search, algorithms, any shortcomings etc.) of your project and also demo your program at
the end of the term. GUI of your project game playing can be simple, but if possible
implement via available libraries etc.
Language: Your choice subject to other rules (e.g. using server or GUI etc.)
Available Projects:
1) Write a backgammon program.
2-4 people/group
You are expected to write your program with a good graphical user interface (GUI) so as to play
against a human. In case the BG server is up and running, then you can play against opponents
through the server, instead of implementing a GUI.
In case of 4 people groups, you will be expected to have a GUI/server interface. If you want to
have a simple interface, we will pass/read moves as in Chess (King to F4), from numbered areas on
the board (e.g. Dice was 6, 3: Moves may be: 13 to 19
20 to 23)
Implementation: You need to think about the data structure to represent the board; move generator
(considering the empty locations that each of your pieces can go); implement the expectimax
algorithm, and find a heuristic (depending on your pieces and locations, how many taken etc.).
Note: We have some old code written in C++ for a BackGammon server that lets people play against
each other. It has a small glitch regarding double-dices (it is designed to expect 2 moves per dice and
solves the double-dice issue suboptimally). If you can and are willing to work with the server, I will
give you the code to improve and some bonus points (around 10/100).
2) Solve the Travelling Salesman Problem (TSP) using a heuristic and one of the following
algorithms: hill-climbing, simulated annealing or genetic algorithms.
1-2 people/group
You are given data (e.g. x-y coordinates of 52 cities are given in a file) with a known tour length. You
need to start with random city orderings and then write a local optimization algorithm. This project
will require less programming than the others, so if you are not very good with programming,
this may be a good option.
At each iteration or at every 100 iteration (enough duration to give the observer reading time) or so,
you should write the best tour found so far and its length, so that when we stop your program after x
seconds (Ctrl-C), we have your best results found in x seconds.
index x y
1 50.0 200.0
2 70.0 350.0
iteration 100: Length: 14,677
Tour: 1-5–32-52-49-4-...
iteration 200: Length: 14,200
Tour: 1-7-29-32-.............
Your system will be tested with a larger or modified TSP problem at the end. So you should be
able to read and work with the file tspdata.txt under lectures/Project/ or any file in that format
(possibly with more cities etc).
You should implement as many local search algorithms as the number of people in your group.
If you have 2 people in your group, you will have twice more time (e.g. 2 min) and you can give the
best of all results.
Important note: One common problem with this project topic is to modify the algorithms (e.g.
modifying simulated annealing). These are well-established algorithms, unless your improvement
helps in more than one problem instance, I suggest you don’t change the optimization algorithm! (you
will lose pts if you loose some randomness or performance, due to your change).
3) Solve Wumpus word with Prolog
Starting from a random world (lets say given from outside or set by the program), according to the
rules of the game, find gold without being killed (fall into pits...).
We may limit this project to the use of FOL only. In other words, we will assume that we can use
logic to deduce hidden properties of the world, without leaving anything to chance or requiring to
compute probabilities about certain events (e.g. P(Pit3,5)). Imagine that a Percept is given as a list, for
a certain time, as in the FOL wumpus world slides.
4) Write an expert system for a significant enough domain in Prolog (possibly for things like
checking whether the requirements for course/credit counts are satisfied; or in a special area of health
or education that you may be qualified build an expert system).
This project first involves studying previous/existing expert system applications and reporting a
summary (20pts/100) and implementing a problem on a narrow domain (e.g. course scheduling with a
small set of courses).
Subject to approval.
5) Make a suggestion for a different game or on a topic related to the course material until project
sign-up time.
Subject to approval. The game shd. be well-known or easily understood, so that we can decide on the
quality of the solution.
Each project group will briefly describe (<5min) what they have used, during the project demos.
Each project will be judged based on:
What it has implemented and unimplemented/incomplete parts, if any
Its success compared to other groups (how many times it wins, whether it has obvious
shortcomings etc.)
The code: depending on whether you wrote a nice, modular AI program (search, heuristic, a-b
pruning parts...) as opposed to a bunch of rules.
Comments: You must have commented code (20pt/100)
If you are doing a backgammon/chess project and will demo using interacting with the servers:
you are expected to interact with the backgammon or chess server (under the Projects/ folder) on the
day of the project presentations, so you must test your program for this beforehand!
What to Submit: Code and Report
You should submit a single zip file, named after your group (formed from your names e.g., containing:
- your code folder with no files or libraries missing, but debug and release dirs removed
an executable file of your program in the main folder
- a 5-6 page project report, containing:
- name of the people in the group
- project task (e.g. backgammon)
- approach & methods (a few paragraphs)
- known weaknesses & bugs
- acknowledgements in detail if you have used any source from outside your group
- how to use the program