CS221: Artificial Intelligence: Principles and Techniques

What is this course about? What do web search, speech recognition, face recognition, machine translation, autonomous driving, and automatic scheduling have in common? These are all complex real-world problems, and the goal of artificial intelligence (AI) is to tackle these with rigorous mathematical tools. In this course, you will learn the foundational principles that drive these applications and practice implementing some of these systems. Specific topics include machine learning, search, game playing, Markov decision processes, constraint satisfaction, graphical models, and logic. The main goal of the course is to equip you with the tools to tackle new AI problems you might encounter in life.

Prerequisites: This course is fast-paced and covers a lot of ground, so it is important that you have a solid foundation on both the theoretical and empirical fronts. You should have taken the following classes (or their equivalents):

Programming (CS 106A, CS 106B, CS 107)
Discrete math (CS 103)
Probability (CS 109)
Algorithms (CS 161)

Reading: There is no required textbook for this class, and you should be able to learn everything from the lecture notes and homeworks. However, if you would like to pursue more advanced topics or get another perspective on the same material, here are some books:

Russell and Norvig. Artificial Intelligence: A Modern Approach. A comprehensive reference for all the AI topics that we will cover.
Koller and Friedman. Probabilistic Graphical Models. Covers factor graphs and Bayesian networks (this is the textbook for CS228).
Sutton and Barto. Reinforcement Learning: An Introduction. Covers Markov decision processes and reinforcement learning. Available free online.
Hastie, Tibshirani, and Friedman. The elements of statistical learning. Covers machine learning. Available free online.
Tsang. Foundations of constraint satisfaction. Covers constraint satisfaction problems. Available free online.

Bear in mind that some of these books can be quite dense and use different notation terminology, so it might take some effort to connect up with the material from class.

Video Access Disclaimer: This class will be given in Zoom. For your convenience, you can access recordings by logging into the course Canvas site. These recordings might be reused in other Stanford courses, viewed by other Stanford students, faculty, or staff, or used for other education and research purposes. If you have questions, please contact a member of the teaching team.

Zoom Instructions

Installing Zoom

Linux:
- Go to downloads and download appropriate Linux package from 'Zoom Client for Linux'.
- Open package (e.g. with 'Ubuntu Software Center' or other appropriate application) and install.
Windows:
- Go to Stanford Zoom and click 'Launch Zoom'.
- Click 'host meeting'; nothing will launch but there will a link to 'download & run Zoom'.
- Click on 'download & run Zoom' to download 'Zoom_launcher.exe'.
- Run 'Zoom_launcher.exe' to install.

Best Practices for Zoom
Please be aware that the lecture is being recorded and will be uploaded to the course Canvas page.

Set up:
- Download the Zoom Desktop App (Stanford IT)
- If you have unstable internet, sometimes it helps to turn your camera off.
During Lecture:
- You will be muted for the duration of the lecture.
- Please send your questions to the chat function of the Zoom. The TA will keep track of the questions and ask the questions on your behalf.

Grading

Per Stanford Faculty Senate policy, all spring quarter courses are now S/NC, and all students enrolling in this course will receive a S/NC grade. This course will still satisfy requirements as if taken for a letter grade for CS-MS requirements, CS-BS requirements, CS-Minor requirements, and the SoE requirements for the CS major.

Since the project is optional, we are providing two grading schemes:

With project: homework 40%, midterm 30%, project 30%
Without project: homework 60%, midterm 40%

We will take the maximum of these two so that everyone will get the better of their grades under each grading scheme.

Homeworks: There will be weekly homeworks with both written and programming parts. Each homework is centered around an application and will also deepen your understanding of the theoretical concepts. Homework 5 (Pac-Man) will have a competition component; winners will receive extra credit. Here are all the homework deadlines:

Exam: The exam is a written exam that will test your knowledge and problem-solving skills on all preceding lectures and homeworks. The midterm exam will only cover material up to lecture in 5/20. If you have a major conflict (e.g., an academic conference), you should let us know privately on Piazza by Thurs May 14.

Date: Tuesday, June 2
Length: 3 hours, with a 15 minute leeway for scanning and/or uploading
Format: The exam will be available for 24 hours, from 12AM PDT (midnight) to 11:59PM PDT on June 2.
Students can choose any 3hr 15m block of time within that window to take the exam. The exam must be submitted by 11:59PM. The exam is open-book and will be distributed and submitted through Gradescope. It will be time stamped to ensure that all students take it within the 3 hour timeframe.

(Optional) Project: The final project provides an opportunity for you to use the tools from class to build something interesting of your choice. Projects should be done in groups of up to four. The project will be something that you work on throughout the course and we have set up some milestones to help you along the way:
See the project page for more details.
Regardless of the group size, all groups must submit the same basic amount of work detailed in each milestone and will be graded on the same criteria. Although we allow 1-2 person project proposals, we encourage groups of 3+ members. The reason we encourage students to form teams of 3+ is that, in our experience, this size usually fits best the expectations for the CS 221 projects. We expect the team to submit a completed project (even for team of 1 or 2), so keep in mind that all projects require to spend a decent minimum effort towards gathering data, and setting up the infrastructure to reach some form of result. A 3-person team can be share these tasks much better, allowing the team to focus a lot more on the interesting stuff, e.g. results and discussion.

