 |
CS 371 - Introduction to Artificial Intelligence
Course Information |
Course Overview
A most fascinating research field, I like to describe Artificial Intelligence
(AI) as the interesting "miscellaneous pile" of computer science.
For example, more expressive, computationally-complex database research
finds its home in AI as "knowledge representation and reasoning".
The difficult inverse of computer graphics is machine vision. Where do you
think the object-oriented paradigm reached its maturity? Many interesting,
cutting-edge problems and developments find their birthplace and first
home in this ambitious and visionary research community.
Presented with the unifying theme of constructing intelligent software
agents, we survey an interesting variety of research problems and modern
problem solving techniques. Topics we cover may include search,
game-tree search, stochastic local search, constraint satisfaction, knowledge representation and
reasoning, reasoning under uncertainty, data mining, robotics, and philosophical
foundations.
Learning Objectives
- Understand the role of AI in the context of Computer Science, and how
the diverse problem solving techniques can be unified in terms of agents and
optimization.
- Experientially learn several AI problem solving techniques through pair
programming work on challenge problems.
- Grow in the ability to observe complex problems, model them simply and
formally through abstraction and approximation, and apply programming skill
to create "intelligent" software artifacts.
Text
Instructor
Todd Neller
Lecture: Glatfelter 112, M,W,F 8:00-8:50AM
Office: Glatfelter 209
Office Hours: M,W,F 10-10:50AM. Please drop by or make an
appointment.
Note: Generally, feel free to drop in
if my office door is open. If it is closed, I'm desperately seeking
to keep on top of things and rabid attack ferrets may drop from the ceiling
in my defense.
Phone: 337-6643
E-mail: 
Grading
75% Assignments
10% Quizzes / Exams
10% 4th Hour Requirements
5% Class
Attendance / Participation You are responsible to know the material
from each lecture and reading assignment before the start of the next class.
Homework is due at the beginning of lecture on the due date. Late
homework will not necessarily be accepted. Code must be a legal program
in the relevant language in order to be graded. (It need not be free from logic
errors.) Class attendance and participation is required. If you attend all
classes and are willing to participate, you'll get 100% for this part of your
grade. Even if you know enough to give a particular lecture, please consider
the value of helping your peers during in-class exercises
Honor Code
Honesty, Integrity, Honor. These are more important than anything
we will teach in this class. Students can and are encouraged to help
each other understand course concepts, but all graded work must be done
independently unless otherwise specified (e.g. group work). Submitted work
should be created by those submitting it. Submission
of plagiarized code or design work is a violation of the Honor Code, which I
strictly enforce. For
detailed information about the Honor Code, see
http://www.gettysburg.edu/about/offices/provost/advising/honor_code/index.dot.
What is permitted:
- Discussing algorithms, syntax, and problem specifications with other
students
- Seeking assistance (as needed) from CS professors, students assistants,
and approved tutors
- Use of "starter code" supplied by your professor, or code you have
previously developed
What is not permitted:
- Sharing code: Verbal dictation of code, transference of code (e.g.
e-mail, file transfer, entry of printed output, etc.). An important
component of this experiential learning process is developing the ability to
independently devise algorithms and express them in program code.
- Viewing and/or using unauthorized code (e.g. solutions found online,
downloads from code repositories, etc.)
- Submitting work that implicitly takes credit for work that should be
credited to others
- Efforts to obscure the source of unauthorized work
- Outsourcing work
Put simply, students may discuss assignments at an abstract level (e.g.
specifications, algorithm pseudocode), but must actually implement solutions
independently or in permitted groups. Credit should be given where credit
is due. Let your conscience be your guide. Do not merely focus on
the result; learn from the process.
