This page will have all relevant email transactions with the students regarding the AI course, so that everyone has equal information regarding the course material.
Newest transactions will be posted on the top. Regularly view this page to see what's going on between other students and the instructor.
All sensitive material such as your name, email address, etc. will be removed, and also any part of code that is not relevant to the discussion will not be uploaded here.
Date: 11/19/07 | Title: Term project teams and themes |
Date: 10/22/07 | Title: Term project information |
Date: 10/02/07 | Title: Program 2 clarification |
Date: 9/28/06 | Title: Program 2 tips |
Date: 9/18/06 | Title: Program 1 typo and clarification |
Date: 9/13/06 | Title: Tip for deriv-eval |
Date: 8/29/06 | Title: Announcement |
Date: 3/01/06 | Title: Resolution solution (customs official) |
Date: 2/23/06 | Title: Lisp tips — clearing dupe-check list |
Date: 2/23/06 | Title: Lisp tips — careful with append and cons |
Date: 2/23/06 | Title: Lisp tips — sorting |
Date: 2/23/06 | Title: Lisp tips — misc. tips |
Date: 2/23/06 | Title: Program #2 — getting started |
Date: 2/23/06 | Title: Heuristic functions |
Date: 2/23/06 | Title: Compiling Lisp code |
Date: 11/19/07 | Title: Term project teams and themes |
Project teams/themes Preferred dates 1. Rakesh Gosangi 11/30, 11/28 Beam stack search 2. Matt Hillary 12/03, 11/30, 11/28 Blackjack player 3. Nishanth Chandrasekaran and Bharathi Manivannan Selvaraj [x/x], 12/03 Natural language interface to a vending machine 4. Abhinav Mathur 11/28, 11/30, 12/03 ML techiniques for fraud detection 5. Shaik Moulaali and Supradha Sankaran 11/30, 11/28, 12/03 Neural network based movie recommendation system 6. Wei Zhou and Xiabing Xu 11/30, 11/28 Sudoku 7. Manoj Yogi and Raghavendra Yemmanuru 12/03, 11/30, 11/28 Credit approval predictor 8. Jaime Perez 11/28, 11/30, 12/3 Hill climbing vs. simulated annealing 9. Deepan Srinivasan Channel routing using simulated annealing 11/28, 11/30 10. Kenton Kirkpatrick 12/03, 11/30, 11/28 Aircraft morphing using reinforcemnt learning 11. Justin Yang and Chiao-Fang Hsu 12/03, 11/30, 11/28 Mobile robot with certainty grid and A* 12. Leo Jiang 11/30, 11/28 Dots-and-boxes game | |
Date: 10/22/07 | Title: Term project information |
Code-base
Final miniproject details1. Pick a code-base - One of the stuff listed above - Your own code from this class (search, etc.) - Your own code, from your own research, which can benefit from AI techniques - A third-party open source, not listed above 2. Formulate your research problem - Identify an AI-related task - Locate data set (if needed): see, e.g., UCI ML repository - Design experiments 3. Proposal - Team members: max 2 per team. - What is the research problem? - Why is it important/interesting? - What are other people's approaches? - What are the limitations of those approaches? - What is your approach? - What experiments will you do? - What are the expected results? - Submit by 11/2/07 (Friday), in class. 4. Presentation - 20 minutes. - Present final or interim results 5. Final report - 4-5 page, single space report. - Due by 12/3 (Monday), in class. | |
Date: 10/02/07 | Title: Program 2 clarification |
[Question] > While doing assignment - II, I got a basic doubt. Is iterative deepening > search Optimal when we eliminate duplicate nodes? It uses DLS and DLS > uses DFS for node traversal. Is it possible that by avoiding the visits > of duplicate nodes, we will miss the optimal solution? Suppose the > solution was at depth 30. So, when we went on the first path till depth > 30, we might have marked some nodes as visited and didn't find solution > in this path (till depth 30). but, when we take different paths, we > might have got the solution at depth 30 by visiting some of the already > marked nodes. [Answer] Yes, that is possible, unfortunately. Suppose (n)-->(G), and (n) occurs at depth 5 to the far right and at depth 6 at the far left. Suppose (G) is the only goal. At depth limit 5, DLS will return NIL. At depth limit 6, DLS will reach the (n) on left (at depth 6) first, and put it in the visited node list, and backtrack. Once it reaches (n) on the right at depth (5), it will backtrack without going further. So, what do you do about this? If you get a suboptimal solution because of this reason, just state that fact and explain why that happend even when IDS and IDA* are supposed to be optimal. Put this in your README file. You won't get points taken off because of this. | |
Date: 9/28/06 | Title: Program 2 tips |
[Question] >I am having a little trouble understanding > what is exactly needed from the assignment. Which file is suppost to be > our main? Also, are we suppost to implement our searches inside the > interface file? Also, is the dfs file that is available to us the complete > code? [Answer] You need only one file: eight.lsp In it, you copy and paste the contents of eight-util.lsp and dfs.lsp, and start modifying. The dfs.lsp is complete and working, for that particular problem (search within a given tree represented as a list). You need to rewrite the expand function. | |
Date: 9/18/06 | Title: Program 1 typo and clarification |
There were some typos in the program 1 slides.
Program 1 typo: In page 1, item 1, page 43 should be page 44. In page 1, item 2, page 46 should be page 47, and page 44 should be page 45. As for the check for division by zero, you don't need to do that check for deriv-eval. | |
Date: 9/13/06 | Title: Tip for deriv-eval |
Suppose you did (setq var 'x) (setq num 10) and then did (setq var num) What would be contained in x? You can check this by simply typing x Actually, that's a trick question. If you followed the steps above, you will find that it results in an error. The reason is that (setq var num) simply assigns 10 to the variable "var". Let's look at what's contained in what at various time points. (setq var 'x) -> "var" contains symbol "x" (setq num 10) -> "num" contains number 10 (setq var num) -> "var" contains number 10 At this point, "x" hasn't been assigned any value. Somewhere above, you need (list ...) and (eval ...). | |
Date: 8/29/06 | Title: Announcement |
The articles below are from Spring 2006, but they are quite relevant
still, so I will keep them here. You may also look at various versions
of the read-only board from previous semesters.
| |
Date: 3/01/06 | Title: Resolution solution (customs official) |
(1a) ~E(x) \/ V(x) \/ S(x,f(x)) (1b) ~E(x) \/ V(x) \/ C(f(x)) (2a) E(a) (2b) D(a) (2c) ~S(a,y) \/ D(y) (3) ~D(x) \/ ~V(x) (4) ~D(x) \/ ~C(x) -------------------------------- (5) ~V(a) 2b & 3 (6) V(a) \/ S(a,f(a)) 1a * 2a (7) S(a,f(a)) 5 & 6 (8) D(f(a)) 2c & 7 (9) ~C(f(a)) 4 & 8 (10) ~E(a) \/ V(a) 1b & 9 (11) V(a) 2a & 10 (12) False 5 & 11 | |
Date: 2/23/06 | Title: Lisp tips — clearing dupe-check list |
[Q] My search works the first time I call it, but it seems
to go on forever the second time I call it. What's wrong?
[A] It must be the case that you are not refreshing your duplicate check node list. Suppose it is *all-nodes-expanded*, then for each search insert this line before you call the search core: (setq *all-nodes-expanded* nil)Note that for Iterative Deepening Search, you have to reset the list to NIL before each iteration! | |
Date: 2/23/06 | Title: Lisp tips — careful with append and cons |
[Q] My (expand ...) function always returns NIL!?
[A] You are probably just doing (cons (apply-op ...) return-node-list) or (append (list (apply-op ...)) return-node-list). What you should do is to assign the result of that cons or append back into the temporary variable that holds the list of expanded nodes (i.e., the return-node-list variable). (setq return-node-list (cons (apply-op ...) return-node-list))Also, at the end of the expand function, you must put return-node-list so that it will be returned as the function value. (defun expand (...) (let (return-node-list) ; <--- declare local variable ... (setq return-node-list (cons (apply-op ...) return-node-list)) ... return-node-list ; <-- (let ...) will return this ; This must be the last line ; in the (let ....) form. ) ; <-- and that will be again returned ; by your expand function. ) | |
Date: 2/23/06 | Title: Lisp tips — sorting |
Here are some lisp idioms that may help you folks:
| |
Date: 2/23/06 | Title: Lisp tips — misc. tips |
These are some scattered Lisp tips:
| |
Date: 2/23/06 | Title: Program #2 — getting started |
Here's a quick guide to get you started on program#2.
Because you can work on so many different aspects of the
provided problem, it may not be entirely clear where to
begin. Following the steps given below will give you a head-start:
| |
Date: 2/23/06 | Title: Heuristic functions |
[Q1] What is Manhattan distance?
[A1] Here's an approximate algorithm. 1. Pick a tile, say n. 2. Find it's current location in the given state: use the (location ...) function. 3. Calculate its desired location (from the goal state). 4. Get the x and y location for the current and desired location. Let's call them x_c, y_c, and x_d, y_d. 5. The manhattan distance for this tile n is manhattan(n) = abs(x_c-x_d) + abs(y_c-y_d). 6. Get the sum for all tiles n=8 sum_manhattan = Sum manhattan(n) n=0 [Q2] How do I select different heuristics for a* and heuristic search? [A2] It'e easier to have a global variable that holds the heuristic function name, let's say *heuristic-func*. Your heuristic search function should take in the function to use as an argument: (defun heuristic (state h-func) ... (setq *heuristic-func* h-func) ... )which can be called as: (heuristic '( 1 2 3 ... ) 'h1)supposing that you defined your heuristic functions as (defun h1 (state) ; tiles out of place ... ) (defun h2 (state) ; sum of Manhattan distance ... ) In (expand ...) or in (apply-op ...), you should call a heuristic wrapper (h state) (defun apply-op (op node) ... ... (h state) ... ) (defun h (state) (funcall *heuristic-func* state) )so that the apply-op function should call the heuristic that you selected in your main search wrapper function. For example, try this to see what the main idea is: * (setq op '+) + * (funcall op 10 20) 30 * (setq op 'list) LIST * (funcall op 10 20 30) (10 20 30) | |
Date: 2/23/06 | Title: Compiling Lisp code |
To optimize and speed up execution, you should compile your program
code. You can do this in CMUCL by running the (compile-file
<filename>) function. See below for an example, where I am
compiling function(s) in the file fibo.l. The file contained the
definition for the (fibo ..) function. Of course you can have multiple
function definitions in the file, and all of those will be compiled.
Again, * is the
lisp prompt, and my inputs to lisp are in bold.
* (compile-file "fibo.l") ; Python version 1.1, VM version UltraSparc/Solaris 7 on 09 SEP 04 10:49:52 am. ; Compiling: /user/choe/web_project/420/fibo.l 09 SEP 04 10:44:02 am ; Converted FIBO. ; Compiling DEFUN FIBO: ; Byte Compiling Top-Level Form: ; fibo.sparcf written. ; Compilation finished in 0:00:00. #p"/user/choe/web_project/420/fibo.sparcf" NIL NIL * (load "fibo.sparcf") ; Loading #p"/user/choe/web_project/420/fibo.sparcf". T * (fibo 20) 10946 *Note that you need to first compile it, and the note what the resulting compiled file is (the one highlighted in red above), and then finally (load ...) that. |