For inspiration, we have made some previous CS221 projects available for viewing.
Piazza: You will be awarded with up to 2% extra credit if you answer other students' questions in a substantial and helpful way.

Assignments

Written assignments: Homeworks should be written up clearly and succinctly; you may lose points if your answers are unclear or unnecessarily complicated. Here is an example of what we are looking for. You are encouraged to use LaTeX to writeup your homeworks (here's a template), but this is not a requirement. You will receive one (1) bonus point for submitting a typed written assignment (e.g. LaTeX, Microsoft Word). To receive this point, you must select the first page of your submission for the bonus question in Gradescope. We will accept scanned handwritten assignments but they will not receive the bonus point.

Programming assignments: The grader runs on Python 3.6.9, which is not guaranteed to work with older versions (Python 2.7). Please use Python 3 to develop your code.

The programming assignments are designed to be run in GNU/Linux environments. Most or all of the grading code may incidentally work on other systems such as MacOS or Windows, and students may optionally choose to do most of their development in one of these alternative environments. However, no technical support will be provided for issues that only arise on an alternative environment. Moreover, no matter what environment is used during development, students must confirm that their code (specifically, the student's submission.py) runs on the Gradescope autograder.

The submitted code will not be graded if it has one of the following issues:

The original grader.py script (operating on the submitted submission.py) may not exit normally if you use calls such as quit(), exit(), sys.exit(), and os._exit(). Also note that Python packages outside the standard library are not guaranteed to work. This includes packages like numpy, scikit-learn, and pandas.
The code reads external resources other than the files given in the assignment.
The code is malicious. This is considered a violation of the honor code. The score of the assignment will be zero (0) and the incident will be reported to the Office of Judicial Affairs.

Collaboration policy and honor code: You are free to form study groups and discuss homeworks and projects. However, you must write up homeworks and code from scratch independently, and you must acknowledge in your submission all the students you discussed with. The following are considered to be honor code violations:

Looking at the writeup or code of another student.
Showing your writeup or code to another student.
Discussing homework problems in such detail that your solution (writeup or code) is almost identical to another student's answer.
Uploading your writeup or code to a public repository (e.g. github, bitbucket, pastebin) so that it can be accessed by other students.
Looking at solutions from previous years' homeworks - either official or written up by another student or on a public repository.

When debugging code together, you are only allowed to look at the input-output behavior of each other's programs (so you should write good test cases!). It is important to remember that even if you didn't copy but just gave another student your solution, you are still violating the honor code, so please be careful. We periodically run similarity-detection software over all submitted student programs, including programs from past quarters and any solutions found online on public websites. Anyone violating the honor code will be referred to the Office of Judicial Affairs. If you feel like you made a mistake (it can happen, especially under time pressure!), please reach out to the instructor or the head CA; the consequences will be much less severe than if we approach you.

Submission

Electronic Submission: All assignments are due at 11pm (23:00, not 23:59) Pacific time on the due date.

Assignments are submitted through Gradescope. Do not submit your assignment via email. If anything goes wrong, please ask a question on Piazza or contact a course assistant.
You can submit as many times as you'd like until the deadline: we will only grade the last submission.
Submit early to make sure your submission runs properly on the Gradescope servers.
Gradescope will run grader.py on the programming questions and give you feedback on non-hidden test cases. You are responsible for checking that your program runs properly on these cases. You will not get credit otherwise.
Partial work is better than not submitting any work.

For assignments with a programming component, we will automatically sanity check your code in some basic test cases, but we will grade your code on additional test cases. Important: just because you pass the basic test cases, you are by no means guaranteed to get full credit on the other, hidden test cases, so you should test the program more thoroughly yourself!

Unless the assignment instructs otherwise, all of your code modifications should be in submission.py and all of your written answers in <assignment ID>.pdf. Upload the former to Gradescope under the "Programming" section, and the latter under the "Written" section.
For the project milestones, make sure all members of your group are included in the submission.

Late days: An assignment is $\lceil d \rceil$ days late if it is turned in $d$ days past the due date (note that this means if you are $1$ second late, $d = 1$ and it is 1 day late). You have seven (7) late days in total that can be distributed among the assignments (except for p-poster and p-final) without penalty. After that, the maximum possible grade is decreased by 25% each day (so the best you can do with $d = 1$ is 75%). As an example, if you are out of late days and submit one day late, a 90 will be capped at a 75, but a 72 will not be changed. Note that we will only allow a max of $d = 2$ late days per assignment, though, so if $d > 2$ then we will not accept your submission. Gradescope is set up to accept written and programming submissions separately. Late days are calculated per-assignment, with the number of late days used depending on the later submission. So, if the programming part is $1$ day late and the written part is $2$ days late, then that will count as using $2$ late days.

Regrades: If you believe that the course staff made an objective error in grading, then you may submit a regrade request for the written part of your assignment. Remember that even if the grading seems harsh to you, the same rubric was used for everyone for fairness, so this is not sufficient justification for a regrade. It is also helpful to cross-check your answer against the released solutions. If you still choose to submit a regrade request, click the corresponding question on Gradescope, then click the "Request Regrade" button at the bottom. Any requests submitted over email or in person will be ignored. Regrade requests for a particular assignment are due one week after the grades are returned. Note that we may regrade your entire submission, so that depending on your submission you may actually lose more points than you gain.