This is my ninth course and by far the absolute WORST class I've taken in this program. Here's a breakdown of why that is:

1. The core class project. A full 40% of the course is based on completing problems from the ARC-AGI foundation. You will also find that none of the lectures apply to actually completing this project. A question that came up rather frequently during this class between my peers was "how do I actually do this?" Now, academic challenge is expected in any grad level courses but it's another thing entirely if the contents of the lecture don't come anywhere near what you are expected to do. To code up the "AI" agent, you basically are solving all problems for it. Everyone that I've talked with in this class had to basically hand write an agent that will solve the 48 problems it'll be expected to solve for the project. That's not AI, that's me as a person solving leetcode problems. Another thing, you'll spend hours upon hours of your life coding up the agent just for that to only be worth 50% of your grade. Being a traditional Joyner class, you'll have to write a meaningless paper and hope that the TA's aren't feeling too harsh when they grade it. The worst part about this is that the ARC-AGI foundation almost prides itself in being exceptionally difficult for AI systems to solve. Click the link here to see how flagship models perform against these problems https://arcprize.org/leaderboard.

2. Labs. At the start of the semester, there were 5 AI-based labs that had us interacting with various AI models to learn how different ones behave. This sounds good in principle, but what really happened was we were used as a way to gather data about how the AI systems were performing. The AI systems were so poorly designed that the entire lab assignments had to get scraped and replaced with the normal homework assignments that previous semesters had. If you want to pay almost $1,000 in tuition fees just to act as a test subject for an LLM you don't care about, then this is the class you'll want to take. And don't forget! these labs also come with their LaTeX formatted papers you are required to submit.

3. Material. None of the things that you'll be learning about are things novel or interesting in nature. This class will take exceptionally straight-forward concepts and somehow turn it into hours long lectures, where the material is so dull and dry that you'll be fighting to stay focused past the first few lecture videos. The two exams are worth 10% of your grade each, and are each 22 five-answer multi-correct multiple-choice questions long. Instead of truly testing you about learning the course content, each question and is a trick question meant to test your English skills more than they will challenge your AI knowledge base. I've watched every lecture video and gotten basically nothing out of this class.

With the new curriculum change, there are so many better options for you to choose from if you're in the AI specialization. Some classes are hard, but you'll gain a lot from them. Some classes are easy, and you likely won't learn too much in the process. Very rarely, are classes hard, and make you feel like you spent the last semester learning absolutely nothing. This class is one of those very rare exceptions.

If you want a deeper dive of what taking this class will feel like, see this reddit thread: https://www.reddit.com/r/OMSCS/comments/1udptbh/kbai_might_be_the_lowest_quality_class_ive_taken/?share_id=gAyWWEsUlFP5Vu3tYGPKT&utm_content=1&utm_medium=ios_app&utm_name=ioscss&utm_source=share&utm_term=1

This class was fine. I switched to the AI track after the debacle of Spring 2026 GA Exam 1 (75%+ of the class failed), and so I'm taking this as one of my last courses in the program.

It's a standard Joyner course, so there's a lot of writing, a lot of smaller assignments, and a bigger assignment that you work on over the course of the semester. The lectures talk about raven's matrices, but the actual project is ARC-AGI.

Everything is a little loosey-goosey with how you're expected to solve the problems, and so some of the techniques for KBAI don't click until later in the semester. There's a lot of writing, but that's to be expected.

So what this means is - if you've taken DL or ML or some of the more meaty classes, this is going to feel like a lot of busy work. If you've not taken a lot of classes, this will force you to reflect and think through problems in a way you've likely not done for a decade or more.

Overall, it's fine - not a recommend or unrecommend. Better if you take it earlier in the cycle than later.

This class was a big disappointment. Firstly, they had us QA their research lab agents and write 5 page reports on them. Secondly, this class should be called "Intro to Leetcode" because that's all this is. Sure the lectures do teach you about knowledge representations and cognitive similarities, but all the projects are just small leetcode problems and reports about them.

Class is simply not good, for a grad level. I'm at the end of my OMSCS journey and this is such a sad class to end my jouyney with. Too much tedious dull work with not much to learn. Not sure why people hyped this class up. Avoid unless you have to take for a specialization.

I feel this course is more about testing GT's research prototypes (Jill Watson, SAMI, VERA...). Lab reports focus on writing QA experience. I honestly think they should reduce number of such labs (redundant to me), or make the lab report much simpler. Current workload (agent interaction & writing) of labs is not that meaningful.

The course covers classic KBAI topics and is worth taking, but the AI collaboration policy deserves scrutiny. The policy restricts AI use to grammar checking only, one can probably argue that writing friction is where learning happens — if AI removes that friction, the instructor can't assess your understanding. That's a legitimate argument, but the course doesn't make that argument. Instead it draws an analogy to the real world: that using AI-generated work without adequate oversight hurts our professional trust. The problem is the analogy doesn't hold. Professionals lose trust for using unreviewed AI output — the policy bans reviewed, understood AI assistance too. Those aren't the same thing, and citing one to justify the other is a stretch.

It's also worth noting that this is a course about AI systems. Critically evaluating AI output — identifying where it reasons well, where it fails, when to trust it — is itself a relevant skill. A policy that treats all AI engagement as academic dishonesty misses that.

Go in with eyes open. The restriction is workable, but the justification they give for it doesn't hold up.

The labs in this class after the new curriculum was created are just not good. Feels like this course is more focused on performing QA for GT's research prototypes more than learning. I will say that solving puzzles algorithmically is fun but its not really using any AI. I won't say exactly what is in the class but imagine they ask you to prompt ChatGPT and write about prompting it. You don't actually build any Agentic AI with LLMs and focus more on representations of AI problems as state spaces/algorithms. I was looking forward to this class because I thought it would teach more cutting edge AI orchestration/data processing systems but got disappointed at how much writing and busy work it has. If I went back in time, I would've taken a different course with more coding AI and less writing (I suck at writing and hate it).

I took this class in Spring 2026, and I’m pretty sure the exams are different now compared to what people who took it in 2025 experienced. The exams are technically open book, but you can only use Canvas materials — nothing else. I heard that last year people were allowed to use AI during exams, but they removed that policy this year.

Even though it’s open book, I honestly didn’t find that very helpful because the exams are pretty tricky and cover a huge amount of material. What worked better for me was actually studying beforehand and organizing my own notes to review during the exam. You are allowed to use your own notes during the test.

I started OMSCS in Fall 2025, and out of all the classes I’ve taken so far, this one had the best overall course structure. My background is non-CS, but I majored in math and already had some familiarity with Python, so I was able to keep up. That said, it definitely wasn’t easy. You’ll probably see some people saying this class is easy, but I’d guess most of them have a CS background. If you don’t, it’ll probably feel pretty challenging. Also, you absolutely cannot use AI for any of the coding assignments, so if you’re not from a CS background it can be rough at times. Still, if you’re already somewhat comfortable with Python and NumPy, you should be okay overall.

There’s also a decent amount of writing involved. Honestly, if you lose points on the coding parts, the writing assignments can help balance things out a bit. I ended up getting an A, and I spent a lot of time on the writing portions. The rubrics are also very specific, which actually helped me understand what I missed in my coding and where I needed to pay more attention.

Course is fine... but workload is honestly insane. Class expects no AI usage despite being an AI course.

Workload was borderline inhumane. 1 week to do both code and written reports which were on average 4-5 pages. And then on top of that, you have to worry about the final project in conjunction. So like everything just keep piling and piling up. It was very difficult for me to manage work with this.

I wasn't that interested in the material, so I decided to just get a B. That said, this really wasn't that hard. About half the grade is written reports, which took me about 15-25 minutes on average. There is a detailed rubric and if you follow it and make sure to answer all the questions you'll get full points most of the time. That leave a lot of room for error on the other assignments. I got about 60% on the tests and final project performance part and ended up with 88% in the class. I stopped watching the lectures after the first test and actually did better on the second test lol.

There is a lot of extra stuff you can do for this course, so I can see why some people spend so much time on it, but if you don't want to do that, this class can be really easy if you're already pretty good at python.

While I enjoyed the concepts from this course and plan to use them in future courses, the assignments themselves were a pain to go through. It was hard to gauge on how to improve with both the milestone and mini project assignments given the concepts in the course were so abstract, but applying them into code was completely different. Only one mini project (Monster Identification) was easy for me to solve given that the lecture for that provided some psuedocode, which is what I think this course needs. If it was up to me, I would completely redesign this course to be something closer to a technical writing/design course. While still keeping the same concepts (and possibly updating them with additional pseudocode), it would be better to give students an opportunity to learn how to design their AI agents through writing, similar to the homework assignments. Then with pseudocode included, they can take their design docs and apply them into code to ensure that their agent design is efficient enough to solve specific problems. I think that was my biggest problem of this course, the lack of direction between concept and code. Taking those concepts and writing some document of how exactly an AI agent is designed (either through specific algorithms or updated algorithms based on KBAI concepts) would have much better for students to understand how to create an AI agent, especially since we're in a time where having some sort of idea of how to design AI agents in modern AI standards is a great skillset. Again, I still plan to use and apply the concepts I've learned in this course since I think that they are interesting and useful enough for my AI journey, even if they are considered to be outdated. I just wish that this course was different in its approach in teaching how an AI agent should be designed without the lack of direction between the course's concepts and the coding assignments.

The most well-put-together course I've taken at OMSCS. I enjoyed the lecture videos, homework, and mini-projects and project milestone assignments. I found the final project to be very challenging to fully complete. The grading rubrics are clear and advertised, and the teaching staff is engaged on the class forum. The content was very interesting and scratched an itch that I had to learn "classical" AI for a long time. I wish more time was spent on the planning and logic sections, as a personal preference, and that some kind of pseudocode was provided to understand how the concepts might be implemented in code. Overall, would highly recommend to others.

The final grade has not been released yet, but I expect to get an A with a high score.

My overall takeaway is that as long as you watch the lecture videos first and understand the related concepts before doing the assignments, it is not hard to get a high grade.

The course content itself is not difficult, but it consists mostly of scattered concepts. It feels more like a humanities course, and it is completely different from the engineering- or programming-oriented AI/ML courses that many of us may expect. Because of that, the workload feels excessive compared with the limited practical value of the course content.

Most of the assignments felt meaningless. It was like learning 1/10 worth of useful material while putting in 12/10 worth of effort.

Joyner added many components that may look positive on the surface but are actually not very meaningful and can feel overwhelming for students, including the reading club, peer reviews, weekly assignments, and Ed participation points. These may make the instructor seem very responsible and dedicated, but considering the actual usefulness of this course, reducing the workload would have been a better teaching decision. The ARC-AGI project was mostly meaningless busywork and had little connection to the course content. Students also posted excessively on Ed just to earn participation points.

I never learned about AI, this is so much fun and hard for beginner level who want to know about AI. I enjoy working assignments, projects and lectures. everyweek, you have something to submit, currently, before i took Exam 2, still i can manage to keep on the margin of grade A and B. I love it and recommend it whoever want to learn from the beginner level and enjoy the coding with python. you can try it.

I don't really get all the complaints about this course. Some on reddit said "this is the worse class ever" while others on discord were saying that it was BS...uh...were we taking the same class? I guess one valid complaint is that the lessons aren't very applicable to industry, but like, that describes 70% of the content in this master's degree (except for GIOS, that class was amazing).

I thought the class was pretty decent, even good at times, actually. Like sure, it's a David Joyner class so it will have a fair bit around of busy work but overall expectations were very fair and the homeworks and projects were pretty relevant and reasonable. I thought the course was altogether quite easy especially compared to summer ML4T and the TAs were very helpful.

I wasn't a big fan of the lectures but some of the projects were fun and relevant. I personally reused my decision tree code from ML4T for one of the miniprojects and you got introductions into important algorithms like A*, DFS, BFS if you chose to use them for the miniprojects. The new ARC-AGI project was also pretty fun and while some say it was harder than the old raven's projects, I thought it was very reasonable so long as you don't procrastinate. One key thing to note is that you get points for the training problems too, so literally you are guaranteed at least 50% of the code portion of the points if you aren't lazy.

Some complained about the TA grading but I didn't have any issues and got literally a 100% for every written assignment I submitted. All I did was open the rubric (there should be a table rubric for each assignment) and I wrote to the rubric. Put my subtitles in my paper as the exact same row name in the rubric and wrote to the rubric, and I never had a problem with grading. Heck, I thought the grading was more lenient than most of my undergraduate classes. Seriously y'all. Were we even taking the same class?

Overall, 10 to 15 hours a week for this class as long as you are consistent. Pretty moderately easy. I think hardest parts were a few of the mini-projects and milestone D of the ARC-AGI projects, but if you do well enough on the mini-projects you can afford to half-heartedly address milestone D.

This course was my first OMSCS class. I came away with mostly positive feelings about the class.

For starters - Dr. Joyner and the TA we excellent. They were super responsive, engaged, and enthusiastic. I think that the decision to migrate the semester project to ARC-AGI from Raven's Progressive Matrices was awesome. I appreciate how much work that must have taken - and I feel that it greatly enhanced the learning experience.

Another positive aspect of the course is how well organized it is. It is clear from Day 1 exactly what you need to be successful in the class. Everything is available from the jump and this would be a great class to work ahead in if you wanted to. There are many assignments throughout the semester. While this can be a bit grating, or feel like busywork at times, they were generally interesting. And opportunities for easy points. Sometimes other reviews for other courses discuss being annoyed with the uncertainty - and I feel like this class is the antithesis of that.

The lectures I found interesting at times. Unfortunately, they didn't feel as "rigorous" as I wanted them to. I feel like there are more abstract topics in computer science (like algorithms) are theoretically/mathematically well founded. Or there are more practical classes (like Operating Systems) which are grounded in their practical application in the real world. KBAI feels like a course discussing a particular view of artificial intelligence which is neither mathematically "true" nor broadly in use. It is a very "vibey" class which kinda left me feeling like I was not learning a "real" computer science topic.

Some people in the class complained about the peer review software or some of the other administration of the class - but that never felt like an issue to me. Also - people who were complaining about not getting perfect scores on the assignments seemed to be missing the forest (an A is extremely attainable in this course) through the trees (missing 5% due to poor formatting on a report without comprehensive enough TA explanations).

In summary - I think this is one of the best ran classes I have ever taken. It really does not waste your time teaching you the material along the way. Ultimately - the subject matter / topic did not completely resonant with me. Which colors my rating + feelings of the class. But depending on what you want out of it - it could be a perfect class.

Background: 1st semester student, Undergrad CS major, working as a Data Scientist for less than a year.

Finished the course a month early and ended up with an A(91.89%).

Pros:

• The lectures are very interesting and enjoyable, and they are presented in a way that’s easy to understand.
• The coding assignments aren’t too difficult and are manageable.
• The TA and Dr. Joyner are great and respond quickly when help is needed.
• The integration with gradescope is cool, you are able to submit coding assignments up to 40 times and it auto grades so you can see your grade right away. Cons:
• The lectures don’t align very closely with the assignments; the assignments aren’t really AI focused and feel more like general coding tasks.
• The writing assignments feel somewhat useless and repetitive more like busywork that could be avoided.
• I received feedback on early assignments, but later in the course I didn’t get any feedback at all.

Homework(15% )- 90/100: These are writing assignments (journals) based primarily on lecture material. Make sure to follow the prompt questions closely and answer them clearly and completely. Demonstrate a strong understanding of the relevant lecture concepts and apply them accurately. When a prompt asks for a diagram, ensure that it matches the one shown in the lecture exactly. In a previous assignment, I mixed up two concepts and received no credit for either, which resulted in a C on that assignment so accuracy is very important.

Exams: Midterm(7.5%) - 70.91/100, Final(7.5%) - 92.72/100: I’m not a great test taker, so I didn’t do very well on the exams. They aren’t too hard since they are open notes and open internet including AI, but you still need to understand the concepts really well. On the first exam I struggled with time management and ended up turning to ChatGPT as a last resort, which didn’t help much. After that poor result, I made really good notes and used NotebookLM by Google to ask questions based on them for the second exam, and I ended up doing much better. I recommend that if you are unsure if a statement is correct to leave it unselected.

Mini Projects: Performance(15%) - 98.5/100, Journals(15%) - 95.4/100: The coding assignments are fairly easy and similar to medium-level LeetCode problems, so they shouldn’t take too long, except for Mini-Project 2 (Block World), which was difficult and cost me a few points. Overall, the assignments are manageable. The writing assignments are short (max 4 pages), but I lost points for not including metrics related to efficiency and performance.

ARC-AGI project: Performance(7.5%) - 100/100, Journals(7.5%) - 100/100: For the assignments, you’ll be solving ARC-AGI problems by creating an agent. I didn’t implement any real AI methods myself, what I did was design a specific solution approach for each problem. To achieve full credit on each milestone, you need to pass at least 6 out of 16 general test cases and 6 out of 16 hidden test cases. The journals can be repetitive, so feel free to reuse the same structure each time. Just make sure you include specific metrics for each milestone, including: Efficiency: Big-O complexity and actual runtime, Performance: Number of test cases passed Keep in mind that even though you only need 6/16 for both general and hidden tests at each milestone, you’ll eventually need to solve all of them for the final project. Because of that, I recommend completing as many problems as possible throughout the milestones rather than waiting until the end.

Final ARC-AGI project: Performance(7.5%) - 84.38/100, Journals(7.5%) - 76/100: Each milestone (Milestones B through D) includes 16 general tests and 16 hidden tests, for a total of 48 general tests and 48 hidden tests across all milestones. I wasn’t able to solve 15 of the hidden tests, which left me with a performance score of 81/96. My performance wasn’t as strong as it could’ve been because I decided it wasn’t worthwhile to spend hours trying to figure out each hidden test for just a 1 point increase. The final journal grading is much stricter than the other journals. I answered every question on the assignment, but some parts were considered vague by the TAs, which lowered my score. I put in the same level of effort as I did for every milestone, where I earned 100 out of 100, but the TAs expected more for the final journal. I recommend being very clear and keeping in mind that the grading is stricter.

Participation(10%) - 100 / 100: These points are basically free, and there are plenty of opportunities to earn them. I mainly completed peer reviews each week to stay ahead. After about two months, I had already earned the full 90/90 points and didn’t have to think about it for the rest of the semester.

I found the lectures interesting but not terribly helpful. I really like the professor and admire the effort he puts in to provide a good learning experience and a great class though. The goal of the lectures is to teach first principles to use solving ARC AGI problems, but because there's not a lot of machine learning from data it feels less like an AI course and more like a few dozen leetcode problems. Some concepts were more advanced, like incremental concept learning (decision trees updated one data point at a time) but many AI concepts felt more like I was the only intelligence involved (represent problem with a state space, use guess and check to solve, etc). Most of the hours I spent on the class were on the semester long project, with took me around 100 hours. In retrospect I think it would have been faster and easier to ignore the course concepts and write a separate algorithm for each of the 48 types of puzzles than trying to build a general solver that uses course concepts like I did. The tests weren't fun but they felt pretty pair for other GT classes, and the rest of the mini projects were pretty quick. The course has a significant participation grade that required reviewing other peoples reports (required with each coding project). I wasn't a huge fan of that aspect, and felt like the reviews were not helpful, but they weren't too inconvenient.

I enjoyed this course. It helped me frame my perspective about AI Agents. The foundations on how an AI Agent need to be built is interesting. Newly introduced ARC AGI is fun. Summer was little short in duration to do ARC AGI project in truly KBAI manner. However, I feel I have broadened my thinking and knowledge in this field after this course.

TL;DR: - OVerall, I liked the course. There is a lot of work involved. TAs are good, there needs to be better connection between lecture material and projects, you will write a lot and the participation portion is not that bad.

I took this over the summer and paired it with AIES thinking a medium and an easy class would go well together. Overall, I was correct. Lots of people have outlined the course contents and what you need to do. For a point of reference, I finished with a 93% for the course. Here are some thoughts on the course:

1. You will write a lot of reports. I found them to be better than I expected. You are given a rubric to follow. If you follow the rubric, format the report so that sections match the rubric sections and you answer the questions in the rubric in each section where they are asked (even if you occasionally repeat yourself) you will be fine. After the first one or two, you get the hang of what they want. I can't prove it but adding in diagrams and flowcharts seem to help the grade.

2. There is a lot of (busy)work. Canvas shows 31 graded assignments ranging from a few course surveys to the final exam and final project. You will be busy with multiple things due each week.

3. There is a lot of "noise" in the course. Ed is filled with lots of extra posts on topical things that are not required but meant to build an online community and discuss ideas. You can decide if they are worth participating in.

4. The lectures are somewhat dated and Dr.Joyner is working on updates. He released a few of them this semester for us to preview and comment on.

5. The lectures are very much at the 30,000 ft. level. They cover a topic with examples using Ed Lessons. When you are done, you know how they work but there is no practical "how would I implement this?" or "What does the algorithm for that look like?"

6. The final project - ARC-AGI was a lot of fun. Unfortunately, many students (including myself) use a more brute force approach to solving the project because there isn't any guidance on how we might connect the dots from the 30,000 ft. level to the 10 ft. level of implementation. On the project implementation I got a 73%. Because the project implementation weight is only 7.5%, it wasn't worth the remaining hours I had left to get to 100%. Time was better spent on the report (which I got a 100% on) which isn't directly linked to how well you did the implementation but is heavily linked to how well you can explain why you chose the method you did, where it worked well, where it struggled, etc. I suggested they cut the project form 96 test cases to 60 for the summer due to the compressed schedule.

7. Participation - You need 90 points to get full participation credit. If you participate on the forums, ask questions, answer questions, make comments, you can get 40 points. If you join one of the reading groups and make it to all five meetings, you can get 25 points. They have a wide range of books and I found this to be a highlight of the course. That leaves you with 25 points to get. Each peer review that you leave if done in a timely manner is 1.5 points and they take about ten minutes to write. My suggestion is to do reviews on the ARC-AGI reports that you write for each of the five deliverables. You can do extra ones up front and get done early. This is a good way to see how others are implementing their project and get ideas you can use for yours. You can get the last 25 points from doing 17 or 18 peer reviews. I found them to be helpful.

8. With so many small assignments, one bad assignment is not going to kill your grade. I see this as a positive.

This course is an absolute nice choice for those choosing the AI track (formerly the II track). After taking it, I found it to be significantly easier than the ML and AI courses, and getting an A is quite achievable. I spent about 4–8 hours per week on this course. Only one or two of the mini-projects were relatively challenging. I recommend that those who don't want to spend too much time directly take a case-by-case approach for the AGI project, rather than trying to develop a strong generalized AI method (this is for efficiency — if you’re passionate about KBAI, then you should go for it).

As for the exam, since it allows the use of any online resources, I barely prepared and completed it using AI (which is permitted). The exam score generally doesn’t have a decisive impact; as long as you perform well on other assignments, a score of 70 on the exam is acceptable (in my opinion, this is the lower bound for using AI without your own thinking). Similarly, it’s hard to rely on the exam alone to pull your grade back up to an A.

Finished with 93%. Projects are doable, and difficulty is manageable. Aim to collect max points for each assignment, and you will end up with A. The actual ARC-AGI problem becomes difficult as you progress through the semester, so it will be difficult to collect the full points later. If you follow the Slack and Ed Forum, other students usually give a lot of hints on how to solve problems.

This is my first OMSCS course (planning on a double concentration in ML and II). My background is a software Engineer for almost 2 years, did Undergrad Major: Management information Systems, minor: computer science. Only class I took this semester.

For an intro-course to grad school and getting my brain in learning shape, this was a great course for that. Wasn't exactly easy, but not too rigorous that I would be destroyed. Initially was spending about 5 ours more than the average I selected, as I took my time to be extra careful and wanted an A to give me that confidence boost, starting Grad school. Spent less time around the middle of the semester as i had gotten acclimated to it and some assignments were objectively easier. In terms of usefulness, not super confident what the real world applications of some of the lessons learned, but does introduce you to thinking patterns, libraries, etc that i think will be super helpful in more advanced courses down the line.

I thought this course was alright. My impression was content isn't very hard to understand, so they overload you with busy work to make us feel like the course is difficult. Some of the assignments are helpful, and some are just extra. Grading at times seemed arbitrary with insufficient and/or repetitive feedback given by TAs, despite the fact that rubrics are public. That being said, I don't know if this turned out to be that difficult of a course (though Exam 2 and final paper grades are outstanding, so maybe it's too early to say) all things considered. In addition, for what it's worth, Joyner did seem gung ho about getting feedback, but it's definitely too early to say that's a good sign, as instructors gathering feedback and instructors acting on it are two very different things.

I greatly enjoyed this course. Ill break this review in to lectures, instructors, and assignments.

Lectures: 4/5 The lectures are engaging, interesting, and well taught in my opinion. Its a Dr. Joyner class, so if you like the EdLesson style he uses, you'll be right at home. I really liked Dr. Ashoks lecturing, and the cognitive science tie ins are very interesting. My only complaint is that the lectures are very high level, focusing only on concepts, and leaving implementation of all assignments and projects to the student with little guidance. If youre well versed in python and numpy this is okay, but if not, consider brushing up first.

Instructors: 5/5 The instructors wand TAs were awesome. They were very helpful, responsive, and reasonable. They take the time to answer all major questions on the forums, and have some grace/understanding when severe circumstances cause the need for an extension or similar.

Assignments: 4/5 There are homeworks, mini projects, and a course project. The homeworks felt a bit useless, at least half of them did. I breezed through pretty easily on that front. The mini projects were a bit more substantial and felt a lot more interesting and related to lecture. They had a wild range in difficulty with the shortest one taking me ~20 minutes to complete with an A, and the longest taking north of 10 hours, so watch out for that. The course project has changed from Ravens progressive matrices to the ARCAGI challenge this semester. With it being the first semester, it was a little rocky, but I still learned a lot and had a great time. There are a lot of kinks to work out, but the instructors are asking for feedback, and seem very open to addressing these issues moving forward, so I am very confident this will mature in to an awesome course project after another couple semesters of trial and error.

Overall, with a background in CS and ML, I had no issue getting an A with 8-10 hours per week. but I did see people on the forums talking about taking 15+ hours to get a B. Because of this, I would say taking a more intro level AI or ML course first would be smart if you dont have a formal CS background like an undergrad degree. I would say that the new project is a lot more time consuming than the old project, so be weary of older reviews that suggest this as a first OMSCS course or an easy A. The instructors make the grading requirements very clear, and they are quite fair, so an A or B is absolutely attainable as long as you are on top of the work.

I'm currently finishing the class and I'd say that it was an excellent first introduction to OMSCS! The class is somewhat intensive but not to a mind-numbing degree and the projects can be somewhat fun.

There's three main parts: the mini-projects, the homework, and the final projects. There's also two exams.

The mini-projects are fairly fun. The first three are fairly difficult with the first two relying on array/logic manipulation, the third being solely NLP, and the fourth and fifth being a breeze with some people reportedly finishing the fourth with only about ten lines of code. Most of the projects also score you partially on accuracy as well as efficiency, so if you reach the correct answer but not in the optimal number of steps then you may lose points. You'll also need to write a paper for each project which will be half of the points for that project.

The homeworks are hit or miss. If you're the kind of person to miss instructions often, then make sure to read them very thoroughly. Otherwise, the lectures are helpful to review for these.

The final project is the new ARC-AGI challenge and it seems like the general consensus is that it's just a bunch of leetcode challenges tied together with a detection system. Most people are currently aiming for about 75% for this one, so the difficulty is definitely fairly high. You'll be writing papers for these too. I didn't hate the project, but make sure to complete as much of the Milestones as you can before the final project is due.

Overall, great first class! I think it would give anyone coming in a nice introduction to OMSCS as their first course, as it's mildly rigorous without completely pulling the rug out from beneath you. You'll need a strong understanding of Python and Numpy though.

Full review here! https://the11d.wordpress.com/2024/12/31/my-thoughts-on-kbai-omscs-review-6/

TLDR (Thanks GPT!)

CS 7637 (Knowledge-Based Artificial Intelligence) in OMSCS provides a deep dive into classical AI from a cognitive science perspective, emphasizing symbolic reasoning over statistical methods. The course features a rigorous workload, including weekly assignments, open-ended mini-projects, proctored exams, and a semester-long project to build an AI agent for solving Raven’s Progressive Matrices (RPM). Students need strong Python and writing skills, with challenges like Mini-Project 2 requiring significant logical problem-solving and creativity. While some content feels outdated and involves busywork, the course’s engaging lectures, unique problem-solving opportunities, and focus on foundational AI concepts make it highly rewarding for those interested in classical AI approaches. The reviewer rated it 3.8/5 for quality and 3.1/5 for difficulty, recommending it for students eager to explore cognitive science and symbolic AI.

This is one of the worst course I would say. They have lots of documentation and peer reviews you need to do. Almost 55 marks in useless peer reviews and documentation. Rest 45 marks is the one you would gain from the actual course. This is just lame course where you would not get any help and have to rely on yourself alone. I would rate this as 0

Avoid this class if you can!

This isn't a tough class but it has a ridiculous amount of work. Weekly papers to write and coding. Some coding assignments are very easy, you can finish them in a few hours. Mini-Project 2 took me weeks of coding and I couldn't get a high score.

You can front load this course since pretty much everything is released in the first few weeks. I got a lot of stuff done initially and then got stuck with Mini-Project 2 and had to keep up with the weekly load.

I didn't do too well on the Final Project unfortunately and I had to focus on getting a good grade on the Final Exam. I only wanted a B in this class but I could have easily gotten an A if I wanted to.

Again, avoid this class if you can. You will be fine if you do take it, just start early and stay on top of things.

Finished the course with an A, achieving a 94%

Background:

• Bachelor's degree in Computer Science from a university ranked #377 out of 436 National Universities in U.S. News
• English is my second language (TOEFL score: 95/120)
• 1 year of experience as a full-stack developer

Overall:

• The lecture is easy to understand, thanks to the excellent course design (one of the best-designed courses compared to others)
• The concepts in this class are very abstract, focusing more on high-level design rather than low-level coding. If you're interested in designing AI systems, this is a great class to take. However, if your goal is to focus on coding, consider switching specializations and avoiding this course
• This class includes a writing section that requires you to produce "graduate-level" papers. From the peer feedback, it’s clear that some people do not meet the required standards (Follow the rubric and explain your work in detail)

Homework (13.75 / 15%): Create a diagram to help explain the concept clearly. Avoid relying solely on plain text; the TA might deduct points if the explanation isn't engaging enough. Image the grader is likely at a high school level, so your explanation should be simple and easy to follow

Exams (6.07 / 7.5% - midterm, 5.45 / 7.5% - final): I’m not a strong test or exam taker. While the tests aren’t necessarily hard, they can be tricky and require a solid understanding of the concepts. Personally, I found some of the English questions confusing, which made things even more challenging. Fortunately, the exams don’t carry much weight in the overall grade, which was a relief. The class average is typically around 88–92 out of 110.

Mini Project(14.93 / 15% - Performance, 14.93 / 15% Journals): Start working as soon as the materials are released. The assignments are very straightforward if you're familiar with LeetCode, as they are comparable to easy-to-medium questions. The only point I missed was Project 2: Block World Agent—it’s difficult to optimize this project effectively. Additionally, I forgot to include the Gradescope score in my journal submission. Make sure to start Project 3: Sentence Reading Agent early to stay on track

One big projects(14.06 / 15% - Performance, 14.81 / 15% - Journals): Read the guidelines carefully—many students skip the syllabus and end up working on challenge questions, only to realize at the end of the semester that those don’t count toward the grade. Focus on solving the questions that are part of the grading system first. If you want to take on the extra challenges, feel free, but make sure your priorities are clear. There are often complaints from students about going in the wrong direction, but the expectations are clearly explained at the start of the semester. Overall, the project is challenging but manageable. The instructor has stated that it’s difficult to achieve 100% on this project, so don’t stress too much about perfection. Aim for a solid score and dedicate your time to other tasks as well.

Participation(10 / 10%): These are essentially free points, and there are plenty of ways to earn them. However, many people still complain at the end of the semester that it’s hard to achieve. The key is to start early in the semester and carefully read the syllabus to understand how to earn these points. It only took me 30 minutes over the first 12 weeks to get 100% in this section, finish it early, and save time for the final project

I deeply enjoyed this class. My background is as an architect who was promoted out of hands-on development into management a while ago - and I miss coding. This was my first OMSCS class and I found this class excellent for shaking off some programming and academic rust. I also genuinely enjoyed the topic.

In my opinion this class is a good choice for two groups of people:

• People interested in specifically exploring AI that thinks like humans (i.e. the subject of the class)
• People looking for an enjoyable and well-run class to get them into the swing of OMSCS.

Despite this being a very popular class in the program this class’s main topic is actually a bit niche - AI techniques to specifically mimic how humans think isn’t the current most popular branch of AI (that’s Machine Learning) but I do feel these ‘classical’ techniques may provide some potentially interesting avenues for AI in the future.

The Good:

• Class is very well-run with a lot of engagement from the professor, responsive TAs, and clear expectations.
• Mini-Projects are fun and a good balance of being interesting without being too challenging.
• You can absolutely work ahead in this class.
• The class feels extremely fair - if you’re willing to put in the work you can absolutely achieve an ‘A’
• There’s supplemental material available if you’re at all interested in the topic - lots of additional stuff to explore.

The Bad:

• The class is just a lot of work - it’s ‘only’ 12-15 hours a week but you’ll be actively producing deliverables (coding, papers, peer reviews) for almost all of that, and some of it (esp in the homeworks) can feel very busy-work. Getting the homework into the page length requirement can be harder and take more time than the homework topic.
• RPM is easier to implement using CV heuristics rather than class topics - I’ve heard they may change this project in the future which I do agree with, because while it’s a lot of fun as a project it’s much harder to use KBAI techniques rather than just bypass them and use CV heuristics.

The Controversial: Some students seem to feel the later lectures are ‘just simplified cognitive science’. I’m not sure where this idea comes from - these lectures cover architectures for KBAI (Explanation Based Learning, Version Space Learning, Commonsense Reasoning, etc.). I think because the techniques aren’t implemented in code during the class some students don’t really connect the abstract techniques/architectures to how one would practically implement one of these systems. So depending on your level of interest in the specific subject (KBAI) these lectures are either going to be the most interesting or most boring part of the class.

Me: Undergrad in CS. Fresh graduate. I'm a full-time student. I took this alongside HCI. It's my first semester at GaTech.

Grade: A (95%)

It's a good course. I'm not sure how relevant the concepts are any more, but an interesting course nonetheless. Ed Discussions are fun and informative. TAs are helpful. Rubrics are clear, so it's easy to score full mark on assignments. If you have some experience in python and coding, especially an undergrad in CS, this course should be very easy. Report writing can get annoying, but it's not hard. Start assignments early and it's easy to stay ahead. Staying ahead will give you a lot of buffer room. Especially if you finish early, since everything is available from the beginning.

KBAI is a good intro class for the II track in that it warms up the two kinds of things which you'll need to get ready to do in a graduate school program which is a mix of ML/AI and HCI: understand requirements and clearly write about your understanding and implementations.

I have heard (substantiated) rumors that they're changing the core project (Ravens Cognitive Matrices) to something else. For me, that project was something that I "went ahead" with in the beginning and obsessed with it for a bit, did ok enough, and then never touched it again. It's interesting, but I found it interesting in a short dedicated effort kind of way rather than a longer set of small effort kind of way. Maybe that's just me. The projects varied, but I have no complaints. It felt like they added closed book/note quizzes because that's what classes do; I don't think they added much, and I think the main thing they did was to stress me out before taking them. But overall, a whirlwind tour of some (generally) non probabilistic AI methods; could be inspiring for someone interested in intepretability?

NOTE: DO NOT TAKE THIS CLASS!

I haven’t reviewed any of my other classes, but I’m making an exception for this one because I disliked it so much that I feel compelled to warn others. I expected this course to be an enjoyable, easy experience, like CS-6795 (Intro to Cognitive Science), but instead, it focuses on basic concepts and how AI agents mimic human behavior. Unfortunately, you'll spend your time on pointless tasks: 5 mini-projects, 3 homework assignments, 4 milestones for a major project, and 2 exams. Every week, you're also required to peer review three classmates' papers, but most people barely skim them for participation points. The projects are tedious and offer no real learning value—you won’t be working on anything cutting-edge or relevant to your future career. For each assignment, you’ll end up writing around 5 pages, totaling 65-70 pages for the entire course. If you're serious about learning something that will advance your career, do not take this class. I wish I had read the reviews before enrolling.

TLDR: Do NOT take this course - you will spend an incredible amount of time but learn next to nothing out of it.

This has been an absolutely worst class for me, not only in the program but probably among the other 20+ graduate courses I've taken throughout my life. There was maybe a course or two where I learned less but then they required much less work. There were courses with higher workload, but then I learned much more from them. This course feels like an incredible amount of busy but absolutely useless work. Even the lectures: very lengthy but with minimal breadth. A student in our class summarized the content of the entire course in a 19 page PDF and that was all in it. And even this summarized material has very little to no practical use. Some mini-projects and the course-long project were kind of fun to work on but they had nothing to do with the course material. Also, keep in mind that each programming assignment should be accompanied with a write-up. On top of that, there are 3 homeworks that are purely write-ups. So it feels that you are taking an English class, not a CS one. To complete the picture, the questions on the exams were also worded in an incomprehensible way. The only good thing in this course for me was that working on the course-long project I got an intro to OpenCV that I wanted to learn. Finally, if you care about your grade (that I was not much though somehow managed to get an A), the written parts are graded absolutely arbitrarily and no re-grade request were acknowledged.

My Background: B.S. in CS from a reputable university. 4 YOE as a SWE. I've taken CS 7646 and 6310. I found CS 7646 was good preparation for this course, but consider CS 7646 more difficult than this one in many ways.

Course Performance: Safe 'A'.

Recommended Background: Have Python experience before taking this course as its first projects require OOP Python from the get go with no build up. Know your graph algorithms - especially breadth-first search. There are courses on edX by Georgia Tech that can provide the required Python background for this course if you don't have prior experience.

Tips to Do Well in the Course: 1.) To get full participation points when reviewing classmates' papers, use the grading rubric for the assignment to structure your response. 2.) Write your project journals based off of the grading rubric for time efficiency and to ensure you cover all required items. 3.) Scoring well on the final project's performance section will take way more effort than other assignments. Accept that your grade is going to take a hit on the final project and ensure you do well on all assignments before the final project. 4.) For mini-projects you don't necessarily need to worry too much about efficiency. Try a simple, brute force approach first then seek to optimize your solution. 5.) Take page-numbered notes during the lectures and organize them by a table of contents. Reference those notes and ctrl-f search the transcripts of the video lessons for exams for any questions you're unsure on. The timing of the exams was nice and not intensely pressured like many OMSCS courses. 6.) Do Peer Feedback tasks and do them early. You get 3 times as many points for doing them early. Try to do as many as possible in the beginning of the course to frontload the workload for the course as much as you can. 7.) Prioritize doing extra peer feedback tasks for the RPM project so you can learn from your classmate's approaches. Keep a google doc of notes of things you learn from your classmates that you may want to incorporate. 8.) Participate in the EdDiscussions in ways that are enjoyable for you. For me that was answering classmates' questions and participating in the Wednesday Debates. 9.) Pay attention to JDF format! Ensure your margins and font size are correct. They mostly care grade-wise if you're using margins or font sizes that allow you to write more than other students. Create a Google Doc template that follows JDF format and make a copy of this before each assignment to efficiently ensure you follow the required report format. 10.) Monitor EdDiscussions. The course is set up to be very collaborative. Learn from your classmates and their posts.

Course Thoughts:

The course material is very interesting. Knowledge-based AI is more intuitive in that you can understand how an agent arrives at its answers. This course provides interesting methodologies to allow your agents (programs) to learn that differ from machine learning. The course feels like it supplements an algorithms course in that it explores problem-solving strategies and gives a more intuitive language to algorithms than I had encountered before.

The course is well-organized and the expectations are clear. The course has a demanding workload, but I would not say it's overly difficult as some of the posts here state. Start your assignments early and do not procrastinate. All course material and assignments are available from day one.

Course Critique:

1.) The homework assignments are busy work. Their material is already covered by the mini-projects. I think the level of work for the course is appropriate except for these homework assignments. 2.) The course project revolving around Raven's Progressive Matrices (RPM) is really interesting! Unfortunately, the need to learn vision processing to apply the course concepts encourages much easier, gimmicky strategies that do much better. I think this course could be greatly improved if the vision processing necessary to create conceptual models and analogical mappings of the RPM problems was taught as part of the course. This would help students that want to take that approach to apply the concepts from the course more. Otherwise, the concepts from the course get rather disconnected from the final project through the use of DPR, IPR, and case recording which score extremely well but don't really apply course concepts. Meanwhile, actual vision processing based strategies applying the course concepts require way more work and don't perform as well.

The semester long project was very rewarding and fun to work on - but it was worth very little of your total grade. 7.5% for the report, 7.5% for the actual code. Getting 90-100 percent on coding assignments didn't take much effort (and were fun!), but the written reports accompanying the homework assignments are graded according to a rubric that is ---not--- 1:1 to the assignment instructions.

Make sure to read the report rubrics and title sections/bold phrases exactly as they appear in the rubric. <---------

If you do the first few assignments without realizing this, you will lose a good percent of your grade. Especially in Summer - you will be turning in multiple assignments before you get your first batch of grades. Given written reports (outside the final report) are 47.5% of your grade, getting 2-3 bad grades without realizing this can significantly impact your grade and make it unnecessarily difficult.

You don't really need any pre-reqs for this course - know some basic Python and you're okay - this is a good intro course.

tl;dr I recommend the course and found the content fun and rewarding, but be aware that the project and tests are not the most important grade-wise.

The lectures are enjoyable and thought provoking, but not very informative and very abstract. it doesnt map to algorithms most of the time. The negatives here are as follows, the course provides no exxtra value than watching the videos on youtube or without actually enrolling to the course. There are no office hours , tutorials nor TA engagment like other courses, grading is alway super late, and feedback is a few words so not helpful to learn from TA correction. Also course load is way more than the learning value as you have to write and review alot, which doesnt help the learning process as much as they portray it. This course relies on the fact that class participation is graded so that people help each other rather than TAs supportting which in my view didnt work much. Its easy to get an A if you put the effort although effort does weight well aganist the amount of learning. Last nitpick is you re betteroff implementing most projects from you prior algorithm knowledge than trying to implement philosphies in lecture and after just attempt to link them together which is also disappointing somewhat since course knowledge is not needed for any of the project even the final ravens project. for final project go for simple pixel and image difference approaches saves you so much effort and time from trying to apply course shape relationships and will get you a higher grade.

Horrible class....the concepts are good but the staff is absolutely abysmal. Students are setup for failure. It is quite evident in almost every GT OMSCS class. You can literally see students crying and complaining but the staff takes no interest and just says "Yeah well thats the standard of GT". They are right... bad teaching is a standard at GT. Students are setup for failure here....Dont do OMSCS. Go to a school that cares about your mental health. So many better schools like UT Austin, Purdue etc. where they actually care about what matters and not stupid stuff.

Review #2 Summer 2024 learned nothing, forced to see psychotherapist 3 times, chiropractors 5 times. Dropped

One question: Why do I want to read the garbage other people has written using chatgpt 3x or 6x every week?

Took it as my first course while working full time. I do have a decent amount of experience in software but not with Python, which is the language we used for all of our projects in this class. wrapping up with python and getting familiar with some of the libraries look some time but was not the main problem. This course has ALOT of weekly tasks which makes it a very difficult first class. On top of trying to get back into school, especially an online school, and learning how to use Python to deliver the projects which one is due almost every week, we had to write 5 page papers weekly, do at least 3 peer reviews, watch 2-3 lessons that were sort of boring, midterm, final, and a very difficult final project which we gradually build during the whole class timeline that hold a pretty big chunk of the overall grade .I had a 90% and it dropped to 86% because the TA gave me a super low grade on the paper, although I had been receiving mostly A's on all my papers.

Its a good class, but I wouldn't suggest it as the first class due to overload of assignments due per week.

Feels like another crappy course so far

This was my first course in OMSCS, I thought it was a solid introduction and ramped me up well. I had a solid professional background in software going in (undergrad in CS, SWE full-time) and found the coding assignments provided reasonable value and were very approachable.

The most valuable part of the course was the context of AI, the introduction to and histories of the topic, and the approach of development for various solutions. The term-long project can be daunting at first, but was a fun challenge by the end of the term - it's very approachable if you build cleanly from the start and meet the milestones as recommended.

There was a fair amount of writing, probably 50-60 total pages of reporting in JDF throughout the course. This was my first time using the format and it's quite approachable. The rubrics for these assignments were very refined and it was easy to get full marks by referring to the rubric and assignment description - they explicitly state what they're looking for.

Lastly, the staff were extremely helpful and very organized. In contrast to some other courses, they're on another level in terms of successful course management.

WHAT A WASTE OF TIME! This was my 7th course in the program and by far was my least favorite. I did not learn anything at all. The lectures are so boring. All my time wasted for tedious reports and peer reviews. There are a couple of interesting mini-projects at the beginning but the rest are so useless. Homeworks are the worst part of the deliverables. Tip: For peer reviews, write a lot and do not just write the three required ones. Go for extra peer reviews if you want to get a good participation point. I lost some points since allegedly my reviews were not detailed enough.

This is the BEST OMSCS course I've taken so far. This to know:

• There is a ton of writing and peer reviews. Very similar to HCI.
• There is a semester-long project to build an AI Agent. You can find tons of information about this all over the internet.
• An 'A' is possible with 10-15 hours of work each week.
• There are mini-projects throughout the course that can be brute forced. Don't overthink them. You're trying to get an A, not impress a leetcode interviewer.

This was my first course in OMSCS.

Honestly a really well-structured course, it becomes very apparent that they have been considerate of different learning styles and different viewpoints. Lectures are impressively well-put together. Instructor and TAs were really accessible and responsive. Content was pretty easy to digest, and complexity of assignments were very fair (sometimes too easy).

However...terribly time consuming. Almost weekly, we had to do some coding assignment, write a paper about it, and do some peer reviews on top of that. While it's still quite an easy course, sometimes it feels like there's very little time for a break, so work ahead whenever possible!

My background: I am a software engineer with a few years experience, and I have a BS in Computer Science.

In general, this class was fairly interesting, but nothing too exciting or challenging. The main course project revolves around solving problems in "Ravens Progressive Matrices" (those IQ test type questions with 3 images, and you have to solve for the fourth one). This project was fun to screw around with, but it was not really related to any of the lectures. I was able to get ~70/96 by just screwing around with my own heuristics and not reading any papers that others were using to score higher.

The lectures themselves were pretty interesting and well organized. I wish I spent more time just listening to them for fun, but as I said it was hard to apply most of them to the main RPM project. There were six mini coding projects that related to the course materials that were pretty interesting and not too hard. There were some written homeworks as well which were more annoying than anything, but they were fine.

There was a lot of drama related to participation, but in my opinion it was extremely easy to get a high participation grade by just doing the reviews at the beginning of the week, requesting extra in the beginning, and posting on the forum for extra points. I got way more than the max points without even really thinking about it.

Every assignment involved a ton of writing, but it was never really that painful to get the assignments out. A lot of people had anxiety about how to score all of the points, but if you just read what they want you'll probably get most of the points.

The exam was kind of annoying, since it was worded confusingly, but we were allowed to use the course videos, transcripts, and Google/ChatGPT as well, so they were not too bad.

In the end, I assume most people taking this class are doing it for the interactive intelligence specialty, and don't really care about this review. But for what it's worth, the class was decently interesting, and not too hard even though it kept me busy. I'd recommend it for someone who wants to learn Python or for someone interested in cognition and how cognition concepts are applied with code.

This is not a Joyner class. This class was recorded when he was still a PhD student. KBAI lectures easily violate every single thing taught in HCI.

Cons

• Boring, repetitive, pointless lectures.
• Poor assignments and projects.
• You can hardcode through the assignments and RPM and call it 'Learning by Recording Cases'

Pros

• It is easy to get an A with minimal effort.
• Coding: Using Pillow or OpenCV (for image manipulation). Implementing BFS/DFS/A* algorithms.

Take this course if you are looking for low-effort easy A.

Worst class I have taken in OMSA (10 taken). Very time demanding, but not at all rigorous. Curriculum is extremely high-level and you will learn nothing that can actually be put into practice. Math for non-majors vibes. Nonetheless you will be drowning in busy work with weekly deliverables that always have a written report component and often have a code-based component as well.

TAs are also drowning having to grade this so they just quickly check off the rubric. If you do the same, you'll get 100 even if your quality of work is terrible. Tip: always overfit the visible autograder data as you will not be penalized. You can even hardcode it - just call it case-based reasoning.

There are homeworks, mini-projects, a major project with four milestone deliverables, exams, and a complicated engagement process all at once. None of these are well executed. Easy A it you do the assignments, but you will work hard and learn nothing. I advise strongly against taking this class.

I don't have a CS or engineering background and I found this class to be really easy and will finish with a high A. The programming assignments are nothing harder than a LC medium at best and the writing assignments, while a waste of time, provide free points so long as you follow the rubric.

I would note that the role of TAs in this course is not great. Here, the TAs are there for operational support, not to clarify questions about lecture content. This is pretty annoying since the lectures are very dated with poor audio and incorrect/incoherent captions. However, outside of name dropping a few lecture concepts here and there for the writing assignments, they aren't really needed since the exams are open book.

The class average on the exams were around an 80%. I think this is heavily skewed to the left due to some really bad performers. Do note, that some of the exam questions were very poorly worded. This led to a lot of non-native English speakers to struggle.

The content is interesting from a historical perspective and to add flavor and depth to some of the challenges still currently facing modern connectionist AI (e.g. commonsense reasoning, planning, logic). It seems unlikely that these techniques will prove the key to AGI, but you never know, and having more tools in one's toolset is always a good thing.

This semester had a clusterfuck around peer review, Dr. Goel was largely absent from participation, and the TA staff was okay at best.

You also need to follow the rubrics to the letter to get a good grade. But once you do that, the rest is up to you. This class epitomizes the concept of you get out what you put in.

You can sleep through the class and not apply a single concept from the lectures and brute force solve the mini-projects and use trivial heuristics to solve RPM and you can still get an A. Or you can spend some time digesting the lectures and reading the extra material to really feel the sense of where these topics can go.

I enjoyed the material a lot, so the class was a net positive for me.

I can't recommend this class. This is my 9th class and it's one of the worst. I took HCI from Joyner and it was amazing, I thought this would be similar and it's complete polar opposite.

I think you can see what this class use to be like and the elements are still there, but while the class has been updated, it hasn't culled away any of the content in 3+ years. It really is a constant barrage of assignments and things to do and its every single week. There is no break. Not even for Thanksgiving or for GT's fall break, and I know it's online but every Fall class I have taken before this gave some sort of breathing room.

This is the standard week for this class: 2-3 hour lecture videos. 3 peer review (which is graded by a computer and they swear it's not based on word count but it is), office hours, a coding assignment (some really small but most are very involved 300+ lines) and a 5-page paper explaining your code. And to top it off you have to participate in the discussion board to receive participation points.

Additionally, you will get nickel and dimed on points for the rubric that the TA won't follow. I seriously had multiple custom deductions on assignments which at that point why even use a rubric. You can submit a regrade request but it's not as easy as just requesting it, you have to submit a doctoral thesis with a 3 page paper explaining why you got points taken off (and they swear that the TAs are not subjective, but again, they are)

The project is also terrible. In theory it sounds like a good idea, but the project literally comes down to more graphic analysis then it does AI. For the most part, everyone has the same idea of how to do things, but everyone's process is different. The exemplary examples they have are chosen based on what how well put together the paper looks but it's just for looks. Looking at some of the examples for help doesn't work because there are so many errors on them that you could find yourself coding in circles.

TLDR: Skip this class unless you have a lot of free time on your hands and even then I would skip. Unless they cull away some of the fat and let the students breathe for a little bit this class is not worth it.

Grade: currently right on A/B border, might get a B.

Lectures: usually interesting, sometimes slow with the examples they walk through. The lectures would really benefit from some good code examples. Everything is presented very abstractly and translating what they present into actual usable code is a pretty huge challenge most of the time.

Mini projects: usually not too bad, I usually solved these with algorithms I didn't learn in the course, because they don't really present many algorithms, mostly just abstract framework.

Ravens Project: Very hard, I thought this was an interesting project to think through, but they don't give you any magical easy way to approach it in the lectures. I learned a lot about opencv/image processing. Get started early, I kept expecting the lectures to give me some a ha moment on how to approach these problems, but there is no easy solution (except farming gradescope which some students figured out how to do and shared it on the forum, pretty disappointed about this actually, they said they will fix this issue next semester). To get an A you are probably going to end up with a brute force agent with miles of if statements, unless you think up something clever, I ended up using a nearest neighbor approach which wasn't bad to code and worked well enough to get a 75/96.

Tests: Awful, open everything, but trying to find jargon specific to the class which you can't find in the text book and it might just be stated briefly in a lecture video. Best way to study I think is to just watch the lectures over and over and take good notes.

This class feels hard for the wrong reasons: -getting nitpicked on writing assignment points, -tests that don't really reflect actual problem solving skills, mostly just understanding jargon.

• ravens project is really hard and a fun challenge, but if some students figure out a gradescope farm you will be working your ass of while they get perfect scores for a hour or two of work (I didn't do this technique because it seemed like a complete waste of my time, not learning anything by doing this) -10% participation grade which is no cake walk to get, need to reliably do peer reviews by Tuesdays and comment on the forum a lot.

Lectures: Interesting concepts in classical AI. Well-presented materials.

Assignments: The assignments are similar in format to Harvard's CS50 AI course, but more challenging (No starter code is provided, but you have the freedom to choose any methods you prefer). Overall, they were interesting and well-connected to the lectures (if you choose to use the methods introduced in the lectures).

Final project: 70% of my time was spent on the final project because I really enjoyed the project. Most people spent much less time and still did well.

Grading: Depends on your luck. Different TAs have different expectations. If you are assigned to a TA who interprets the rubric differently, you will get points deducted. This was what made this course stressful to a lot of people (You will find your heart beating at 150bpm whenever they release the grades).

Overall, this is a well-designed course for someone new to classical AI. The course was enjoyable but I would recommend against taking the class because you can just watch the lecture videos online and do the assignments yourself. This would save you from unnecessary stress. (I give it a rating of 1 not because the quality was bad, but because I think there is really no need to enroll in the class.)

This is an easy class if you have already taken AI. I even think you probably don't need to take it at all if you are in the ML track. If you're looking for a side class accompanying some big classes, or just looking to graduate, I would recommend it. Otherwise, I'd say you'll learn nothing.

Some tips:

1. For the RPM project, you have 3 milestones to work towards before submitting the final report. For each milestone performance score, even you could get 100% grade by solving half of the test problems, I still strongly encourage you to get them all if possible. That will save you a lot of effort on the final stage.
2. Also for the RPM, make sure you come up with a way to effectively determine if two images are the same in the early milestones. Some images look the same, but in pixel-by-pixel they vary. This semester we have observed students using several ways, but none of them seem to work neatly. Most students are using a threshold.
3. For each writings, just refer to the rubric. The rubric is comprehensive and clear. And that's the best part of this class.

I agree with all the reviews posted so far from the Fall 2023 class. Although previous semesters had some positive and some negative reviews, I'm not surprised to see only negative reviews from this semester.

Pros: Assignments are easy to understand. Assignments can be worked on ahead of time. This course was really flexible in terms of scheduling. Work load is dispersed quite evenly throughout the semester (some of the final assignments are easier but at that point you should be working on your final project)

Cons: Grading can be quite subjective due to the nature of essays. The course videos appear related to the assignments, but they are related in superficial ways. Two snafus during the course lead to large disruptions in learning.

This class really needs the help of an involved professor. The lack of an involved professor made this course seem like a circus.

KBAI Review

TL;DR I am a Mech Eng and Software Eng and I learned absolutely nothing worth anything in this course. You basically spend the whole semester solving problems each week using whatever algorithm you want but call it an “Agent”. The material is outdated and I am shocked that this is allowed in the curriculum of a top 10 graduate CS program.

I’d recommend for - students who have no/little software background and want an easy start and can tolerate material that will likely be irrelavent if you want to do anything with AI as well as students who just want an easy A to get MS credentials. Or if you like structured learning environments and want to pay to practice solving problems that you could just do on your own.

I’d NOT recommend for - students who genuinely want to learn something relavent in the AI space and can’t tolerate wasting your time having to memorize and regurgitate outdated information so you can pass exams.

———DETAILED RATINGS----

Organization: Excellent The organization and responsiveness of the TAs is excellent. At no point in the course was I stressed out because I awas unclear about something or left wondering for days/weeks. When tweaks were made, they were clearly communicated. (Unfortunately, however, you only have to get a B in a course to be a TA so many of them are not particularly knowledgeable. They are basically just glorified grading tools. Don’t ask them a sophisticated question about….idk equivalent problem representations…. or they will break and take points away for non-conformity lmao)

Grading: Fair There was nothing unreasonable or unexpected grading-wise if you know how to read the rubric and check the boxes.

Workload: Way too much busy work I probably work a bit slower than average and with the exception of the first assignment or two everything I did for this class felt like torturous busy work. I think to give us a break whey made the last few assignments easier and maybe some people appreciated that but I felt it was just more mindless work…I’d have preferred an actual dropped assignment or something so I can focus on research for a week and forget about class work.

(Note - I can’t say anything about the workload compared to other OMSCS courses as this is my first one)

Material: Outdated and irrelevant in the AI space This was the main frustration for me in this course. I do not care (more than I have to for survival) about social credibilitly. I care about learning and my efforts and research helping the world. This classes wasted 4 months of my time (hyperbole acknowledged) solving weekly problems I don’t care about and watching 25 lectures that made me want to break my monitors. Whats hilarious is that if you used the methods we “learned” in class on the assignments, it would have made the assignments harder to do then just using simple heuristics and search algs.

A much more appropriate name for this course would be "Ancient AI", "Applied Algorithms", "Narrow AI", “Techniques for Dumb Robots”, ...¯_(ツ)_/¯

There are two intellectually distasteful things in this class for me 1) you have to learn the KBAI rebranding of existing concepts you already learn far more broadly and efficiently in other classes (ie. algorithms and data structures) and 2) the whole class is about various static algorithms that people have come up with in the past to solve AI problems that have produce terriblly narrow and non-extensible AI systems like those terrible phone robots that you have to get past to talk to real people about your problem. Sure, these systems work for some narrow applications but they are just static algorithms, not AI. Or like your Roomba….basically algorithms for dumb, narrow “AI".

There are enough actually challanging problems in the world that require understanding complex processes and so in a top tier program making students waste their time memorizing KBAI's rebranding of things they a) already know by another name or b) can learn in algorithms classes more efficiently is truly yuck.

In short, this class is a waste of brain space because its basically a rebranding of things you should already know if you take, math and other fundamental CS courses. If you want cognition, take a neuroscience or another course. Not this. Otherwise just math, algorithms, and a minimal degree of introspection regarding how your own brain works is all you need to know everything in this class.

One additional TIP because I like a level playing field for those who still decide to take this class after my glowing review: I (foolishly) completed my final project using IPR/DPR and a few little image processing techniques….but come to find out you can get 100% by just hardcoding all of the solutions and calling it "learning by recording cases” even though YOU are the one learning…not your socalled “agent". facepalm

———

Context: Background: Mech Eng and Software Eng Fall’23 - KBAI: A

This was a strange course. At first, I was excited for the challenge and learning something far different than anything else in OMSA. But I've had several issues with the course. It's a very "busy" course - frankly just too much.

Many of the assignments seem to provide little learning value for me. Many of the mini-projects were a form of space-searches. The RPM project also seems promising, and I'd like to have focused more on it, but I just got a little bit burnt-out on the amount of coursework. I think people typically will say "deal with it, you're getting a GaTech degree, etc..." but in reality, less is more. People only have so much bandwidth, and additional assignments are diminishing (if not negative) returns.

Outside of this, the course had a weird focus on catching cheaters. Much of the class was accused of cheating at one point on peer reviews (strangely). The teaching staff continued to double-down on this accusation, until they realized their errors, and retracted it. It was a very strange event overall.

Not sure I would recommend this course without significant modifications.

Avoid this class if possible. So MUCH tedious and useless work. I honestly have learned little about AI. My writing probably has improved, after having to write a journal for every single coding assignment and every milestone of the semester long project. The midterm was like a reading comprehension exam with confusing words.

There is no AI in this course. All the randomly selected puzzles are to be solved by 'so-called' AI agents. There are many Mini-projects, Homework, and MileStones. For each assignment, you have to write ~4-5 pages of report (weekly), and that is too much for a course that is not AI. Each assignment is different and shallow in terms of learning. The course lectures are outdated and not useful nowadays. The grading is done by AI mostly, and I did not see a single comment on my submissions. The course will take a lot of time, and you will gain almost zero knowledge about AI. It is good for high-school kids, but not for MSc students in CS! I forgot to say that participation is mandatory and you have to write peer-review for others' assignments. This feedback takes so much time, and they are useless. I would call it 'abusing' student to assess submissions and grading based on their feedback reports (may save costs!). 10% for participation is insane, and there is no fun there.

I would only recommend taking this as your first course in OMSCS. Taking this in my last semester makes the tedious projects and boring lectures mind-numbing. There are non-stop peer review assignments, an unnecessary amount of papers and generally uninteresting content. I've worked way harder in classes like ML, RL or DL and had a blast. AI4R and Game AI are similar in workload and far more interesting.

I'm not a fan of the peer feedback thing - I came here to write this. I hope my grade isn't dependant on the other students.

I wish lectures were more relevant to the assignments.

I'm not learning anything that will be used outside of this course (and if I will, I've already learned it in undergrad) - and I work in reasearch, I think it's a more specific Data Structures/Algorithms course.

This class is busy work and basic problem solving that is beng used for publications. It's underwater basket weaving - but you don't have goggles and assignments are due every week.

This was my second semester and I picked HCI in the first sem. I received an A in this course over the Summer of 2023.

Lecture Videos: The lecture videos were very abstract and left a room for a lot of thinking. I wish I could have the time during the summer to think about these abstract topics and apply these concepts in the Mini Projects and RPM Projects. But summer being very condensed it was not at all possible to do this. Most of my mini-projects were brute force approaches to solve the problem.

If you really want to apply these concepts, I would recommend a spring / fall semester as it is not possible in the Summer. I had to work 1-2 weeks ahead to keep up with the pace of the course.

Assignments: The course has 3 different types of assignment running parallel: The Mini Projects, the Homeworks and the RPM project. All the assignments were easy with well layed out rubrics which helps to answer the questions. I lost marks mostly in Homework 2 and 3 as a lot of room to answer was left upon us Students, the lectures did not help much here.

Exams: Exams were open book and easy. I have no complaints.

Overall: I came in with little to no Python knowledge and was easily able to pick up the materials and RPM project on the go with lots of Google Searches, etc. This course is an easy course, I learnt a lot about Knowledge Based AI but I am not happy that I could not apply the concepts I wanted to for the RPM projects. I look forward to do this during my downtime.

I wish they could condense the course in the Summer so we can apply the concepts learnt and not rush through the semester. I would recommend picking this during Fall/Spring as unlike other courses, no assignments/homeworks have been dropped.

It is my 1st course in OMSCS. And I regret deeply for didn't take the time to check out reviews here and watch some videos of this useless course before paying for it. My opinions:

1. videos are very useless, taking about concepts in a way like a daily conversation anyone can come up in school. In the end, teach students bascially nothing if not to take exams 1 & 2.
2. too much writing, feel like a course for MBA student. too much writing for homework, min-project, RPM. too time consuming.
3. Joyner's file format is a joke. Joyner is also a terribel teacher, trying to connect everything in the lecture to RPM, which makes zero sense.
4. serious questions questioning lecture videos/notes don't get answers from teaching team. I suppose they trap themselves with poorly prepared notes and videos.

Overall, just don't take this one unless you are required to do so.

Overall, I didn't learn as much as I wanted to in this course. It was alright, but not what I hoped for. Most projects could be brute forced, a lot of writing that seemed fairly pointless, Joyner Peer Feedback which was almost always useless forms of "good job" from fellow classmates. I will say I really appreciated everything being unlocked right away, I powered through lectures and assignments usually being 3-4 weeks ahead of schedule on work. Taking this class in the summer was pretty manageable. I got basically 100 on all mini projects and homeworks. 94/110 on Exam 1 and 92/110 on Exam 2 and 64/96 for the semester long final project with 50/50 on the final project writeup. This secured a solid A for me. If you know python, you are probably fine for the class, as you see even a meh score on the final project doesn't drag you down too much. Just stay up to date on the schedule (or work ahead). I wish there was slightly more challenging homework that really required application of AI rather than brute force algorithms that you pitch as AI in your reports. Literally with any approach you take, just follow the rubric and drop some keywords and you score full points. The Artificial Intelligence course in OMSCS is much harder but much more informative in terms of AI techniques and approaches. I expected more from this class, but oh well, it was an easy enough A for me.

I'm reviewing this class after receiving an "A" grade for the Summer 2023 term. Overall I had a positive experience with this course.

• This class could very easily be renamed "Applied Computer Vision" or "Applied Algorithms" considering the main RPM project, and mini-projects, respectively. The lectures do not go into any detail about OpenCV / Pillow / NumPy, so expect a very "hands-on" style deep-dive into these topics. The class also expects a decent familiarity with Python and about good programming principles in general.

• You probably shouldn't take this course during the summer. While it's possible to get an A, it will probably interfere with your life more than you want it to, and you will not have as much time to grasp the concepts in the lectures. Many of the assignments will feel rushed, and there are some weeks where both a homework / mini-project / exam is due the same week as as an RPM milestone; this is not ideal.

• Dr. Joyner, as usual, does an amazing job at administering the course, and allows students many opportunities for grade improvement. As is usual with his courses, expect the extra work of giving Peer Feedback every week. You will also find yourself looking on the EdStem forums a lot for this course, not only for the extra participation threads, but also for the assignments themselves (more on that later).

• The weakest point of this class is the lectures. Dr. Ashok Goel was the initial creator of the course, and Dr. Joyner is a co-host of the lectures. The lecture material does not really help while doing the assignments. Most of the material is very conceptual, and only a few of the lectures series have a real, technical description of an algorithm you should use on an assignment. I found this disappointing because the lectures became a chore every week. Instead of learning the material I would later apply in an assignment, it felt like I was learning the theory for the sake of learning the theory.

My recommendation to the course maintainers was for them to drop somewhere between 33 - 40% of the lecture videos, and with that remaining space, create new lecture videos which focus on implementation. The course covers so many topics that it does feel a bit overwhelming. Those videos in the 33 - 40% felt to me like topics which I only needed to know for the exams, and nothing else. It would be nice if the course could give some basic ideas / tutorials on computer vision fundamentals, and about how actually useful parts of the course material can be implemented in code.

This was a great course. the content is well organized and Dr. Joyner goes above and beyond on helping the students stay on track by sharing and posting on ed lessons the week announcements.

The concepts of the class are not hard to understand but do require you to pay attention and think about them. The interaction on the forum was really good and it really helps to figure out details on the projects.

There is a primary project that you build during the semester and 5 mini projects. All the material is available on day 1 so you can work ahead but there are weekly discussions on the topics assigned for the current week.

All of the projects can be built based on the material from the class, at least conceptually. in practice, you will need some knowledge of Python but nothing that you can't learn as you take the course.

The main project involves image processing but is very light and you could even go ahead without it. PIL and OpenCV will be your friends.

Overall, this is a good course. The coding assignments are fun and they’re not too tough if you have any Python experience. The exams are open note and all multiple-selection T/F type questions, so it’s not too stressful. The material is pretty basic. So, if this is an early course in the program, you’ll get eased into some material. But if it’s later course, you might be a little bored.

Biggest downside is that there’s a LOT of writing. Way too much writing. Writing about your code. Shorter writing prompts based on course material. Write about other student’s assignments. Just way too much writing. If you can’t pump out 5-8 pages of writing easily, you’re going to have a bad time.

This class was not very difficult. What I liked is that Dr. Joyner opened up all the assignments (even the midterm/final exam) at the beginning of the semester. This allows students to get a head start on assignments. I highly recommend to get a good 1 assignment ahead so you don't need to get stressed out.

There is a new assignment to do every week, so as long as you've got reasonable time management skills, you'll do fine.

In addition, get ALL the participation points you can, it can easily drag down your grade if you slack off on doing it.

David Joiner & Ashok Goel are great instructors for the class! The workload isn't too bad and there's no group projects (thank god, lol)

This is an amazing introductory course in the program that I wish I had taken as my first OMSCS course. Lectures are engaging and easy to understand. I paired this class with AIES and was easily able to get an A. Good mix of programming and writing.

I went into this course with zero "AI" experience and was surprised at how digestable and easily understandable everything was. The hardest portion of this class is the semester long project but I thought it was a really fun assignment.

I understand that writing the papers can be annoying, but they are actually really simple to write and easy As (as long as you follow the syllabus).

Dr. Joyner is so good at crafting these courses that are challenging and engaging while also fostering a sense of community through Ed Discussion. He actually cares whether you learn something from a course which I can't say about other courses I've taken in OMSCS (AIES, Global Entrepreneurship).

Don't be intimidated by the title! If I can do it, I promise you can

Pros:

• The programming assignments are somewhat challenging but extremely doable. The lectures give you everything you need to solve the projects. If you're stuck you can also check Ed Discussion where someone will definitely have posted a high-level description of the solution (this helped me so much!)

• Lectures are really engaging (as long as you haven't fallen behind and are binging them)

• Helpful student engagement and discussion in Ed Discussion

Cons:

• While I really enjoyed the semster long project, it kind of felt like there was the "one way" to do it with IPR/DPR. I know that's not true, but it really felt that way. I wish the lectures and the RPM problems were closer to each other.

Background: BS degree in civil engineering with ~2 years of development experience. KBAI was my second course in the program after HCI.

As mentioned in this course, there are basically four schools of AI: designing agents that (1) think optimally, (2) act optimally, (3) think like humans, or (4) act like humans. Knowledge-Based Artificial Intelligence is focused on (3) - how can we design AI agents that think like humans? With that in mind, this course has significant overlap with cognitive science and philosophy in an effort to understand how humans think. The lectures fly at a pretty high level, but I found them interesting and thought-provoking. Many folks mention the writing assignments as a drawback to this course, but it's to be expected in a Joyner course and I think it's perfectly reasonable for graduate-level coursework. A lot of the writing is focused on communicating your problem solving approach for homework assignments, which I consider to be an essential skill. It doesn't really matter how slick your algorithms are if you can't explain to anyone how they work.

Overall, I would recommend taking KBAI. I didn't have any prior experience with AI, so this was a nice introduction to the field. You'll definitely improve your Python skills, and you'll get your feet wet with rudimentary NLP and computer vision. I really enjoyed the semester-long RPM project because I got to learn more about NumPy and OpenCV.

With that said, I will agree with a prior comment about how KBAI feels like the "underwater basket weaving" of AI. Throughout the semester I couldn't quite get past the fact that it all felt too high level and simplistic. It was a very unique time to take this course because it happened smack in the middle of the ChatGPT explosion, and so I couldn't escape the feeling that the little logic problems presented in the assignments fall short of what "real AI" looks like. If you're looking to dive deep into algorithms, AI or ML might be a better choice.

I thoroughly enjoyed how KBAI combines writing and programming to create a well-informed understanding of AI at a high level. The course is structured around three major assignment types: Mini-Projects that leverage a particular AI strategy to solve programming problems in Python; written assignments that require analysis of AI topics and their application to real-world scenarios; and a semester-long project on using Python to engage in image transformation detection for solving Raven's Progressive Matrices. These assignments rotated weekly, which I felt was helpful in ensuring that I didn't get burnt out on a particular topic.

I found myself extremely overwhelmed by KBAI at the start of the course but eventually found a groove that made the workload manageable. The first Mini-Project was significantly more difficult for me to complete than any other assignment - I ended up with a 50-something on GradeScope and seriously contemplated withdrawing from the course only 2 or 3 weeks in. That said, once I better understood the requirements for each of the Mini-Projects and major project milestones, the work became almost trivial. Prior knowledge of Python is a major plus that will help you significantly throughout this course.

Many reviewers of this course have branded its lecture videos as a distraction from the actual course content, and generally I tend to agree. The lectures cover various problem-solving and knowledge topics at a high level but never provide details on how they could be implemented in a programming environment; I found some lectures to be more useful than others in terms of guiding me toward solutions. Knowledge of the lecture video content is only truly necessary for the written Homework assignments and the 2 exams.

The real secret to success in this course lies in community participation: go-getter students are very eager to share how they completed particular assignments or problems, allowing you to skip over the process of deliberating how to solve such problems and instead focus on implementation. I highly recommend lurking around Ed if you are stuck on something.

This course rewards those who are either: a) willing to dedicate significant hours to coming up with original solutions; or b) clever at making most of the resources offered to them and not obsessing over a perfect score. You can easily maintain a high grade by being deliberate about which assignments you're capable of getting a 100 on and letting these pad some of your lower-performing code submissions. I finished with a mid-90s final grade despite earning a 76/100 on my final project's performance.

Background: This is my first course in the OMSCS program. I have a BS in Computer Engineering and most of my programming experience is in C#/.NET. Took a 5-6 year break from school and currently work as a Software Developer professionally.

Overall: This course is a great introductory course for those who took a long break from undergrad or for those who want to get better at programming without taking a deep dive into highly complex topics. All the mini-projects and main project require you to use Python. From my personal experience, I took most of the time (for the first month) trying to understand how to set up Python and getting used to the differences in syntax compared to C#. Also, an initial lack of knowledge in NumPy, PIL, and OpenCV libraries, which are essential for the Final project, significantly increased development time for the Project Milestones. Although the Homeworks are basically long essays, I found them to be the least time consuming assignments of the course. I struggled in this course initially because a lot of the mini-projects required knowledge in different data structures, which I lacked, and had to play catch up to eventually get an A in the course. Mini-Project 2 and 3 were the most difficult assignments, based on my experience, so do not get discouraged if you score low on those.

Tips: • Use the course forum if you feel like you are struggling in the programming assignments. (The other students in the course are very helpful and give great advice) • Try to write additional peer feedbacks if you don't plan to be active in the forum. (I found I had to play catch up towards the end of the semester for my participation points) • Play around with the Python libraries that are used for the RPM project when you have free time. (It will help lower development time for your project) • Focus on the rubric for the assignments rather than longevity.

What I got out of the course: • I improved on my Python programming • Learned different ways to approach problems • Better understanding of the importance of planning • Better awareness of time requirements for a Graduate course

I would definitely recommend this course as an introductory course for the OMSCS program based on the overall good experience I had.

I really enjoyed this class, I love a Joyner class in general. Lecture material is interesting and the projects are all just the right amount of hard. You have to think and put in effort but none took more than maybe 5 hours for the week. There is a paper due with every project, but they take no time to write up and do not have to be anything crazy to get full points. Feel like I learned a lot and wasn't stressed over this class. I really looked forward to working on the course project (there are weeks set aside just to work on the overall project).

My first course in the OMSCS program, my background is BS in mechanical engineering and I have been a working professional for 8 years. My CS background is limited, and my work does not use python. With that being said, a great first course! I enjoyed the jumpstart into programming in python, and the class has a great discussion forum that is very lively. I had to get used to the flow, you typically have to write ~4 pages a week on homework, and have to work on creating a working code that is submitted to be graded. The beginning of the course did require a lot of work, the first coding project took me 15 hours to complete but only because my programming was rusty and needed to get up to speed. After that initial kick I got the hang of it, and really enjoyed how goofy some of the project was. I will say after each exam I felt like I didn't learn much about KBAI as some of the definitions were hard to pick up from the lessons. This course to me was more about the enjoyment I got from the homework, mini-projects, and final. Highly recommend to anyone who is in a similar boat and wants to dive in. Be warned, I did say 13 hours a week, but in the beginning I did have some 20-25 hour weeks, but towards the end I had some 4-5 hour weeks to balance it out. And yes I am a nerd and kept track of all my time, the actual average was 12.3 hours, but decided to round up to be on the safe side if someone is trying to plan out a semester workload.

I love this class! It's my first class and a great transition to the program. The projects are so much fun and really improve my coding skills. Students on the forum are always there to share ideas and tips and help each other. It's surprising how friendly the classroom environment is despite being online. The TAs who post on the forum are nice and professional, even when people post angry complaints.

The biggest complaint I've seen is the writing. There's writing every week. Personally, I don't think it's that bad since the required JDF format has big margins. Just make sure you hit the rubric and be clear with your thoughts.

Although the lectures focus more on the theories, which seems to be a masters-level thing, you can tell the professors put in a lot of thoughts to incorporate the materials in the assignments.

The RPM project is my favorite part of the class. It's so rewarding to see it come together by the end of the semester. The discussions on the forum on various approaches and testing make it feel like you are working as a team.

Everything's available at the start of the semester which is really nice for working ahead. Lastly, this class is very organized as it's one of Dr. Joyner's class. It just makes your life so much easier when everything's clear.

I just finished the final exam. It is open book/note/lecture/everything, but I realized how little I learned in this class.

Pros: Everything is released right away. All assignments are online, so you can get started whenever you want (barring those assignments changing for the next semester).

Professor is active in the forums but that should be the norm, not a pro.

Lots of graded assignments to cushion the blow if you do poorly on something.

Cons: Lectures are just high level and hand wavy. Examples that are abstract to the point of being absurd. "Suppose a robot wants to buy a cup of coffee". That stuff is just laughable. This content has nothing to do with the mini-projects or RPM. MPs can almost be solved with a search algorithm (BFS), other MPs you can just hack something together.

You can get 70% performance on RPM with affine model, DPR/IPR hacks and a look up table. No reason to go beyond that since you'll lose only a couple points on your final grade.

80% is the average success rate for students on RPM performance, rarely anyone gets 100%. So your grade is penalized by virtue of tackling the problem. 80% performance should be 100% of that part of the grade.

Some of the homework questions were tangential and not with-in the scope of the class. But it is easy busy work to pad your grade, so maybe a pro.

Cognitive Science is just pseudo-philosophy. Unfortunately, this class is just that with a sprinkling of AI and not the other way around. KBAI feels like the underwater basket weaving of AI. Maybe interesting to think about (if that is your thing) but completely useless in the real world.

My $0.02:

This class failed since it didn't teach me anything. That is what I learned on the final exam. Just topics that you watch a video for, take some notes and you'll probably forget a week or two after the semester is done. I wish this class showed some actual application to the real world. How does KBAI tie into Chat GPT? Does Boston Dynamics implement KBAI into their robots? Those kinds of things.

I recommend checking out the course page and see if this is something of interest before you register. It is an easy class to get a B and fulfill the Interactive Intelligence specialization requirement, but kind of a waste of time when you could be learning something useful or that would apply to your future career. I feel like I left AI having learned new skills but I leave KBAI wondering if I should have just taken ML instead.

Pros: -The videos of this class are absolutely the best. They're short and sweet but you'll also learn a lot from them, I felt they're changing the way I think. -Exams are reasonable, not too hard, not too difficult for someone watched all the lectures. Cons: Pretty much everything else :) -Every single week you have to write a journal, but the issue isn't in writing them as much as how they get graded. During the whole semester, so many students complained on ED that they didn't get graded fairly which is kind of true, your grade depends on how nice the TA is and they're all subjective so it's hard to argue against it. For some reason the professor didn't get engage in any of those threads. -TAs are there to review those journals, they're rarely engaged in anything would truly help the students. -The projects are silly and you don't need AI to solve them, they're all solvable through brute force, in fact, I haven't seen anyone else in the class solving them in a different way based on the journals which I had to review during the peer review process.

Long story short, take that class if you don't have other options, otherwise, watch the videos of the class on your own, they're available online for everyone.

I have to rant about KBAI to someone or I will lose my mind

I had to write a paper about what a sandwich is. How to play UNO using if-then statements. What free will is. What a joke is.

This class is a joke. Every homework is just busy work. Here's a great line from the prompt for home work 3:

As we all know, our appreciation for literature is only increased when we painstakingly tear it apart and analyze it like a chemical compound, so let’s do that here—and save pondering how to design an AI agent that can understand the sarcasm of that sentence for another day.

No! Professor, are you serious? No! I am in a Comp Sci program. I am a professional with a life. This isn't funny. This is you looking your student in the face and saying "im making you do unrelated busy work instead of what you came here for, and I'm going to laugh at you about it." This is every homework.

I hate this class. It makes the whole OMSCS program feel like a bad joke of an online school. I literally lost points today because a TA didn't like how I defined what a hotdog is. Are you kidding me? In a masters level grad program about computer science?

The first thing I ever programmed on my own was an if-then stupid little program to play blackjack. Turns out that was actually masters level work because Joyner was happy to assign an UNO if-then stupid little program as homework (and then call it an "AI agent" lol). This class is a literal insult to the intelligence of its students.

But at least we get cool AI based homeworks right?

NO. NO, YOU REALLY DONT.

For every assignment you can just brute force your way to perfect score, and what's more, that's usually the best way to do it. The lectures are full of stuff about AI that only gets applied when students drop buzzwords from lectures to try to satisfy TAs who want to see us "apply what we learned". In other words, replacing the word "class" with "frame" and "variable" with "slot". Boom, you can do AI now.

The TAs for this class have no business deciding if I defined free will sufficiently at a masters level. I have no business trying to do so at a masters level. I'm not here for philosophy, I super don't care what Joyner or his TAs feel about free will. Like, at all. And if they care what I think then they're even more bonkers than I thought. What even is this class?

I don't know. I'm never taking another Joyner class again.

This was my first course in the program. I feel comfortable writing this review six weeks before the end of the semester as I have fully explored all the course content, submitted all my code, and submitted almost all of written work. I currently have a 98 in the course and fully expect to maintain an ‘A’. This is a relatively easy course if you have a background in CS, but make no mistake, it is time-consuming. I was only able to work ahead because I have significantly more time than the average student to put toward schoolwork.

PROS: -- The content of the course is interesting. It feels like a cross between an intro to AI and an intro to cognitive science. I learned a lot from the different concepts covered in the lectures, from semantic networks, to incremental concept learning, to analogical reasoning. If you’re interested in the nature of intelligence and minds/possible minds, you’ll probably find this stuff fascinating. -- The lectures are well produced and easy to consume. I think this is the case with most courses in the program, but like I said, this is my first course, so I really appreciated it. -- Because the course is popular and has such a high student capacity, Ed was always very active. Every question asked was answered quickly and satisfactorily by a fellow student or a TA. Communicating with others on Ed was actually one of my favorite parts of the course. I learned a lot just from these interactions. -- David Joyner. I just love the guy. -- The programming was pretty fun. If you’re looking for something on the easier side, are just getting started in the program, or don’t have much background in CS, the projects are a good way to get some exercise with python and maybe a little numpy. -- The exams are fair and very well put together. No gotchas, no ambiguity (that I saw), and the difficult level was appropriate for an open-note, open-internet format–challenging but not too hard. That said, I think I would have preferred a somewhat easier, closed-note exam format. I personally learn more that way.

CONS: -- I’m not sure how directly useful the course content is in industry. This isn’t a euphemism; I’m honestly not sure. Judging from what others have said (I’m not in tech professionally yet), these concepts probably fall on the lower end of practicality. However, I still think they’re useful at a high level when considering what the properties of a truly intelligent agent are. -- The programming assignments, including the central Raven’s Progressive Matrices project, don’t require you to use the course material and thus end up not complementing the course the way they should. To me, this is the biggest flaw of the class. Your program results are auto-graded, so as long as your output gets you across the finish line, whatever got you there doesn’t matter. Most people in my experience wised up quickly to easy visual heuristics (DPR/IPR and others) they could get away with to solve RPM problems. For the mini-projects, there were a handful of people who worked ahead very quickly, figured out short cuts to solving them all, and then described the easiest solutions on Ed. Others will rightly point out that when it comes to learning you get out what you put in, but when you’re assigned 4-8 pages to write every single week, it’s hard to not take the easy path when it’s sitting right there in front of you. Speaking of which… -- There’s just too much writing. Some of the writing is fun (I had a blast writing about consciousness for homework 3), but the RPM journals get tedious. There are four milestone journals PLUS the big writeup for the final project. This is in addition to writeups for each of the five mini-projects, the three (long) homeworks, AND the peer feedback you have two write each week. I much rather would have spent more time coding.

Overall, I’m right on the fence with recommending or not recommending this course. Would I take it again? In its current form, I don’t think so. It’s just way too easy to not learn very much, and I wish there were more mechanisms in place to hold students’ feet to the fire. However, if you’ve got time to put the work in and feel you won’t succumb to the temptation of taking the easy route on assignments, I can imagine this being a rewarding experience.

Very well taught class. It was my first in the OMSCS and I recommend it.

KBAI was one of the best courses I've ever taken, and I highly recommend it for anyone who REALLY wants to learn how to think differently about complex problems (both in AI but also in a general technical atmosphere). Let me list the pros and cons below.

Pros: • You learn a LOT. From the moment you enter the class to the day you leave, you are constantly learning about the parallels in how humans think and how we can mimic AI machines to think like us! Very fascinating stuff. • The course project is for sure a shiny badge for your resume. The semester-long Raven's Progressive Matrices Agent that you build will definitely teach you a lot about the course subjects, but it'll also look really good on your professional profiles or resume! Even if your Agent isn't in the top percentile, the learning you do and all the code you write for it over the semester is for sure an achievement regardless. • The Mini-Projects allow you to improve your coding. I knew programming decently well coming into this class, but after completing the coding projects needed, my python programming skills have improved drastically! • The sense of community on Ed is like nothing else. Seriously, the Ed forum was a lifesaver for this class. The professor and TA pretty much always foster a community of learning and making mistakes and helping eachother out. I can't recall a single time where they took down a post where students were helping eachother think about problem solving techniques and offering advice. You could tell that most of the teaching staff wanted students to succeed and help one another. • In my personal opinion, I think it's extremely important to have good written communication skills as a developer, and with all the reports you write in this course it definitely gives you the opportunity to work on and hone those skills. Writing reports for every single project can seem annoying at times, but I assure you'll come out a better writer! • You can tell the Professor loves this course and is dedicated to student success. Dr. Joyner is amazing at what he does, and it's clear throughout every point in this class. From the weekly assignment reminders, to the fun engaging lectures, and the occasional responses on Ed posts, I liked knowing I was in a class where I felt appreciated and valued as a student. • You WILL get out from this course what you put IN. If you make a decent effort to learn the concepts, complete the course project, and all the other assignments, you will come out of this class feeling like a different person. You will be equipped with a huge toolbelt of knowledge to go and tackle problems you never thought you could before. I came in knowing nothing about computer vision, and now I'm able to do technical analysis on images and process pixel counts and use those to make assumptions about what an image is showing me... very cool stuff! • You have the ability to work ahead! The thing I loved the most about this course was having the entire class given to you day one. You have a syllabus and deadlines for assignments, but you as a Student are able to pick how far ahead you want to work. This saved me so many times while working fulltime, because there were weeks where work or sickness caught hold of me but I had worked 2-3 weeks ahead and so I was seldom worried about my assignments. If you can, I HIGHLY implore you to get ahead wherever you can in this class. Some students worked so far ahead they got the entire month of December off and to themselves. So keep that in mind when taking this class.

Cons: • Lecture Exercises are somewhat outdated (it can get kind of annoying because by the end of the semester I wasn't even actively doing them as I knew most of the results would be wrong anyways). Just focus on the lectures themselves. • Not necessarily a con, but rather a warning. You REALLY need to be a competent programmer. I don't recommend this class for anyone just learning how to code. A lot of the projects in this class require intensive programming. • Grading isn't very standardized. I only encountered this issue towards the very end of the course, but despite my reports being extremely similar in structure and format from week-to-week, some TA's may take that as a 100, and other TA's may take that as a 75. • Exams are fair, but my only hesitance with them is the way the questions are worded. I don't know how non-native english speakers even take them, as being one myself made it extremely difficult to understand the question wording a lot of the time. Hopefully they improve that in the future but for now, question wording can get really convoluted and you'll spend 2-3 minutes just deciphering what the question is asking. (Exam times are also on the shorter side so beware of that). • Peer Reviews did not help. In this class you're required to submit peer reviews for others' reports as part of participation. For one, most of the peer reviews I got didn't help me at all, but also in my cohort it actually caused issues in regards to retaliation. Students who took critical feedback would then go and "reputation strike" other students, which I think at the end caused a lot of issues that could be avoided outright if reviews are abolished or at least give reviewers option to remain anonymous.

My first course in the program. It's an excellent "re-entry" into school (20 years past since undergraduate). I loved the concepts of thinking about problem solving and the direct links between human cognition and the algorithms implemented by computer "AI agents". It really expanded how I think about computer program design and the parallels to human thinking/problem solving. The programming itself wasn't too difficult. I improved my python skills immensely - but YMMV. My biggest complaint was the writing components - the weekly papers covering your program did become a bit of a chore. The class message forum was lively, helpful and educational.

I review each aspect of this class in detail here, in this 5 min video https://youtu.be/mCsmaXxZL60 Cheers!

Before I begin my review, I should let you know that I am not in the OMSCS program. I am in the C-track (Computational Data Analytics) for the OMSA program and took this course because C-track students have to take 2 CS courses for the program. This course got one of the better reviews of the ten CS course options listed for the C-track electives, so I decided to take this course. I'm disclosing this to let you know that I do not come from a pure CS background like most people that take this class, just to give you a heads-up.

Now for the review. To put it simply, this class just has way too much going on. I knew going into this class that there would be a decent amount of writing because a lot of the reviews on here mentioned it. But what most of those reviews don't mention is EXACTLY how much writing there is, which is what I am going to tell you right now so that you know. Don't say I didn't warn you.

Excluding the 2 exams, there are 13 assignments in total for this course, with all of them requiring a write-up. Here are the page total requirements for the assignments:

• 5 papers for a semester-long coding project: 5 pages per paper for the first 4, and then up to 10 pages for the 5th one.
• 5 papers for 5 different coding mini-projects: Up to 4 pages per paper
• 3 papers for 3 different theory-based homework assignments based on lecture material: Up to 6 pages per paper (4 pages recommended)

In total, I did roughly 65 pages of paper writing for this course. I should note that not every page was all text. You are asked on some papers to include figures/diagrams, which can take up at least half of a page a lot of the time. But there was definitely more text than figures in my papers.

A paper is due every week, first thing Monday morning. And THEN you have to give peer feedback to 3 different students' papers that are randomly assigned to you for each of the 13 assignments. And the peer feedbacks that you submit are graded. If a student's paper meets all of the rubric's expectations and is really good, you can't simply write "This was a great submission and it met all of the expectations. Great job!" You will get a bad grade for that. You have to go into great detail and write in paragraphs why that student's submission was really good in order to get a good grade on your feedback, which I thought was redundant busy-work.

All of this writing makes it incredibly easy to fall behind on the lecture videos, which are fairly interesting but they're only helpful for the exams in my opinion. I thought there was a pretty big disconnect between the lecture material and the coding assignments for this course. They were incredibly high-level "whiteboard" explanations that didn't really give any good algorithm breakdowns or coding whatsoever. I literally didn't use any of the concepts covered in the course for the semester-long project because the project was too big and complex for any of these concepts to be applicable. And this seemed to be the class consensus based on discussions in the class forum. I would encourage you to pay attention to the discussions in the class forum because students share methods that they implemented in their mini-projects and semester-long project that really helped them out, and I found that to be pretty useful.

There's also no starter code for any of the coding assignments in this class - I didn't find this to be a big deal seeing as it is a grad-level CS course, but I figured I would just let you know this ahead of time as well.

The one good thing about this class is that because there are so many assignments in the course, everything is weighted pretty evenly and lightly. So doing really poorly on one assignment is not gonna affect your grade that much. I got roughly 60% on the semester-long project for this course and I'm either going to barely get an A or easily get a B in the course.

In terms of coding, I would say it is on the easier side for OMSCS students (it's all in Python, by the way). But my final advice to you regarding this course is this: if you are not required to take this course for your program, you need to SERIOUSLY consider whether you are willing to do a ton of excessive writing - between assignment write-ups, peer feedback, and coding - for a 4-month period. Because that's what you're gonna spend the vast majority of time doing in this course.

Knowledge-Based AI was my second/third course only after AI. I would like to say what I really loved about KBAI. The course material was easy to understand and digest. The projects were pretty great and while we had to think about them, they weren't that difficult to solve or submit. The TAs were really generous and helped out a lot. For an online student, the best tool that we used was Ed Discussions and Peer Feedback, as these were a semblance of actually interacting with the class. The students were extremely helpful and may be due to participation points, were really supportive throughout.

There was not much I didn't like, but I would definitely say that this was a time-consuming class. Weekly Projects, Reports, and Submissions without any breaks were extremely exhausting. Even if I missed one week, I would lose a grade. Not saying that a Masters's Course should be any less rigorous but this is something the student should expect from this class.

The only reason for bumping difficulty from 3 to 4 is to keep it aligned with the strict time-bound activities we need to perform. Overall I had the most fun in this class and would recommend students to take this class.

I'm taking this as a first OMSCS course, with 2 STEM degrees, some undergraduate CS coursework, and a functional (but rusty) grasp of python.

Noting that folks of widely ranging backgrounds take this course, I'd like to address some common criticisms.

1. There is too much writing. There is an assignment due basically every Sunday midnight (except exam weeks). Nearly every assignment is 50% Gradescope performance and 50% write up. If you bomb an assignment, it's not the end of the world.

The write-ups are really not bad, and very manageable for graduate level coursework. Maybe 3-4 hrs spread over the week.

• Use a latex template (Overleaf is very easy) from the beginning.
• Stick to the posted rubric.
• Make plots / tables as you do the projects. You'll find yourself hitting the page limit in basically every write-up.
• Don't wait till Sunday to write it or you'll hate every moment.
• The peer reviews on your write up are actually quite motivating.

2. They don't teach you how to program. Yeah, not really. This isn't a programming class, it's a graduate-level classical AI course. They cover a range of topics on a high level, then toss you interesting projects to get your hands dirty. The discussion forums offer plenty of help if you're struggling. (there is usually an easy way to complete a project, but it's fun to try some exotic stuff out).

3. This is all outdated anyway. I never understand this take. A survey of classical AI techniques is going to broaden your understanding of the field and give you a wider base of approaches to apply to future problems.

There isn't a clear 1:1 relation from classical AI to modern data-driven approaches. But if you really can't fathom how to use anything but deep learning to solve problems, you're part of the problem.

To wrap up: If you're here to learn and want a good class to sink your teeth into (that isn't going to absolutely kill you); you're in the right place.

If you're here to get in and get out, well, its not crazy hard and you can get by with just skimming the lectures. You might actually enjoy it, so be careful of that.

The class felt a little front loaded. It's progression and organization are great, but they jump right into it with the first project. If you're not comfortable programming you'll have to learn quickly.

You'll have to be pragmatic with your time to get projects finished. Get a basic, working version submitted early before scaling it up.

I absolutely recommend this class. But don't take it if:

• You don't have at least a functional knowledge of python or object oriented programming. Learning this right before the class is going to be a hard sell unless you're comfortable in similar languages.

• You want a theory class. This is basically all projects and not much math.

Just took the first exam of the semester. I'm taking this class with a background in computer science, while also balancing a full-time job and a supportive family. It's my first class in the program too.

Let's start with the negatives of the class. First, speaking as a writer, there is a LOT of writing. Heed this warning. You will be programming a lot, AND writing a lot, AND reviewing people's writing a lot. This is a class that demands 50% of your energy for writing + reading and 50% for programming. If you're okay with this, then that's awesome. If not, then you should consider a class that doesn't require you to write so extensively. I think I've written about 30 pages worth of stuff by now, and it's been only a month.

The second thing, which is more serious--there have been a LOT of criticisms regarding how, despite a large number of our assignments requiring us to program extensively, there are very little to no programmatic algorithms introduced to us in the class. Which is a little awkward, considering many people recommend KBAI as a first class for people--in this sense, it's probably better as a second-semester class.

There's sooo many people who say "This is grad school. Don't expect to be spoonfed anything." but this criticism isn't coming from people who want to be spoonfed. It's coming from people who want, literally, perhaps a page from Russel & Norvig or a link to some reference for generic pseudocode and programmatic explanations. There are absolutely NO guidelines at all on how to program some of the algorithms presented in the course! I would be incredibly surprised if you could prove me wrong on this!

I personally have had to do the added research of perusing Russell and Norvig, as well as the optional readings from our Winston textbook and studying relevant data structures that may outline how to approach the assignment, in order to get an A.

If you take this, PLEASE be aware that you will not receive any help from the lectures themselves on how to approach programming assignments, much less learning Python! I use Python at my job on the regular, and I cannot imagine taking this course if you've never used Python!

As for the positives, there are many. Perhaps as a result of writing all of these reports, if you take this as a first class into the program, you will have set up a good process + environment for writing papers in the future. All of the assignments are given to you at the start of the semester, so you can plan ahead as needed. TAs are incredibly responsive; exams are fair. Programming exercises, if you know how to program beforehand at least, illuminate the concepts in the lecture very well. They are also very flexible exercises--you aren't being shoehorned into a very specific technique or method in order to get 100%.

I just don't know if these positives can outweigh this HUGE, GLARING negative point. I think it wouldn't be so serious if the course instructors themselves emphasized that it would be very, very important to have prior understanding of Python and a basic grasp of data structures, or suggest as optional reading some more technical papers that outline a programmatic approach to some of the algorithms from lecture, or at the very least a few chapters from the AI textbook by Russell and Norvig.

I struggled to get a grasp for the class at the beginning of the semester because of how lost I felt for our first programming assignment, but I was able to figure things out by reading a lot more and doing my own research, so I'm much more comfortable now. But there are still a lot of students I've seen in the discussion forums and in our peer reviews who are struggling with completing the programming exercises because they are very genuinely lost, and it's hard to blame them.

this was my first class in the program and what a fantastic class to kick things off with. Very interesting and extremely well structured and enjoyable. Dr. Joyner remains my favorite humans in the program and I highly recommend the class to anyone looking to get an understanding of AI and practical coding. Thank you Dr. Joyner for making my life easier and doing a good job structuring your classes so well

Nightmare.

1. Like said in the other reviews, this course teaches a very out-of-date concept. I don't think anyone is really using this techniques in the industry.
2. Maybe because of the lack of real knowledge in this course, it has lots of tedious homework. For example, in Homework 1 Question 2, it asks to read some European Regulations, and how it applies to general AI, etc. which is completely irrelevant to the course. (More like an ethical course topic)
3. Again, maybe because of the boredom of this course, it asks to complete weekly reports and so-called peer feedback.

Overall, this is a very tedious course teaching useless content. It has a public website (Google it). I highly recommend you read the website before taking this course.

Positives-

1. Well run, organised
2. Was my first course, so good warm up to the rest of the degree
3. Everything is thrown open on day one, so you can plan the course as per your pace
4. Good projects to pick up python programming fluency
5. You can score well, possibly an A, if you just follow the instructions. Major chunk of the marks is reports for the projects which are easily to do if you just follow the grid.

Negatives-

1. Course is not relevant to modern day AI, or something which will help you at work (or secure a new job)
2. Re-stressing again on the above negative, very theoretical and intuitive topics discussed in the course, not directly applicable in your programming
3. Although the projects are good at building fluency and logic, they are general programming challenges and independent of the course lectures to a certain extent. You can use common sense, any algorithm, or force the course topics into the projects but this is reinforces my above contention that the topics are not relevant to modern programming
4. Every week or so a paper is due, can find it a bit too much
5. Exams tested less of conceptual learning and were more focussed on command over English language to decipher the 'tricky worded' questions

This course was great for learning about topics used in KBAI, but you do not have to code most of the topics and can get away with doing simple solutions for the projects. If you are someone who can only learn topics by coding them, this class might not help you to learn. The test cases for the projects are fairly simple so your code can be inefficient and use basic search instead of the topics taught in the class. The workload is a lot compared to other classes. There is often a coding assignment, report about the coding assignment, homework essays, and lectures to complete during the week. There are also exams, which are thankfully open notes, and a semester-long project that will require a lot of time to complete. I would say this class is not difficult but tedious and an unnecessary amount of work to learn the topics. Overall, I would recommend taking this class if it satisfies a requirement but finding an easier class if you do not have a lot of time during the week for assignments.

This course has extensive load. I have to spent nearly 20 hours the first half just to keep up with the schedule. The mini-projects can be tough and has nothing to do with what is taught in lecture. The workload is heavy. The 3 homework is also not very relevant and confusing rubric. The good side is the grading is reasonable. As long as you write something that make sense, you are expected to get full score. The Final RPM seems a duplicate of previous 4 RPM, but has a substantial weight of 15%, equal to two exams. It is very helpful to read through previous reviewers to have some expectation. I had thought this is a easy course and didn't start work on projects until late of wk2, and have felt some pressure to keep up.I personally think the 3 homework is simply waste of time or weighted too much. 5% each, and I usually have to spend a whole week to finish writing. Also, reviewing 6 papers from your peers every week is also not making much sense. I felt less motivated to prepare for exam 2. Did some calculation and knowing that I will still getting A even if I score 20 for the exam.

Pros-

1. Interactive course, keeps you engaged
2. Very well structured and organised, Dr Joyner is an expert in online education!
3. Great community support, you will not have to struggle alone
4. Programming projects are interesting (if you like Python programming)
5. Thought process and logic of KBAI would help you refine your programming logic and style
6. You can pace the course as per your convenience, everything is thrown open in the very beginning.

Cons-

1. Not a cakewalk or easy course to get an A
2. Atleast one report is due every week
3. You have to spend substantial hours for report writing, peer reviews and programming
4. Programming projects are not beginner level and will be steep if you are new to programming or not fluent in algorithms.
5. KBAI school of AI is a bit outdated and doesnt see high usage/deployment in modern day programming.

Summary- This is not an easy A course as provided by some reviewers, first 1-2 months of the course can be overwhelming and you must be ready to dedicate time and efforts to overcome that. After this the course becomes relatively easier to handle.

However course is well organised and well designed and if you are willing to give your time, be active in the forums, you will be able to well. Unlike some courses, efforts will ensure you a high performance in the course and Dr Joyner expertise in online education is amply reflected in the course.

Background: Chemical Engineering w/minimal python experience

Workload: as a non-CS background, this was a good first coding class in the OMSCS program. The mini-projects are challenging, but my coding has improved immensely. Like I look at my first project and can not believe how far I've come understanding and utilizing classes for object oriented programming. The caveat is that I spent a lot of time learning fundamentals which upped my hours/week. If you have background in this, or just want to get the projects done, you can definitely spend less time than me per week. For reference, the first mini-project took me 20+ hours while others in the forums mentioned it took them 5 hours. Also note that the class seems pretty front loaded, or at least it was for me. The tail end of the course I spent WAY less hours per week, but that could also be due to the fact that I took time in the beginning to learn fundamentals.

Grading: The forums are fairly open for discussion and support, minus actual code sharing, which is great for learning and expanding your approaches. The head TA, Kia, was amazing. Quick responses and very helpful. They just started using a rubric for grading, so there is no ambiguity in what you will be graded on. Note that each assignment has a journal aspect. This is great if you are weak at coding as each assignment grade is only 50% code. It is not great if English is your second language/you hate writing. Overall, I found grading fair. If you put in decent effort, you can make it out of this class with an A or B.

Material: seriously, these are the most interesting lectures I have ever watched. By far the most interesting class I have ever taken. I can not recommend this course enough. I wasn't entirely sure what the class was about when I signed up, but imagine breaking human cognition down to the most finite, subconscious elements. For example, you need to paint a ceiling and the ladder. We instantly know you must paint the ceiling first, otherwise the ladder will be wet and you can't climb it. But how do our brains make that decision? How do we break that down to a method to code into an intelligent agent? Another example: you need a cup from the kitchen, but all the cups are dirty. How do you improvise and know that bowl might be used instead? In fact, how do you even know that a yellow cup and a cup with a handle are both examples of cups? How do we learn and how do we correct mistakes in our learning? A lot of ML/AI requires thousands of data points to train on, but as humans, we often don't have that as we learn, so how do we proceed through the world with limited knowledge. Seriously, this stuff has me agreeing with Musk on simulation theory or with Sam Harris on the fact that free will is an illusion.

Prep: If you aren't familiar with object-oriented programming, I highly recommend watching the section here on breadth-first search (https://cs50.harvard.edu/ai/2020/weeks/0/). The class never mentions it, and I was lucky to see it in the forum. My biggest issue with the class is not introducing this as a more concrete coding application rather than the theoretical stuff they propose.

This class' difficulty is based on how you approach the course. If you'd like to actually apply what is taught in the lectures, then the projects are a bit involved. But 4 out of the 5 mini-projects can easily be "cheesed" with really simple solutions, because the test cases on GradeScope are so simple. RPM is a bit involved in the beginning getting set up. As the project progresses and you have to code more, you can observe other classmate's strategies through Peer Feedback and get ideas for implementations. A lot of people complain about having to learn Pillow/OpenCV, but if you are used to reading documentation and experimenting to learn an API, it's really not that bad.

The way to make this course as easy as possible is to get high A's on all the assignments so that a low final project performance score is fine. My RPM performance scored a 55/100, but I was still easily able to get an A.

TA staff is very engaged and helpful, and students are very collaborative on the forum, which is really nice. Nothing is redacted or censored. The first half of the course content is well-defined and concrete. The second half becomes a bit more nebulous, but is somewhat interesting.

The worst part of this course is really the exams. They are incredibly vague and wordy for no reason. I have no idea how a non-native speaker would be able to do well on these. Even with them being open-book, open-internet, deciphering what is being said is quite difficult. You also never get to see what was scored as correct/incorrect after grades are released, so it is a bit of a mystery what a correct answer usually looks like. The second exam was a bit more vague than the first exam.

Also, Peer Feedback requirements are excessive. This course would really benefit if they halved the required feedback amount.

Overall this is the ideal first OMSCS course if you are new to CS. The programming is straightforward, the class is very well-run, TAs are awesome, and all assignments are released at the beginning of the semester with no revisions to instructions.

Really interesting course that teachings you valuable building blocks. Good amount of paper writing. Lectures videos are the best of any course I've taken. Projects are good, just make sure you watch the relevant lessons first. Work on the PRM project early if possible.

Amazing class, highly recommend. It was super exciting learning about how humans may approach and solve problems, and then translating it over to computers. They cover a wide range of topics which combine cognitive science and computer science. The videos are broken down into manageable chunks and have many helpful exercises with follow-up explanations. TAs and professor are very active on the forum and responsive. Assignments and final project draw from course lectures. There are opportunities to earn extra participation, capped at 100% for the category. No curve, no extra credit. Full course calendar is available from the beginning of class, but there isn't much room to work ahead.

The first half of the class balances between coding and written assignments, and has more cohesive content. They go over knowledge representation structures and different problem solving techniques, and keep referencing them in later lectures and incorporating them into all of the written assignments so you really get a solid foundation.

The second half of the class branches out into many different topics, and with all of the coding assignments bunched together in the middle of the term, feels a little less cohesive. You do something different every week and start to forget what you learned from previous weeks. They do reference previous material, but not as much, so it doesn't stick as well as material from the first half of the course. That being said, I still learned a lot and highly recommend this class.

Background:

• undergrad CS background
• work full time
• number of previous classes: 0
• other classes this semester: 0

Breakdown of average time commitment per week:

• 2 lessons. 1 hour to watch videos (add 1 or 2 hours for understanding the material)
• 1 assignment, either coding + report or written homework. 20 hours
• 3 required peer reviews. 1 hour
• participation, easiest way to earn with confidence on number of points is with 3 extra peer reviews. 1 hour

This is my first OMS course. I can safely say that this is a great course to take as an introduction to the program as a whole and is a great way to get a solid grade for your first foundational course requirement. Though, if you do not have CS experience (university or a minor) or are working full-time then this course may be more difficult. The lectures are digestible and are broken up by mini quizzes that test your understanding of the material throughout. Compared to my previous institution’s online lectures, these were like a Hollywood produced movies. Dr. Ashok and Dr. Joyner are great lecturers too.

There are only 2 exams in this course, both of which are open note and open book. My only critique about these is that the questions are very obtuse and require sometimes very creative applications of what is learned in the lecture.

Aside from that, most of the assignments you’ll be graded on will be Homework, mini-projects, participation, and the Raven’s Progressive Matrices.

Homework assignments are essays that will sometimes ask you to answer a philosophical question about cognition and how said concept can be described to a computer. These assignments took the most time to complete since it was recommended to write up to 4-6 pages on these topics but they were also one of the easiest.

Mini-projects are the second highlight of this course. There are 5 of them all of which are based on the lectures. I would recommend not tackling these in the way the lecture explicitly tells you to tackle them. It’s better to try to solve them as you would naturally, and you’ll always end up solving it in a way the lecture expects you. In other words, don’t think too hard about how to approach them.

Participation is based on how active you are on Ed (discussion board for asking questions and what not), giving peer review feedback on assignments, submitting example questions for exams the list goes on. If you want to max out your participation early on, I recommend doing a lot of peer review feedback. I wouldn’t recommend stopping though because some peers may have some insight that can help you for Raven’s Progressive Matrices.

Raven’s Progressive Matrices is the main highlight of this course. You’re building a program that can pass a visual IQ exam. This project is broken up into 5 parts and each part tests a specific section of the IQ exam. Ultimately, if you want to do well on these assignments I recommend looking into Pillow, OpenCV, and image analysis functions like dark pixel ratios.

One more thing I forgot to add. Mini-projects and Raven's Progressive Matrices Milestones requires a report of what was accomplished and what you learned that's usually 4-6 pages long. So if you are not a fan of writing 800-1000 words a week then this course may not be for you. On that note, some of the lecture topics aren't applicable for the mini-projects or Raven's Progressive Matrices even though they are advertised as so. The concepts only work when applied in an abstract way, but sometimes when programming your A.I. you may accidentally programming it the way the lectures says it should be done if you don't think about it too hard.

Grades take a long time to be published with many taking 3.5 weeks or more.

In conclusion, I highly recommend this course to those first starting off in the OMS program. It gets you acclimated to discussion boards and graduate level expectations without the fear of not fulfilling the foundation course requirement of a B or higher.

I took this class as my first class in the program because the reviews here said that it was a good intro class to the program and with fairly low workload. That was not my experience at all. I am a CS major and work as a software engineer and even though the coding assignments were not a problem per se (other than learning some new libraries), the amount of writing in this class is insane. There are two homework where I spent at least 12 hours researching each. It was a subject not even related to the lectures, it was more related to ethical AI which I didn't think this class was about. I don't think the lectures actually help you solve the final project, so you ave to put it a lot of extra time to come up with a solution. I passed with an A, but I put in a lot of time. If you don't like writing a lot of papers and doing mandatory peer reviews, stay away of the class. I will say I liked the class though. I do think it was interesting but it was not what I was expecting based on the reviews here. The good side of the class is that it extremely well organized and you can start doing the assignments as soon as you want, which can put some people in advantage to work on the final project if they have the time.

This class was harder than I expected due to the fact that the semester I took it was the first semester they added mini projects. The mini projects weren't all that bad overall, but some of them made me have to refresh myself on AI algorithms and the likes. For one of them though, I was able to come up with a quick 11 line solution so I'd say definitely don't overthink any of these, brute forcing is the way to go. The RPM semester-long project was definitely harder but the best things you can do are implementing basic transformations, boolean operations (OR, AND, etc), and Dark Pixel Ratio (DPR) and just taking it one milestone at a time. I was able to get around 70% accuracy with these alone. It was pretty satisfying knowing I had created an agent that could solve the majority of a set of human intelligence questions. The lectures are pretty decent, though I wish they would redo them in the style of HCI with my man Joyner taking the lead. Overall, this is definitely the better AI course in the program even if it may not be as traditional as CS 6601.

This was my first OMSCS class, and I had different expectations going into the class than what I actually received from it. I almost dropped the class upon failing to implement knowledge from the lecture into mini project one, which I explain in the next paragraph. Tough it out, as I got a 97% (A) in the end. The first few weeks are overwhelming. Then somewhere in the middle, there are about 5 weeks where it gets SUPER chill. Then the last 2 weeks, it is slightly hectic, but nothing like the first few weeks.

Tips: The first mini project was incredibly difficult because I tried to solve it by incorporating stuff from the lecture. But if you ignore the lectures and solve the mini projects using methods that are not necessarily perfect, but rather "good enough", you will realize that this entire course is a lot easier than it seems at first. Remember that the goal of the class is to mimic human intelligence. So sometimes, your code is allowed to reflect some of those human imperfections, too.

The same applies to RPM. But anyways, RPM was by far the most annoying part of the course, just because I had to learn computer vision with Pillow. Most checks you will implement are high-level, so Pillow is good enough to get a 100 on the project.

Also obsessing about time taken for your agents to run is not important for any of the mini projects, or RPM. For example, I know most people's RPM agents ran in under 10 seconds. Mine took 90-100 seconds but I didn't get any points docked off for my agent being slower. Only time I got points docked off was for not mentioning the time at all on a mini project, and it was only docked from the report.

Last but not least, expect to write ~10 pages every week, give or take a few pages here and there depending on the assignment. You will have to not only write functioning code, but then describe it in a report/document. The homeworks are the most frustrating to write, even though you do not have to code anything. You will have to draw diagrams, independently research relevant topics, and then tie it all in with a lecture.

Overall, I liked the class but was extremely frustrated with the amount of writing and doing RPM as a final project because it has a learning curve that the class workload does not account for very well. Great first class, especially for those in the Interactive Intelligence specialization, as it will be one of two required courses for them. Easy A if you are able to simply put the time into the class. Nothing was crazy hard to understand. But expect to spend as much time writing as you do coding.

My background: KBAI was my first OMSCS course. My undergrad was in engineering and I work in an industry that has nothing to do with using Python/Java/C++. Before KBAI, I had never used Python to code anything beyond simple addition of numbers and print "hello world". I fully expected to have a hard time in this course simply because I had been out of academia for so long (writing skills have tanked due to writing so many work emails) and because I had barely any useful experience using Python (hence expecting to struggle on all coding projects).

End result: I achieved a solid A in the course, and my name showed up on the list of Exemplary works more than a handful of times. I worked hard to front-load all coding work and to finish the course as early as possible so that I could have a leisurely November and December. So the number of hours per week that I spent on the course was 20+ in the first half of the course and then dramatically dropped off in the second half of the course. I honestly didn't expect to do as well in this class as I did, so it gives me the confidence to try other courses even if I don't have the ideal prerequisite background needed to thrive from the very beginning.

Words of advice: In this class, being able to pick up concepts quickly and apply them in various ways to coding projects is important. However, what is equally important is the ability to write reports well and to create drawings/figures/tables that enhance the quality of your reports. If you are weak in Python but a decent writer, then take the time during this course to heavily ramp up your understanding of Python and its use of structures. If you are strong in Python but not the best writer, use this time to utilize drawio or similar to draw good figures for the reports. Nothing is worse than reading just a wall of word vomit on 4 pages (each mini coding project requires a 4 page follow-up report or word vomit on 10 pages for each RPM milestone report and/or the Final RPM report).

You should also participate on Ed forum from the very beginning. Participation counts for 10% of your final grade, and there were SO MANY POSTS and feedback from students about how they struggled with getting full points on participation because they either didn't submit "high-quality" feedback on peer reviews for assignments or they didn't want to post on Ed forum because they had nothing to contribute/couldn't answer other people's questions quick enough, etc. People griped and whined so much about Participation grading, but honestly just have fun with the course and post your thoughts and observations. Nobody is out there judging you in the way you think people might be judging you.

Observations about the TA response rates: For Fall of 2021, I thought the TAs were very responsive in the first half of the course. Toward the second half of the course, students would ask public questions on Ed forum and the questions would go unanswered for 1-2 weeks. This was annoying especially when the question benefits multiple students and yet the TAs would not respond. Then if someone else asks the same exact question as a new post after more than 3 weeks of the same question in a different post not having been answered, then the TAs would answer it. This happened enough times where I would get annoyed but nobody would write anything bad on Ed forum because the TAs are human beings and don't deserve vitriol from just grade-hungry students.

Observations about the students: For Fall 2021, the unofficial Slack forum was where some students were able to collaborate on ideas and help each other get through assignments. I didn't participate very much on Slack mainly because I had front-loaded and done so much work so much faster that Slack was not helpful to me. However, Slack helped a lot of other folks (especially if deadlines were looming and folks hadn't started doing any coding work for assignments).

Summary: If you are strong in science/engineering/math but don't have Python background or CS background, then don't be scared. You might actually be one of the best performing students in the class at the end of it all simply because of work ethics and your innate sense of ambition and curiosity to just try things out and do as well as you can in this course.

Have been out of the field for over a decade, and haven't taken academic coursework in CS in almost two decades (last time was on Sun workstations and doing Java, no guis/IDEs), so temper my feedback with that context.

I found the course very approachable and quality of instruction overall very good. I like to write so found the written assignments very easy to complete; the coding (learning Python and OpenCV on the fly) quite a lift. I got an A in the end, but felt like I really flogged myself to get there safely.

Learning the underlying concepts for AI was completely new to me and very interesting. However, not sure how exactly I'd apply these concepts if I had an actual job in AI (yet).

Projects were great, but your mileage will definitely vary depending on whether you deliberately choose to use a new concept (e.g., version spaces) or a more simple one (e.g., incremental concept learning). Students and TAs on the forums are very helpful and have a good culture of mutual support.

This is my first semester and so far really learned a lot.

This was my first course as an OMSCS student. My undergrad was analytics with a CS minor so not really a true CS background. My current experience is in analytics as well.

Overall the course was a great introduction to OMSCS. Dr. Joyner has a great class going and I learned a ton. The coding projects weren't difficult and you can follow along with other student's approaches using slack or Piazza to help you with mini projects and the RPM project. If you make connections the course isn't difficult and can spend around 10 hours a week on it.

TL;DR: 10 hours a week with no CS undergrad to get me a borderline A.

This is a great course and I wish I had taken it before taking ML and RL. You'll great a great overview of AI, with context behind the history of different approaches and their connection with human reasoning.

Projects are approachable, would make a good first class, especially if paired with ML4T. Raven's project is a lot of fun and you are encouraged to learn from classmates and incorporate their approaches into yours.

If you're want a well-rounded class that involves coding projects, writing, human psychology, and a hint of philosophy, this class is for you.

The class included 1 major project with 4 milestones and a final, 3 written homeworks, 2 exams, 5 independent projects. No surprises. By the way, a useful class if you consider doing Phd and need to show examples of your writing since there will be a report for every coding assignment. You will learn how knowledge is used to make functional AI. For example, language processing, computer vision tasks. No group projects. In terms of workload intense because new stuff needs to be done and delivered every week.

I've seen things you people wouldn't believe. [laughs] Attack ships on fire off the shoulder of Orion. I watched c-beams glitter in the dark near the Tannhäuser Gate. All those moments will be lost in time, like [coughs] tears in rain. Time to die.

This course doesn't translate into making you a better software /Machine Learning engineer and that is why you get lot of dissatisfaction. Meaning its not really applied for most students. You will love this course if you are into NLP, Entity linking, Sematic disambiguation, cognitive/linguistic science etc. I work in research lab on these technologies for my company and for me it was very helpful.

You will either Like or Hate the course. RPM project is tough but fun. Getting A is not tough but you need to devote time.

Easy class. I have no CS background and learned everything during the class. Class is in python and it is easy to pick up.

You can start all projects early as you please. A lot of opportunities for extra credit to get an A. If you mess up you can recover. Also you actually learn in this class with the lectures and not dry unlike other omscs classes. Best professor in OMSCS who understands their students

I enjoyed this course. The review below mine complaining about lack of statistical methods very clearly missed the point of this being knowledge based AI and not a course on ML.

I came from a non-CS background and this was my first course. I expect an A. My engagement with this course fluctuated over the semester but overall I enjoyed it very much. This course has encouraged me to pursue AI further as a topic. I am coming out of this course a stronger programmer and writer. I also think slightly differently about how to approach problems with programming and could see a few applications of this course to my job.

The course is front-loaded because the first two mini-projects are the most difficult and the main project is daunting to start. I would say this course starts out hard and by the end is easy. You can finish this course early. Join the slack and read the forums when you get stuck.

Those experienced in Python and good at thinking creatively would crush this course. I would also recommend it as a first course to non-CS background. My prior experience to Python was a Coursera course 1 year ago. Being good with DSA is a plus but I was able to get full performance on every mini-project with nothing more than lists and tuples.

There are 3 homeworks, 5 mini-projects, 2 exams, and the main project. The homeworks are time consuming but I learned a lot philosophically from the 3rd one and a good amount from the 1st one. Homework 2 was rote practice I did not like it. The first 2 mini-projects are most difficult for people without strong DSA while the last 3 are moderate-easy difficulty. MP#2 is the hardest. The exams are open notes and not hard if you watch the lectures once over.

Lectures

I personally found the lectures annoying, slow, and useless. Lots of topics are touched on, and I suppose they're interesting, but I found they weren't at all motivated enough. These techniques are not state-of-the-art for solving the problems they set out to solve. They also aren't doing a good job of laying the theoretical foundations of the field (like e.g. statistical learning theory, which you'll find v well taught in ML).

Projects

I enjoyed the semester-long project on Raven's Progressive Matrices, though it's a little annoying that we're heavily restricted in what libraries we're allowed to use (no ML, no openCV). I found this project pretty difficult.

The best class I had so far. It gives a deep and realistic introduction to many topics, with a very interesting explanation. Professor Goel gives a very nice explanation, you will end up thinking "he must be a lovely person", and Professor Joyner is always great.

I loved the mini-projects, I know many people haven't done it in that way, but I applied directly what learned in the class**, and it was awesome. ** some peer feedbacks pointed that out. I was afraid of these peer-feedbacks, but it was a great experience, almost all the time I felt they were fair and objective, and I could learn a lot from many mates.

Only drawback: the final project demands some Computer Vision knowledge: I spent more hours in that than in the KBAI part itself. Make sure you check the class forum, look for advice about how to approach this project (specially CV part), READ the papers related to that before starting the implementation (I think deliverable 2). As mentioned, this final project is divided into deliverables, a bad design choice at D-2 might push you to refactor the whole solution in following deliverables, loosing a considerable amount of time in that instead of in the final solution. Still, with a lot of hard work, I got an A. I absolutely recommend this topic.

This course is difficult. If you don't have knowledge about AI or Python, you will either fail or drop out with a W. KBAI used to be a bit easier back in the day, but they have revamped the course adding more assignments.

Took this class in Spring '21 with the newly introduced materials which means we had 5 mini projects in addition to the assignments and a semester long RPM project that was submitted in 4 milestones and one final RPM project.

Overall, the class kept me busy for the entire semester with writing and mini projects. Many a times it felt unnecessary writing on assignments explaining my understanding of the concepts used in KBAI systems. The basic NLP project along with other projects were very interesting. It helped me build concepts of BFS/DFS, queue etc. First 2 projects were time consuming. I didn't do well on the block problems (scoring about 70%).

For the mini projects, some of the test cases were known but some were unknown to the class which changed with every submission at gradescope. For the sentence reading/ NLP project, i submitted around 45 times to get 100% on the dynamic test cases.

There are enough places to score score extra credits and unlimited attempts at gradescope is very helpful in getting "A".

PREREQS:

This was a relatively simple course in terms of programming as long as you have an okay grasp of data structures and what they do/when to use them (I really hope you do by the time you take a Masters course), along with the syntax to use them in python (there is an excellent 4 hour Youtube video by freecodecamp called "Learn Python - Full Course for Beginners" which will give you basically everything you need to know, you can google the rest).

OVERVIEW:

The course gives you an overview of KBAI theory, and you have to code things in python to basically show you understand the material (as almost nothing in the course is practical, you don't even have to vectorize ANYTHING in python until maybe the final the project so python is just used because its an easy language to work with, if this is was your only python course, you will come out with a Beginner understanding of it).

The class is somewhat time consuming because you have to write reports explaining your code, which help you understand your own code better, along with rating other people's essays so you can see different ways to implement each project. This is a Dr. Joyner class so he is very into making SURE you learn the material, via all these methods.

The professors themselves answer questions in Ed forums which is a nice change of pace to some courses.

FINAL PROJECT:

Note, you can get 100s on the coding portion of the RPM checkpoints if they pass 50% of the test cases. You will get a 50 on the final project coding portion if you do the same thing, and thus the final project is really the only masters level difficulty (honestly its sort of PhD level) project in the entire course, save the NLP project, which is a pain, and doesn't even teach you anything practical about implementing NLP.

I believe I got <60 on the final project coding portion but comfortably got an A in the class because I got A's in everything else, but if you didn't get A's in everything else I doubt you will be able to get a good score on the final project coding portion, as doing so would require to basically implement a combination of everything you learned in the course along with decent understanding of OpenCV.

EXAMS:

Exams are open book. That doesn't mean they are easy, honestly this is an excuse to make them extremely precise to match the exact wording of what the instructor says in the lecture. Make sure you take good and organized notes (preferably electronically, so you can search through them with keywords) and read over them at least once before the test so you know which lecture to watch again during the test for the tricky questions and you should walk out with an A (test prep. shouldn't take more than 2-4 hours assuming you already took good notes and watched the lectures and are a good test taker).

Let me behin by saying that so far I have taken 4 courses in OMSCS, Introduction to Information Security, Computer Networks, Machine Learning for Trading and Software Development Process. I am a big fan of Dr Joyner’s courses but this one dissapointed me and stressed me enough to withdraw from it. I am surprised at all the easy reviews, may be they are experts in Python and I am at intermediate level. The course demands a lot from you - one main project with 5 milestones, 5 mini projects, 2 exams and peer reviews. If you have a demanding job that required 9+ hours of time, then you will find that the only two things in your life are job and this course as you will be switching between the two and wouldnt that time for anything else. I guess they made the syllabus of this course more harder after all the easy reviews, feedback provided by my seniors was they there were no mini projects until the recent semesters.

The guard/prisoners mini project (or fox/sheep however you want to call it) was enough to stress me out and get me out of this course. ML for trading had good videos and ideas on how to implement what is being asked but with this one you are on your own. Be preared to then write a journal once you have been drained with writing code from scratch. This, in my mind should be one of the hardest courses. Writing programs that would solve problems like humans do is no piece of cake. I generally dont write reviews or complain about courses but this one made me do it. I had never felt so down after 2 weeks into this course. I lost all my motivation, may be its just me. Having said that, I will give a shot again at this course some time later when I am mentally prepared.

Background: Non-CS undergrad (Mechanical Engineering), working with software at work for about 2 years in Python and C++.

This class was alright, maybe would be a good warmup class for students in their first semester. Personally, I found most of the class a bit too easy (aside from the Final RPM Project). The lectures were more philosophical and while they seemed to try to connect the lectures with the assignments, I rarely could find a practical connection (aside from the Mini-Projects, which were great). Exams are almost impossible to study for since they're written with open-book in mind and the format is essentially True/False. I'd prefer a short response exam given the course material.

The overall course material is slightly interesting, although I think they could prepare more practical lessons and less obvious approaches. I kinda feel like I wasted a class slot, although this was a summer semester so I'm not beating myself up too much. Fortunately the pace was manageable, I was actually able to take a week long vacation during the semester since all assignments are available the entire semester (until their due date).

There were 5 mini-projects in this course and I think they were all interesting and I like that they were all open-ended. The second project called Block World(which is similar to the prisons and guards problem) was the project that gave me the most difficulty.

The Raven's matrices project has been broken down into 5 milestones and a final project which is great and allows you to better approach the entire project in steps. Homework assignments were generally straightforward. My only complaint here is that I feel like the TAs were sometimes a little nitpicky when it came to grading them. Tests were open-book and were very challenging. My advice here is to try to watch all lecture videos and take good notes.

I like the idea of participation points but I feel like the peer feedback system needs to be revamped. Most participation points are a required part of your final grade so this causes there to be a good bit of forced and inauthentic feedback/participation at times. One way I believe this could be fixed is to reduce the amount of peer feedback assignments and offer a variety of other avenues to earn participation points. Maybe fewer points could be required for mandatory participation, while other types of participation could count as optional extra credit.

And last but not least, shoutout to Ida and Dr. Joyner! You guys are the GOAT TA and Professor respectively! You guys are awesome and thank you for all that you do!

I enjoyed KBAI. I am a person with a non-traditional CS background and the course provided a great introductory framework for knowledge based approaches to AI. I expect to keep going to back what I learned here in other courses.

Most of the reviews of this class characterize it as "easy", but I didn't experience it that way. While the subject matter and coding projects aren't strenuous (particularly for someone with extensive CS experience), the workload is significant. I took the course during the Summer of 2021 and I would describe it as UNRELENTING. The normal 17 week semester was compressed into 12 weeks. No work was dropped. Each week, you're going to have at least two deliverables. Sometimes its a coding mini project and a paper describing it (~5-6 pages). Other times its a homework essay (~5-6 pages) with a milestone for the RPM project (code submission + ~4-5 page paper). This is in addition to watching lectures (~1-2 hours) and peer feedback (~1 hour). If you're planning to take this during the summer and have significant plans, make sure you plan well ahead.

I was involved in study group and found it to be enormously helpful when I got stuck on things. If you're interested in something like this, post on the forums and see if you can get a group together.

As mentioned in other places, the exams are basically 110 true-false questions. Its worth taking high quality notes while you're watching them initially, even though this will take more time. Reviewing the notes and watching the lectures again at 1.6 speed was good preparation. I'd say the re-watching is critical because some of the questions are worded in such a way that having a recent impression of the lecture will help you find what you need quickly.

I was frightened by the RPM project at first, but there is actually a lot of academic writing on how to build agents that solve the matrices. Its worth doing a bit of research on your approach before getting started. I used fairly simple heuristic methods and was pleased with the results.

TLDR - This is a good course that is a lot of work for the summer months because of the reduced time window. I'd called it KBAI intensive.

Easy class and easy intro class for the OMSCS program. A few things I noted over the course of the semester is that there are a lot of useless things in this class that once again make learning out of reach. One, the exam is 110 true/false questions is open book, but very tedious and annoying for an exam setting. Two, you don't get to see what you miss on an exam, so all of the course's emphasis on learning seems pretty hypocritical. Three, on all the written assignments, there is a minimum assignment length, which makes a lot of the writing pointless and just filler writing. Furthermore, the TAs read the assignments and sometimes dock random points saying some of the questions aren't answered in detail when they are. Overall, easy A, but David Joyner's courses seem to have a decent number of complaints like the ones mentioned in this.

The course is a good 1st course for OMSCS as you will get used to the idea to get a concept and then code it out. The TA are super helpful. the class have very active Ed Discussion.

The course has deliverable every week, so that's a lot of work for this course.

Homework: it can be quite dull. however, some question can be thought-provoking like GDPR, conscious..etc

Mini-project: I like the mini project the most. I learned a great deal from here , from both programming and KBAI perspective

RPM: This is a tough project and I only get 55/96 for my final agent. I get to learn OpenCV in great detail , which is fun for me.

I got A still despite my low score in RPM agent performance.

Overall, great learning experience!

For context, this was my 6th class in the program (CN, IHI, GIOS, CP, AI). Non-CS engineering undergrad, working as a software engineer.

This was the first summer semester with the adjusted syllabus: they added 5 nontrivial "mini-project" coding assignments with some reductions (shorter written Homeworks, down from 3 to 2 exams), then crammed all 17 weeks of expanded content into the 12-week summer semester. The majority of weeks had both a coding & writing assignment/exam due in addition to peer reviews and 2-3 lecture sets, so there's hardly a moment to breathe or get ahead. Dr. Joyner deliberately shifted the difficulty from grading to the workload, resulting in more reported hours of work but also a higher proportion of A grades.

The instructors made some scheduling mistakes: several assignments were due before the corresponding lectures. This piled onto the aggressive pace of the first half of the summer semester. That said, head TA Ida was probably the best TA I've ever had in OMSCS thanks to her quick and very specific help on the forums.

I believe many OMSCS classes don't adjust the syllabus for the summer semester, so this class probably isn't the best or worst option for a summer semester. Strong Python students should still be comfortable in KBAI during the summer. In its current format, I would rate the class Easy for Fall/Spring and Medium for Summer.

Grading

The syllabus seems designed with the expectation that students will get lower scores on 3 assignments: the 2 exams and the final RPM code submission. These assignments are far more difficult to get a >90% than other assignments in the class. To get the A, it's important to get >95% on all the Homeworks and Mini-Projects. No curve or extra credit was offered. The Head TA stated in a forum answer that they round up for cutoffs: 89.5% rounds up to 90% for an A.

Homeworks (writing assignments)

The writing assignments are well-organized but simply time-consuming because the 2 main questions are subdivided into 6-10 specific sub-questions and visualizations.

Achieving near full-credit on the writing assignments should be a rote exercise: follow the JDF format, use proper APA citations, answer every question & subquestion thoroughly, include requested visualizations. It's a good idea to always include one or two tables/figures because, unless your writing is extremely organized, the graders heavily favor visualizations. There are no points for formality, so organizing sections by questions is the most straightforward choice.

Mini-Projects (coding assignments)

I appreciate the intent to create interesting, open-ended applications of the course content. As other reviews noted, it's easy to find overspecialized solutions which exploit the predictability of the autograder, which is more lenient than other OMSCS courses. These are all 50% autograder (Gradescope), 50% written report. For better or worse, 3 of these problems are graph problems, so CS6601: AI students have a huge advantage here.

1. Missionaries & Cannibals: other reviews have cried "it's just BFS!" but that is exactly the point: state-space searching is a large component of AI. The whole challenge is creating & managing the state representation.
2. Blocks World (Sussman anomaly): I believe this is the most challenging mini-project. It's similar to the first project but uninformed search will not work. My solution was a hill-climbing algorithm from YouTube.
3. Sentence Reading: I agree with other reviews - this would be the most difficult problem if it wasn't so easy to exploit the grading methodology with hardcoded workarounds. I didn't see anything more creative from peers in the class because we can't use any NLP tools. Most students created a production system (series of if-else statements) which mapped question words (e.g. who, when) to the set of possible answers. I also abused the grader a little and submitted 20 times until I got a favorable set of questions for full credit.
4. Monster Identification (Classification): I thought the problem might require a nearest-neighbor or version spaces approach, but my first straightforward attempt scored 100% with just 8 lines of Python code. This is definitely the easiest programming assignment I've completed in OMSCS.
5. Monster Diagnosis: Yep, another state-space search problem (I used A*, but BFS should work). The data is nested dictionaries of strings, so a bit more annoying to work with than MP1. I saw a lot of peers brute-force this problem with itertools.

Raven's Progressive Matrices

This semester-long project is the most interesting challenge of the class.

For students who have a hard time coming up with solving strategies: start with the Joyner paper and take advantage of Peer Reviews & Exemplary Reports for more ideas.

I didn't get penalized for literally hardcoding the answers to the Basic problems with a simple lookup table, so that was a guaranteed 50% minimum on the coding portion. As long as the report demonstrates that you put effort into more generalized strategies, you'll get a solid grade. Ideally, you aced all the Homeworks, Mini-Projects & Milestones so you don't need a high score here.

Exams

Proctored but with generous policies: open-note, open-book, open-internet. As another review mentioned, the exam is effectively 110 True/False questions. The instructors also put in effort to ensure none of the answers derive verbatim from the lecture notes, so a substantial amount of reading comprehension is required similar to the SAT or GRE exams. I sympathize with the non-native English speakers in the class because I honestly believe they're disadvantaged.

In my opinion, the only effective strategy is recognizing the lectures associated with questions. The exams will punish you for rushing or skimming through the lectures. I rewatched all the lectures on 1.7x or 2x speed the week before the test to "study" and achieved one of the top few scores on each exam. The class provides a PDF with all the lecture transcripts to make this a bit faster to review. Thankfully, the exam does not pull any content from research papers or additional readings.

• Lectures: Quite boring. You don't really learn much from the lecture if you are going to take AI. KBAI is a subset of AI.
• Written Assignment: There are 3 Written assignments. It's loosely related to the lecture.
• Mini Projects: 5 Mini projects + Report. Not difficult. Most of them are just a bunch of if/else statements. You don't actually need to code AI agent to solve them, just a bunch of IF/Else as the GradeScope grader is dumb.
• RPM Projects: Students without OpenCV or Pillow experience are going to struggle. A lot of students complain about the difficulty of final delivery. I don't understand why didn't they read the requirement. Everything was posted in the beginning of the class. Some students are like oh I didn't expect my implementation of DPR/IPR can't solve the problem set D and E. It's a semester long project. You should have read the requirement before you implement your agent. This project is fun and I got 94/100 for the final delivery. You absolutely need to invest your time in it if you want a high score. However, you can hardcode the solution and easily get up to a decent score as long as your writing skills are good. You need to score 100% on all the reports as it counts 50% of each delivery.
• Exams: 2 Open Everything exams. No point to study. One can easily search the notes you prepare and find the answer.
• Participation: You need to be active on Ed and do all the peer review to get this 10 points. Not difficult, just tedious to read through boring papers from your classmates.
• Professor: Professor Joyner is great. Very active in Ed and communicate with students every week.
• TA: Best TA in the program. No nonsense Rubric deduction. Grading is very clear and generous. Grades are returned in a couple weeks and I rarely see anyone complain about grades on Ed. No drama like other courses.
• Difficulty: RPM is not difficult, You just need to put in your effort. One can easily get a decent score with hardcoding or overfitting the solution. Mini projects are not difficult. Some projects can be done with a couple hours.
• Time Management: Don't follow the schedule. Work 2 weeks ahead of the schedule and you would be very comfortable in this class. This class requires 10-15 hours/week and the second half is more relaxing when you get your RPM mostly done in the first half. If you follow the schedule and only implemented DPR for B and C, you would probably be stressed in the last 2 weeks.

This was my first course in the OMSCS program and have little to compare it to. I have taken undergrad AI courses previously. For reference, I got a comfortable A.

From my understanding, this course was majorly updated this semester, with the inclusion of 5 mini-coding projects, and less writing-based homeworks. The final RPM project now allows unlimited Gradescope submissions, but full credit requires answering every basic and test problem given. I didn't hear of anyone who received full credit on it. Most people (from anecdata) seemed to get around 70%. However, your grade is very evenly spread out among the assignments from the rest of the course, it was a non-issue. RPM problems are now visual-only as well. There is a deliverable every week, and yes, usually writing is necessary. I am comfortable with writing, however, and found that to be pretty easy.

Highlights

• Prof. Joyner appears to be genuinely very enthusiastic and caring about the quality of the course. Processes have been tweaked nearly to perfection, there were no road bumps along the way
• The coding aspects of the assignment are enjoyable, dare I say, fun!
• Grades among course work are very balanced. Nothing is weighted too heavily. As long as you keep up, you will easily pass
• All assignments are released at the start of the course. You can front load the crap out of this course, which is what I did. It was very useful because I knew I would get very busy in March, so I completed about 75% of the course before then (note that I did take a week off between jobs during this time to get ahead).
• High level topics are interesting to think about
• The workload seemed extremely manageable to complete on top of a full time job and still have time for personal activities. For reference, I work full time, changed jobs (to a higher-responsibility job), bought and moved into a house, produced and ran a virtual film festival, and worked a side gig 4 nights a week for a month during this semester (no kids though, haha).
• There is a lot of flexibility allowed for how you solve coding problems.
• Low stress, open note exams.

Downsides

• As mentioned, coding allows for flexible solutions. You can use course concepts...or not. As another reviewer mentioned, this can mean that some of the projects are pretty trivial to solve and not actually useful in extending your knowledge about the course concepts. Several of the mini-projects felt like interview practice questions for me. Fun to code out, but not useful to me in building my knowledge deeper
• The amount of peer feedback you have to give is a bit of a drag
• Lecture videos also kind of drag toward the end of the course
• Grading, while generous, felt a bit nitpick-y at times. Most of the points I got deducted were for "not explaining enough" when "enough" was never defined in the first place.
• I am not a fan of the exam format. There are two exams of essentially 110 true/false questions. You need only study for a few hours for these, and are low-stress, but your full results are never released, so I don't feel like they reinforced any knowledge, personally. It felt like they were included in the curriculum out of obligation.
• A lot of the RPM project was solving image processing/computer vision problems, which is not content covered whatsoever in the course. Prepare to dig into openCV documentation A LOT before you can even begin to think about solving the problems with the concepts discussed in the lecture videos. This is the crux of what people mean, I believe, when they say the project is not related to the course very well.

Overall impression

KBAI is a solid, fair course. It is well run and well organized. The expectations and workload are very manageable. Difficulty leans a little toward the easier side. However, I don't feel it gave a lot back to me or deepened my knowledge in great ways. This is partially in part my own fault for not challenging myself further with the projects. You get what you put into this course. Because of this flexibility, it is a little easy to shrug off some of the work.

This was my first OMSCS course. All the elements of the class felt well designed, but personally I didn't find the topics very interesting.

The lectures generally walk through some concepts at an extremely high level. The new mini-projects were nice in that they allowed us to put the lecture concepts into practice, but they were often very trivial and could be completed without any concepts from KBAI. The RPM project, on the other hand, felt like a drag because it felt completely unrelated to the rest of the course. The peer feedback system also felt like a chore simply due to the sheer amount of feedback we are required to give to get participation points.

Overall, this is an easy course with a moderate workload, but I don't think I learned much at the end of it all.

Also, there is a TON of writing in this course, so if that is not your cup of tea, beware.

I really liked this class because I feel like I've learnt alot more about how artificial intelligence works versus my previous poor grasp of AI. I think that this course in particular is alot more work heavy compared to alot of other classes I've taken. Partly because of the way the course is structured and partly because building out an AI involves alot of small tedious things(I think). But overall I liked the class because I learned alot.

I don't want to say the difficulty is hard but I'd treat it like a hard class because of how much work is involved. But on the upside, because there's a lot of homework/miniproject/projects/participation it gives you alot of oppurtunities to get a better grade versus if you mess up on a single aspect of grading and there's not alot of oppurtunities to improve your grade.

This was my first OMSCS class. I think it's a great one to get back into academic work, especially for those who have been away from college for a few years. The class is very well-organized, and although I found it slightly front-loaded, the amount of work I spent on the course each week was roughly the same.

My best advice for this course would be for the RPM project--the course's semester-long project. Although I enjoyed the project a lot, I think it's fair to say that the concepts from the lectures of the course are really only loosely tied to the project. For me, the project was much more about learning about image processing and researching strategies.

Back to the advice: there are helpful milestones for completing this project (generally, one milestone per problem set type); however, I made the mistake of trying to always generalize the code of my previous milestones to fit new milestones. This was a mistake. Instead, you should create modules per milestone which the agent can call depending on the problem set name. For each milestone, you should then try as hard as you can to fit your algorithm specifically to that problem set. If you do this along the way, the final project will be essentially complete through the milestones.

I loved this class! The mini-projects were a great addition. I hope Dr Joyner and the rest of the instructional team will continue to incorporate even more lecture material into the assignments as the semesters go on.

A lot of people critique the main project of this class as being more image processing involved and using DPR/IPR as opposed to applying concepts from the lectures. I see where people are coming from, but I think it depends on how you choose to look at the problems. Personally for me, I tried looking for patterns on my own first before looking at any papers and felt that the lectures did help frame my thought process (even though I don’t think I can attribute anything I used directly to the lectures except maybe generate and test). And even though I did not end up using DPR/IPR, some of the discussions around it did help me improve my agent too.

I believe how much you will enjoy this class will depend on how much you want to put into it. But if you really despise having reports due once a week, then maybe skip this one.

I thoroughly enjoyed this class. It was overwhelming at first as there is something due every week, but it is one of the most organized classes I've taken. The full calendar breaks down not only what lectures and projects to complete, but when you should start working on projects that will take more than a week to complete.

I have a strong background in Python, a CS degree, and was familiar with numpy through CP. Most of the coding took me a couple days at most to get a full credit solution. The exceptions were MP 3 and the final RPM. I was one of the ones who attempted a frame based solution (and only partially succeeded) for MP3 when this version could be solved with a series of if statements (I believe they plan to change this in the future).

RPM is the ongoing project. The milestones aren't too difficult. I was able to pass one or two with horrible solutions that did just enough, but had to go back and redo a lot for the final version. I wish they'd move all the milestones to the end so you don't have to constantly switch between RPM and the other assignments.

The reports are tedious to write but the number of times I'd start explaining my agent and realize a detail that could improve it made me feel like it was worth it. Make sure you follow the format. Use the template - it makes life easier and means you loose less points.

Participation is frustrating to get. Opportunities for participation other than forum posts and peer feedback are rare. If you're not the type to post often on the official forum, automatically do the 3 required and the 5 extra peer feedbacks as you go. Otherwise you'll be giving feedback for assignments due 3 months ago. Peer feedback as a tool to improve my future reports is almost worthless. Occasionally I'd get some valuable notes, but most of the time it's "looks great/good" or everything is wrong because I didn't do something exactly like the reviewer did. As a tool to understand other ways to complete the projects, it's invaluable. For RPM, some of the changes I made came from reviewing somebody's report for feedback. The exemplary reports are also a great resource for this.

This was my first course at OMSCS, and I come from a non-compsci background. Overall, I found the course relatively easy and very enjoyable. A lot has been said about the high quality of the lectures, the divisiveness of the RPM project, the general ease of the exams, etc, so I won't delve into that.

There's not a lot of info here about the mini-projects though, so here are my thoughts on them:

MP1 is very simple, all you have to do is apply a simple idea from the lectures and implement BFS or A* and you're fine.
MP2 is perhaps the most open-ended one; I saw many approaches to it. It's not crazy difficult per se, but it's a little deceptive. It looks about the same difficulty as MP1, but took me twice as long.
MP3 probably looks like the most interesting one from afar, and it's pretty cool, although definitely the most time consuming. Prepare to likely spend a while pre-processing the words. A lot of students started out trying to use a Frames-related approach, and switched to heuristics or a production system later. This semester, a lot of students got full points by implementing a very hacky solution since there were only 60, maybe 80 test cases. I don't know if that'll be the case in future semesters.
MP4 was shockingly easy. My full file, including starter code, was less than 25 lines. YMMV, and once again I wonder if future semesters will have more rigorous test cases.
MP5 was also pretty easy. Like in MP1, BFS or A* are your friend if you can mix them with a generate and test ideology.

The other big changes of note this semester are that the RPM was graded more leniently for the milestones, but more strictly for the final project, the homework essays have been shortened, and the exams have been condensed into two tests instead of three. Things did seem very confused when it came to grading; almost every grade for the first two months was entered incorrectly on Canvas, only to be changed to the correct score a few hours later. This led to a lot of freaking out on the class forum, but generally smoothed itself out as the semester went on. I imagine it will be less of a problem in future semesters.

My hour count is a complete guess, as I finished over half of the course's content in the first month or so by working ahead.

Like I said, I came from a non-compsci background, and yet managed to do very well on each RPM milestone, exam 1, homework, and got full marks on each miniproject. I'm waiting on my final grades, but I'd be surprised if I didn't end up with an A. I'd highly recommend this course to anyone who is either new to the program or wants a course with interesting content, relatively easy coding assignments, and a fair amount of writing.

Pretty easy course if you've already taken AI (CS-6601) You'll have to write and read a lot of papers during the semester which wasn't very fun but it's not hard. The assignments were all doable and are released early if you want to do them ahead of time. Tests are open book/notes/internet

This may be a good course if you're really interested about AI or trying to take lecture materials and apply them in a very abstract way to a problem you're woefully underprepared to handle.

Lectures These are actually the best part of the class. They are concise and relatively clear. They cover a broad range of topics and do drill into enough detail to get a solid idea of the principles.

Exams These aren't difficult to pass but hard to ace. If you've paid attention and written some notes about the lectures you should be fine.

Homeworks These are just essays. You are expected to look up a topic and write a few pages about it. They're not bad but they're also not as engaging as some of the other assignments in this course. To me they felt a bit shallow and really should have been more of a discussion of sorts instead of a written paper.

Mini Projects These are, hands down, the best assignments in the course. These are setup to give you the opportunity to actually practice the lessons learned in the lectures. They are modeled or sometimes complete copies from the lectures. These have been a lot of fun and the most engaging. I WISH the final project was more like these, or just a bigger version of one of these.

RPM project This is going to be your bane of existence in this class. This is the final project and it's absolute garbage. As others have pointed out, this is really the professor's attempt to crowd source solutions to the RPM problems and see what novel solutions student's can come up with. The problem is that there isn't enough time dedicated to try any novel approach. There is just enough time to get the easiest solution working, so everyone ends up finding the paper about IPR/DPR and implementing that. Even if you wanted to try something else since you're allowed to use Pillows and OpenCV, the course then shifts from AI to more image processing. Some image course really should either be a prereq or the students should be given some tools/wrappers for those libraries to allow them to focus on the AI aspects instead of wasting all their time with just the image processing aspect.

Summary The course might be better for some, but I enrolled in an AI course and with how much of the grade is dependent on the final project it feels more like an image processing class. The experience has honestly been the 2nd worse of my OMS career and I can't recommend this class in good faith unless you have already taken an image processing class or are prepared to find previous RPM papers and copy their efforts.

Great course overall which I am really enjoying, however there are some flaws which (depending on what you want to get out of this course) may be annoying.

Lectures are great - they are clear, concise and present the topics well.

Exams are tricky - you are effectively assigning true/false to over 100 statements. The floor is high for this (as you should get ~50% just by guessing) however it is trickier to get a 90%+. This is just exam 1, have yet to take exam 2 though I understand the format is the same.

Homeworks - there are 3 of these, which are written papers of between 4-6 pages. They are good as well as thought provoking. Also (If you have not taken a Joyner class before) the format the class insists on has a lot of spacing and margins. So 4 pages of text here is not as much as your typical 4 pages in a newly opened word doc for example.

Mini Projects - there are 5 of these and they are fun, they do get you thinking. My only complaint is that on a some of them it is easier (and arguably more effective) to come up with your own solution rather than using concepts from the lectures.

RPM project - this is semester long and in total is worth 30% of your grade. You have 4 milestones throughout the semester (these are worth a combined 15% and each has a paper associated with it) and then the final submission (worth 15% and includes a paper you must write). I've enjoyed this a lot, but again it is easier to complete focusing on image processing/openCV than it is using many of the concepts from the lectures. My python/openCV knowledge has come a long way, but my ability to implement KBAI concepts, less so.

In summary this is a great course - though be warned that to get the most of the course you need to be disciplined when completing the projects. You can go through most of the project work without using any concepts from the lectures - if you want to get the most out of this I recommend at least trying (even though it will take longer and may affect your grade).

Also if you hate writing and having to submit something most weeks - this might not be a good course for you. Though you can work ahead a fair bit also so that helps if you are able to get ahead.

This was the first class I took in the program and I enjoyed most of it. I have been out of both the technical and academic fields now for 15 years so I thought this would be a good course to help me transition back into things. For the most part, I was right. The course was excellent in many aspects, good in some and bad in some. It was superbly organized and managed. Expectations, objectives, and communication were all clear, concise and seemed ready-made for the student's needs. The material for the most part was super-interesting from a cognitive/philosophical standpoint. Both of which hit spot on to many of my interests.

The homework assignments were hit or miss. Some of them were very interesting and provided excellent opportunities for both learning the subject matter as well as expanding on our own thoughts and arguing for our viewpoints. Other homework assignments were needlessly repetitive and outright boring (reading multiple papers and summarizing, etc).

The Raven's Progressive Matrix project is the main focal point and stretched through the entire semester. I put in a massive amount of hours on the first iteration but after that the effort vs. return seemed to diminish greatly as only minor changes were needed to achieve acceptable performance.

The reports for each iteration got extremely repetitive given the required format of reflecting on the same points for each of up to 10 submittals per project. I think this format could be tweaked to achieve the instructor's goals of encouraging iterative improvement while at the same time limiting the repetition of trying to figure out how to say the same things in eighty different ways.

The exams were not difficult but did require a good amount of familiarity with the material and/or very organized and efficient keyword searching during the exams (which are open-everything).

The thing I found most enjoyable about this course was its cross-disciplinary exposure to topics in psychology, philosophy and neuroscience. These topics forced me to really sit and think through my stance on the nature of consciousness, self, and personhood. Overall I enjoyed this course and found it manageable from a difficulty/time spent perspective.

This class offers a glimpse into the world of cognitive science. It is a good introduction to a broad range of concepts, but does not go deep into any details.

The homework questions and the quizzes are all well designed to reinforce the course material. Some questions are very interesting and reveal some of the delicate socioeconomic and legislative challenges in the realm of AI ethics.

The RPM programming exercises are not as exciting as the rest part of the course. First of all, they are quite repetitive. Secondly, most students (myself included) ended up with overfitted pixel-based approaches that can crack the problems without using anything related to "knowledge based" methods taught in the class. At the end of the day, I feel the RPM projects only improved my report-writing skills, not much on programming or KBAI knowledge.

I am glad to know that the instructors planned to dramatically change the agenda of the course going forward, by including more lecture-relevant programming exercises and reducing the weight of the RPM projects. Hopefully, all these changes will make the class more coherent and enjoyable for future students.

In this course, I don't think I learned anything useful. Waste a lot of time on writing articles and simple if-else codes without improving my CS knowledge and skill. It was my 1st course in OMSCS. I thought all the courses in the program is as boring as 7637 and was considering quitting. After another two semesters, I realize that 7637 is a special one.

Summary

I am ML spec and think this was a great introduction. I took this alongside CS 7638 / AI4R. This course was significantly more time consuming than AI4R. Liked the content, though it was high level and language agnostic. I must have landed at the cusp of an A (sub 90, got an A).

Assignments

Homeworks were thought provoking and took me about 10-15 hours each. I think they gave me a good overview of ethical issues in the field of AI. I imagine the time commitment for the papers will go down as new projects are being introduced. Expect the focus to become literature review, ethics and philosophy of AI.

The new projects are going to focus around concepts taught in class and of the couple I did, were quite fun. Looks like these will be code X and submit. Though there could be a small write-up.

RPM

This project will still exist in some form (at least that was the most recent decision). Was fun solving a somewhat "real" problem. My first agent was verbal which felt in-sync with the course. The latter two agents were visual and felt more disconnected. In future semesters, students will probably be focusing on the visual techniques.

Exams

I did ok on these. Questions are based on lectures and the exam is essentially a True/False format. It is valuable to familiar with the lecture material before taking the exam.

KBAI was my first class in OMSCS and in retrospect, it was a great choice to warm up with the program without taking something 'too easy'. The RPM project was fun and challenging enough, without being too stressful.

Assignments

3 homeworks, about 8 pages each. The JDF format isn't terrible to work with as they provide starter documents in Google Docs and Word. Half of the questions are interesting and immediately relevant to material, the other half are philosophical/ethics-based questions which are a little painful if you don't like writing.

Projects

Projects are great - progression of difficulty is a little steep from 2->3 given the types of patterns you have to find and a lot of trial and error is required depending on your technique. I found making some sort of automated tests helped catch regressions. I ended up making a spreadsheet with answers and conditional highlighting so I could quickly find accuracy % and catch any regressions on previously correct answers. I did verbal for P1, then visual for P2, P3 which worked out.

Exams

The exams are nothing to stress about. Just watch all lecture content on 2x speed beforehand, have the PDF version of the lectures available, and CTRL+F any questions you don't immediately know and it'll work out.

Peer Reviews

This was the most painful part of the course for me. You get 'assigned' 5 peer reviews per HW/Project paper, which comes out to 30 'assigned' peer reviews. Each one of these is 8-14 pages each, which is a LOT to read and sometimes very painful to get through. Then you have to provide a review that meets a 'quality' criteria. The grade for this is your participation grade, so you don't necessarily have to do it, but it depends on what other options exist for participation credit. Thankfully, we had 5 mini-projects this semester that would count for more than enough to get full participation credit so I was able to stop the peer reviews.

New Course Content in future semesters

We had 5 optional participation credit mini-projects available that are supposed to be normal assignments in future semesters. I've read a lot of hype around the 'NLP' assignment here, but it is very basic in nature and doesn't involve serious NLP concepts, but is instead an exercise in framing. The other projects were very relevant to course material and I think will improve the experience overall. They were some fun programming/algorithm challenges that give you an opportunity to solve problems closely related to lectures and go through the process that is generally hand-waved during lectures. The RPM project is likely going to change in that it might just be 1 big semester-long project, but I'm not 100% what the plan is. Overall, I would expect the quality of the course to be higher in future semesters with these changes.

Overall, fun class, not too hard, not too easy, great way to refresh Python and learn some high-level AI concepts. Was a nice starter class because some weeks you can get away with doing nothing and it's possible to cram work before assignments are due without sacrificing your sanity.

This is my first course in the semester. I have a good CS experience but a very less AI experience. Hence, I wanted to get started and KBAI is one of the best startup courses. It has really engaging lectures, great TA support and weekly threads discussing about various news, articles and papers around the world. The homeworks are bit of a writeup but they are not exclusive to this subject. There are certain questions which make you read about various papers published in AI or general GDPR rules and write your theses. The projects have not changed over the years but it gives you that first hand experience of designing something in AI if you are new to AI or Python. This is a great first course to start with if you are planning a ML specialization

From what i understand, the assignments have not changed for the past 3-4 years. Hence there is grounds to believe that the previous reviews that claims that they can complete projects 1-3 in 2 weeks is either dishonest or they have just copied from others or they are geniuses.

When i started on this course, i have the same negative thoughts on the materials and what i am learning. However, as you approach the final weeks, you start to see where the David is trying to get at. He is creating cognition not in machines but the students. (see his last lecture on his PHD project)

While you might be good at writing lines of codes and able to do ruby, javascript, C++, psql etc. You might not be good at thinking through how to solve problems in general. Think of how you would approach a google interview, this course give you a good insight of how to do it, provided you are able to relate what is taught to yourself.

Overall, projects are doable if you relate to the lectures, which i admit they are mostly dis-linked. However, i think david is trying to change the assignments in the next semesters after the feedbacks. Which after doing some of the test projects would seem fun.

This was my second attempted course in OMSCS. I tried taking AI4R in Spring 2020, my first admitted semester, and ended up withdrawing after not passing the first project.

I spent time prepping my general programming knowledge and worked through a Python book before the Summer 2020 semester started. I come from a pure math undergrad and I'm not a developer, I actually run a small construction company so my professional technical experience is pretty much nil.

I really enjoyed KBAI and ended up getting an 'A'. A common complaint is that the lectures don't line up with the projects well -- which I feel is true. My best advice: start on the visual-only approach as soon as possible (there are 3 projects in the class, the first two have verbal approaches which are much easier). Also, go to pinned slack messages from previous semesters and see what algorithms other people programmed to solve the RPM IQ tests.

Overall, I felt my programming skills were refined and I got a decent understanding of AI outside of the realm of ML.

Before I took this course, I saw lots of review on this OMSC Central, which said this course is really too simple, and it offers you nothing to learn. Some even said they can complete the whole course and all assignments (3 homework, 3 projects, 3 exams, 25 lectures) within two weeks. I think those reviews are simply not true, except if those reviewers are superman (or maybe they really are?).

I think I did learn something from this course. At least I learned that AI is different from Machine Learning (ML) that AI learns from very small sample size and behaves much more like human than ML. And in contrary to ML, AI can apply to a wider range of problems, while an ML algorithm will typically fit a specific problem.

There are some areas in this course that may make students think they learn nothing from it, including some concepts which common developers may already be very familiar (e.g. configuration, script, pre / post conditions, frames (i.e. classes)). The course did introduce these concepts, even with very detailed examples, but some experienced software developers may think those concepts are nothing new. Students may even complete all three projects without even knowing a single skill taught by the course...

Nevertheless, I think those AI algorithms can really help, even in doing the final project, if you have the time and patience to integrate those algorithms into a single working Java / Python application.

The homeworks are almost all writing tasks, and some questions are philosophical rather than computational. Some questions even touch religious topic such as "what is free will?" or "what is consciousness?", which I am comfortable with, but I understand some students may consider those questions as totally irrelevant....

One thing I do not really understand is why the course designer insists on using visual methods to do the final project. That makes the visual recognition, instead of the artificial intelligence, becomes the greatest hurdle of the project. My question is, are we not having the right to do intelligence, if we do not have the vision ability? Anyway, I chose the fractal method, which the instructor introduced at an very early stage, though from all the peer feedbacks I cannot see anyone doing the same fractal method, which is a shame since I made a very slow fractal algorithm, and I do want to see some other students doing the fractal method but with a faster speed.

So, to all future students who want to do the fractal method with Python, beware of a very low speed. I saw many other students do the ASTI or something like the different pixel count, and they can achieve very good result with a much faster speed. Fractal method is very versatile, but may not be suitable for this project, except if you can implement it very efficiently (perhaps with Java?).

Finally, I think this course is fine. And professor Joyner is very responsive. I think you will not regret taking this course.

This is my second OMSCS class overall and also the second with Dr. Joyner after HCI. The course introduces you to AI in general and focuses Knowledge-based AI.

Video lectures

The video lectures were well done. The topics were explained to be understood even by non-CS students and the exercises were mainly fun and could help understand the topics in these lectures. They are also broken down to 2-5 minutes so you don’t feel overwhelmed. Each module can take you between 45-90 minutes if you are doing all the exercises and taking notes. In some parts you may speed up the video to finish faster.

The big issue with the lecture content is, some of them are outdated and not used in the real-world. For example, detecting 3D objects by detecting edges is not used today and instead deep learning is the prominent method for visualization. Cannot say for NLP because I am not as knowledgeable enough.

Assignments

The three assignments were mainly essays of 10 pages, each with four questions. The questions can be either exercises to do based on the video lectures, others ask to read about GDPR and Toronto Declaration, and the rest are “ethical” questions open to argument. As usual, Dr. Joyner’s assignments are a lot of writing so while the question is not difficult, the time needs to express and write in summarized and concise fashion can be challenging, not mentioning that writing essays can be tedious especially on weekends or after long hours of work if you have a job.

My main problem with the assignments is, Dr. Joyner wants to make sure you are “busy” with them rather than the core value and goal of them. For example, third assignment asks you to read, summarize, find the major contributions and possible weaknesses for FOUR papers. Not one, not two, but four. If you know that the papers are heavily AI-related, it can be challenging to find a paper which a novice student can understand and summarize, let alone find the possible weakness or suggested future work. I am not new to such assignments as I enrolled in Dr. Joyner’s HCI course which is similar, yet far more assignments. So for me KBAI assignments were a breeze in comparison.

Project

You have to work on a project, submitted in three parts, aims to solve Raven’s progressive matrices problems. The concept is neat and I was interested in building an AI agent to be able to solve such problems. Until I started working and found out I ended up “coding” to make my agent work without caring about using KBAI methods presented in the lectures because: 1) There is not enough time. 2) The goal is to solve as many problems than how you solve them and 3) The project has NOTHING to do with the lectures. This is frustrating because you feel you are not learning how to do develop and agent using AI methods you are supposedly learning. The other big problem is you are required to use out-of-date libraries in order for your project submission to work online (Bonnie). This is troubling knowing that such versions are not easy to install and students should not suffer with old Python and library versions.

You are also required to write a journal to explain your project’s goal, progress and future improvements. The journal is important to grading your project so it can add to the stress, and yes, it will take 8-12 pages so keep this in mind.

Exams

You have three exams, each after assignment and project submission. The exams ask about the topics discussed in the lectures. They are multiple-choice questions with true/false statements. If you took a course for Dr. Joyner before, you will be used to the exam’s format. The exam is open book so you can open your own notes, revise the lectures and even google for answers.

Participation and Feedback

Same as all Dr. Joyner’s courses, you need particiaption points by giving feedback to students’ homework and project journals and participating in Piazza (ugh). This can be very cumbersome when you realize you need to do that after the lectures, assignments and projects so you’ll be exhausted because you don’t have time to take a break. It also feels very forced to enter a badly-designed forum and “participate.” The feedback can be interesting to know how other students solved some questions and tackled the challenges faced buiding their AI agents and you can get a lot of good ideas. But also reviewing students’ homework and reading the same answers can be really boring. In the end, TAs are paid to do that!

Overall, as all Dr. Joyner’s courses, KBAI is well-organized. The lectures are clear and easy to follow. The assignments are a lot of work and you will be very busy during the course.

• Unclear page count requirements for Journals and unnecessary deductions.
• Deductions for missing margins in "JDF" format seems very picky.
• Lengthy Homework Questions with unclear asks. Makes me wonder how I will be evaluated. Questions could be more straight to the point.
• Some of the homework questions and page count restrictions do not make sense. (Only option was attaching diagrams with reduced font size)
• There is Revise & Reflection points which means you not only have to get your projects working but also need to make multiple submissions over a couple of days.It pains me to think how they have included this as It is not always possible for someone to spend a couple of days in a row for a project. I don't know about others, but if I get 2 full hours on a weekday, that's perfect time management.
• Very unclear participation points that I stopped worrying about it multiple updates on participation points in Canvas. (Its a moving train!)
• 'Substantial' Peer Feedback for 4 people is a lot of work. Each submission has atleast 10 pages. So you would peer feedback for atleast 40 pages every week.
• Usage of outdated libraries is limiting. The only reason for usage of outdated libraries was that "Boonie" could not be updated.
• Verbal approach and visual approach for projects are vastly different. Recommend to start in visual approach! However there is no relation to the course material as visual approach is heuristic based.
• Reading the paper on "using Human computation to acquire Novel methods" felt like a back stab; Is that why we are required to submit over 5 days for Revise & Reflect points. Are our project submissions being used for research for Novel methods? Are we unknowingly part of an experiment? Of Course the 4 people have been credited, but what about the other 220 people; Were they aware their projects was used for a study?

Bottom line: Easy & well organized course material, but the process to earn your credit points is at times extremely difficult & poorly organized.

Too much busy work for not much learning. 10% of the grade for participation is huuuge. Forcing participation points like this results in a contrived conversations/endeavours that have no soul. I'd rather encourage students to participate for the joy of participating not forcefully to rake up freaking points. And writing. Omg ! They explicitly demand a certain number of pages in your assignment. What is this? An english composition course? Might as well start grading by the number of pages. Projects and lecture videos are cool though. This course has potential but needs a make over.

KBAI is a classic Prof. Joyner class - if you liked HCI, then you'll like KBAI. It's also probably a pretty decent introduction to the OMSCS program as well since it has a nice mix of coding, writing, test taking, peer reviewing, etc. with good video lectures worth watching and a free ebook to study from. Overall, KBAI is a very high quality class with both active TA's and an active professor on Piazza.

That being said, for many classmates, the writing assignments (3 in total) and participation grades (80 points in total) were a bit of a struggle, but if you start early and post on Piazza frequently, then they should not be a problem. Some of the writing assignments can get a bit abstract though, discussing the ethical considerations of AI and the ideas of "free will" for example.

The coding projects were mostly done using Python's standard libraries with NumPy and Pillow (important to note that OpenCV was not allowed for image manipulation) to make an AI agent solve visual puzzles for a grade. In total, there were 3 separate projects for development with increasing complexity and difficulty, and each also required a written journal response detailing the development processes and results. The top 10 individuals with the best performing agents after each project received an additional 5% to their final grade (equivalent to a single exam), so my recommendation would be to try to get that in Project 1, which is the easiest, by scoring perfect results (12 out of 12) on the Basic and Test problem sets at a minimum.

The 3 exams themselves were difficult, but not unfair. Each are 1 hour long with 15 multiple choice questions, where multiple answers are correct. The questions can get very technical to really test your understanding of the material. And while the exams are all open notes, videos, and Internet (just no taking it with another person), Googling the questions will not help at all. Instead, my strategy was to watch the lecture videos, which are much better than most of the other OMSCS class videos anyway, and then use the ebook for quick ctrl+F referencing during the exams.

Overall, the class is difficult and can take a decent amount of effort / workload depending on how comfortable you are with writing papers and coding using Python (+ NumPy and Pillow). I took Computer Vision in a previous semester and that helped out a lot, despite not being allowed to use OpenCV. Ultimately though, there is no curve for the class, so to get an A, you need at least a 90%, B you need at least an 80%, etc. However, I was able to comfortably secure an A without too much trouble by closely following the syllabus and assignment due dates. The class is structured for students to do well with enough time in between assignments for very good pacing.

This class focuses on AI and its relation to human cognition, in both directions: thinking about our own reasoning to build AI agents that can learn with minimal data, and comparing AI techniques to understand more about human cognition. This is the "knowledge-based" aspect that many reviewers regard as antiquated. In a sense, I agree. But I still found the topics interesting, and I don't regret taking this class.

I don't have many complaints, but I do wish this class didn't involve so much writing. I ended up writing 53 pages in total (3 homework, 3 projects). That's not too bad, since some of that space is taken up by figures and tables, and the margins are quite wide. But it was still a lot of writing. My biggest complaint is probably that most of the course material is not required for the projects, and while the topics are interesting, it's hard to apply them to code without a little bit of guidance. It's entirely possible to complete the projects without using any concepts from the lessons. The exams are multiple choice and have some tricky wording at times, but are fair. It's worth noting that I'm a native English speaker and I had no trouble understanding the lecturer.

Overall, I enjoyed this class, and I have more positive feelings toward it than negative. The content was interesting to me, despite not being immediately applicable to the projects. I especially liked version spaces and incremental concept learning. The structure of the class was nice and predictable: watch lessons, do homework, do a project, take an exam. Repeat 3x. The class can be completely front-loaded, everything is available right away including the exams. Start with the visual approach for the projects and take a look at the papers you're given to get some ideas. Dr. Joyner was very involved in the course and checked in on Piazza regularly, and offered plenty of opportunities for flexibility due to COVID. If you're looking for a summer class just to get some credits knocked out, I'd recommend Software Analysis & Test over KBAI. It's about equally applicable but overall an easier course, in my opinion. But if you're looking for a course to round out your AI experience, KBAI is worthwhile.

This is a very easy course. Although my AI agent was among the top-scored, I feel I learned nothing much from the project. I should have taken the more challenging AI course instead. For anyone who wants a challenge and really learn something, not just for the sake of credits and grades, I would not recommend this course.

Very well-run class by Joyner and TAs, although the material seemed antiquated and not very useful in real life applications. The projects were fun once you start doing a visual approach, but there was a major disconnect between the lectures and the projects. I did not use any lecture material on the projects and still passed with decent results. There are three homework assignments which are basically 10 page papers with a number of different prompts. Not the worst class I've taken, but also wouldn't recommend it.

I applaud Dr. Joyner for the compassionate way he handled the COVID-19 impact on the student population. It was amazing to see the level of empathy he has for the students. We all know how awesome of an instructor he is already, and it was very nice to see his level of understanding, sincerity, and patience in dealing with students who are going through an unprecedented time.

Now regarding the practical knowledge of the class itself, I am not sure how to relate it to future classes or at work. Learning Pillow APIs, Image Manipulation, etc were good to learn, however, OpenCV has far more applicability than Pillow in my opinion. I also felt the knowledge is too abstract. From a coding perspective, I found it to be pretty easy.

The RPM project was the brightest part. The exams were the least likable part. The exam questions were like parsing grammar and words. Amount of writing in this class is intense. I wrote a total of 65 pages in JDF format for this class. However, I can write quickly so for many of the homework I was able to knock them out over a weekend.

This class has a lot of potential to be far better if it could be re-tweaked to have more coding assignments, add an NLP project, and getting rid of the exams.

Tips:

1. Start with visual approach from P1. Developing a good set of visual heuristics in P1 can help make rest of the project deliverables fairly straightforward with parameter tuning for each problem sets.
2. Learn Affine transformations (from the research paper), DPR, IPR, logical operations (OR, AND, XOR, INVERTED XOR), and connected components labelling. These should be good enough to pass all the tests in the projects.
3. Use numpy for everything.
4. Use overleaf to make JDF super easy to use. Also use lucidcharts or draw.io for diagrams/charts.
5. Also make sure that you have at least 6+ submissions for each project to get continuous improvement grades in the projects.

This is my first OMSCS class and I have mixed feelings with the course. I like the course, but sadly I didn't really learn a lot. I was hoping to get more out of it but maybe it is because of the disconnect between the lectures and the project. I am not a python expert and easing into coding again and given all the projects even if there was a boiler plate, I had no clue on what to do and was walking like a headless chicken. Dr. Joyner helped out on where to find video tutorials and I was able to finally reach out with a TA. Most TAs are not the most responsive, I guess I was too lucky to find one. Classmates were very helpful as well. I have learned a few python here.

I think it would have been better if I have prepared myself before taking this course or maybe I should have taken a course where it piques my interest. I guess I wasn't really interested in Knowledge Based AI. Maybe courses that may help introduce python and explain codes line by line. Overall it is a good class. It's the most organized so far and I am hoping all courses are designed like this.

KBAI was a great first class in OMSCS for me. David Joyner runs a great online education operation. The lectures were of good quality and were all you really needed for the tests. I found I could watch them once or twice and then listen to them in the car a few times in order to study for tests. The projects were challenging enough (for me, anyway, as a relative newbie to Python) and taught me a lot. Like it or not, one thing you learn is why it's incredibly difficult to replicate human intelligence with traditional programming and AI methods, so that's why ML is "winning". But still, I think it's useful to understand KBAI, even if ML is the present and future of AI. Joyner also uses other techniques to try to increase contact between classmates. So you get points for insightful Piazza comments, and for reviewing your classmates' assignments and providing non-trivial feedback to them. I know some people find this annoying but it's useful to see some other peoples' work and learn about how you could improve your approach.

I liked this class but it didn't seem particularly useful in the grand scheme of things.

One major thing that bothered me was the disconnect between the lectures and the project. I know others have mentioned it as well. For me, the project quickly turned into "what's the best score I can get with the least amount of work?". There is not really any incentive to try to implement the lecture material into your project.

Heavy disconnect between lectures and the project. But individually lectures are interesting. Home works are heavy on reading papers and writing.

This is a very good subject if you are new to OMSCS, Programming. It give ample time to learn coding python. This include 30% theory - assignments which include some web browsing, lecture analysis and mostly writing journal like skills. Need to take care of format of the document and proper references is all time requirement. Very interactive class and enthusiastic instructor.

I took this my first semester alongside HCI and it was definitely my favorite of the two!

Course Material (3 tests) The lectures are really interesting and have examples and quizzes throughout to keep your attention. The tests are open note/book/internet and only worth 5% of your grade each so they're pretty low stress. All considered, it feels like they're designed for you to learn throughout the process: the best test design in my opinion.

Homework (3 assignments) The homeworks can be a lot of reading and writing, but there's only 3 of them so you just have to get through them. It could be worse, there's way more of this in a class like HCI.

Project (3 parts) I really enjoyed the projects because they were where you got to practice designing and implementing an agent. You have your pick of java or python; if you don't know where to start, there is more starter code than it seems, just ask around on piazza. The main drawback is that I (and I believe most people) were able to get away without using most of the concepts we learned. There are technically 3 projects but they're really just 3 parts of one, each having you solve different problem sets of Ravens Progressive Matrices.

Project Tips

• There is a decently large writing component, but its honestly not bad if you write it as intended, and even helps you plan more: Write Intro before touching the code, write each journal section immediately after submitting, and conclusion at end. For the first project, I wrote my entire report afterward and it just became tedious, ingenue, and I discovered things while writing that could have helped me.
• Don't try to make your project pass ALL local tests before submitting: allow room for improvement. I tried making all pass before my first submission for the first project and regretted it. It allows for only minimal tweaking as you have to submit a good number of times, and you'll just waste your time.
• Start using the images in the first project: you'll thank yourself down the road.

Participation (peer reviews, piazza, etc) Depending on your piazza activity, this part honestly just sucks. If you want to avoid piazza, you have to do 9 reviews per assignment (3 homeworks + 3 project reports) which can become energy-sucking. Being active on Piazza is honestly just a necessity: for us shy folks, I promise its not as terrible as it seems, just go for it.

I took this course in my first semester along with CP.

Pros:

• This course is easy to get an A.
• There are 3 assignments, 3 projects and 3 exams, you get enough time for each one of them.
• You can front load all assignments and projects

Cons

• A lot of writing, each assignment/project needs a 8-10 page report
• Very theoretical, I did not learn much about AI
• For projects, you do not have to use any concepts taught in the classes

The material went in a bit of a different direction than what I was expecting. I thought it would be, given previous knowledge how would you improve on AI techniques. The course covered mostly the organization of knowledge to be used in algorithms. The course would be a good introduction to NLP or picture interpretation.

The class projects were half written report which was inconvenient. I wish the projects weren't as open so you were forced to explore all the topics in code.

This class was my first and it offered a great primer to the program. 3 projects, 3 homework papers, 3 tests (proctortrack, but open book).

The projects are Ravens Matrices which get more complex over the 3 projects. You can use approaches from the lectures or bake your own. Don't over think it, my best solving routine ended up being the simplest.

The homeworks are 8 page papers. Be sure you answer every question in the rubric. They must follow jdf document standard. I highly recommend using the provided latex template and Overleaf.com (free pro account if you use GT email address). If you don't know latex spend about 20 minutes to learn the basics; it may even help in other courses.

Exams are open book, but do use proctortrack. Unlike many others I had zero issue with it. Exams are relatively low weight on your grade so don't sweat them. I'm a note taker and that was enough just to read over my notes once before each test and make moderately well.

Other grades were participation and performance bonus for top 10 project submissions.

Overall a great course for a first semester, or if you may be disconnected some during the semester. All information for the semester is clearly laid out at the beginning of the semester, so you can work ahead if you like on most of it.

This was an interesting course for sure. There are three projects that each build on each other to solve Ravens Progressive Matrices. Lectures are high quality and interesting, but ultimately most of them weren't super related to the projects.. they are purely for the test. Similar to Human Computer Interaction, it's sort of like an AI class meets a psychology class. Overall, I enjoyed it, but it follows suit with David Joyner's other classes so.. if you like those, you'll like this.

TAKE THIS COURSE IF YOU WANT BREADTH IN AI, TO DO RESEARCH, AND IMPLEMENT AN AGENT FOR VISUAL ANALOGY

This class has a lot of mixed reviews, but it is excellent for anyone that wants to research critical issues in AI, write code, and learn more about where your research interests are in the symbolic AI and cognitive AI subareas. This isn't a deep learning, RL, ML course, so people who expect to come in learning those things are often disappointed. But guess what, you need to know this stuff because deep learning isn't the future. This class is about different subareas which are critical in the broader conversation in AI. You do implement an agent that solves visual analogy problems (as of 2019). It is unlikely that next semester (Spring 2020) there will be an NLP project, as others suggested.

You can front-load projects and assignments. Overall, this is not a difficult class, but there is a good deal of writing both code and completing assignments, which is why I gave it a medium. If you get behind, good luck.

Grading and the Rules

The grading in this course is heavily geared towards "strictly following the rules and the prescribed format".

For example: it requires the use of the JDF format for all reports. This is strictly enforced, with heavy penalties.

If you follow the rules exactly as written, you will do fine.

Exams

There are 3 exams, worth 5% each (15% total), open-book multiple-selection, each focusing on a third of the course, where you will get points for all correctly selected and correctly unselected statements. It covers the course lectures only. It can feel a bit like answering tricky trivia questions on the material.

Projects

There is one big project, split into 3 submissions of increasing complexity over the term, worth 15% each (45% total). For our term, we had to build an agent that is able to visually solve visual IQ puzzles using Python, Numpy, and Pillow only (or Java equivalent).

There are good ways to use the course material to solve this challenge, but that is not required. You will have no guidance here beyond the technical limitations and the theoretical lecture material; implementation is completely open ended and up to you.

Assignments

There are 3 assignments, worth 10% each (30% total), consisting of 4 questions apiece. One question on the course material. Two that are focused on soft topics like ethics, or analysis of papers, or trends in AI regulation. And a final open question about things like popular culture or media coverage.

Participation

10% of the total grade is attributed to participation in peer-reviews, forum discussion, survey participation, etc.

Work Ahead

The course site is public on: http://lucylabs.gatech.edu/kbai/

You may work ahead, but you're also taking a gamble that the material does not change from previous terms.

Opinion

There are two lecturers, one of which has a thick unintelligible accent. The "ebook" is a compilation of the lecture transcripts, with errors. There is room for improvement here.

The material is interesting, but is dwarfed by the performance of Machine / Deep Learning systems; this is a hotly contested topic (though it may be telling that the best performing project made use of a neural network, rather than the classical AI methods taught in the course lectures). The way forward for knowledge based AI in industry may be via a hybrid implementation with Deep Learning methods.

I feel the Project could have used some guidance to relate it to the course material. I was not a fan of the way rules were strictly enforced, but understand the rationale for doing so.

If you like writing papers, this course is for you. If you prefer code implementation, there are better options geared towards that.

This was definitely one of the best classes I have taken. If you think it will be a detailed instruction on how to program an AI, you will probably be disappointed. If you are interested in the conceptual nature of it and are willing to work through some of the coding on your own, you will enjoy it. tests are effectively 75 T/F questions disguised as MC. low % of grade. Most of the course work is some longer, writing based assignments and a longer project that can be programmed in python or java. I don't have a ton of python coding experience, but I was able to pick up enough to do fairly well on the project. would definitely recommend this course.

I'm not sure what the poster is talking about below, I took this class in Fall 2019 as well and it's definitely still about Raven's Progressive Matrices, not chatbots.

Overall, this was solid class with interesting projects. There are 3 homework assignments, 3 projects/reports, and 3 exams. Each assignment involves A LOT of writing (10 pages) so be ready to type.

Otherwise, I thought the content was pretty easy and the projects pretty straightforward. If you have a good handle on numpy, Python, and basic CV, you're all set. Other reviews are pretty accurate in that the lectures don't relate to the projects and the content isn't exactly cutting-edge.

I got a pretty high A without putting in too much work. Definitely the easiest class I've taken so far.

Knowledge Based AI consists of 3 projects, 3 writing assignments and 3 exams.

1. The project involves writing an AI agent that can solve Raven’s Progressive Matrices (RPM), a visual human intelligence test. Students can use either Python w/ PIL or Java. The amount of time students put into this project seemed to vary considerably based on the rigor and approach to the problem, such as reimplementing academic papers on RPM versus just using simple black pixel counting. You can do either a visual or verbal approach. Visual is probably easier since advanced image processing or computer vision techniques are not necessary to do well on the project and verbal cannot be used in the final project.
2. Each writing assignment consists of 4 questions each with each answer requiring 2 pages. The questions target AI ethics, AI in society/culture, applying KBAI lecture material as well as reflecting on academic AI papers. It is best to start thinking about these questions early to get the most learning benefit. I found the writing assignments really fun to research and went down many interesting rabbit holes in the process of doing them, especially on the academic/conference paper questions.
3. The exams consisted of 15 questions with 5 choices with Joyner style grading (effectively making the test 75 questions). Getting As on the test requires watching all the lectures. Notes and lecture transcripts can be referenced during the exams.

Overall, I think this is a good course, though I am unsure how I will apply the knowledge I’ve gained since a lot of the lecture material is very theoretical. Despite the coding project, I don’t think I have a good idea of how I would implement or use much of what was presented. It is a class that offers some flexibility in time you need to commit since everything is available upfront. You can get an A by putting forth average effort, but can also go much deeper if the subject captures you and aim for exemplary designations and bonus points for going above and beyond.

I was personally not a fan of this course. I came into it thinking I was going to learn a lot about AI, but ended up wasting my time writing tedious reports and doing busy work i.e. reading articles and answering open ended questions about them. If thats something you're interested in then this is the class for you. If you want to actually learn about AI then I'd avoid this class

This should not be a CS class, it is a humanities class with some aspects of CS. I did not learn anything from taking this course. You will be made to write long reports on pointless philosophical stuff. The lectures are pretty abstract and do not go into the depth of any topic. The homework and projects are almost completely unrelated to the lectures. The only positive about this course is that it is very easy to get an A.

My expectation from this course was to learn how to create intelligent AI agents. This course turned out to be completely useless in this regard.

I love this subject area, and more broadly the areas of Philosophy of Mind, Cognitive Science, and learning AI, so I found this class to be a lot of fun. I agree with other reviewers saying that you aren't necessarily going to leave this class with a bunch of code that you can copy-paste into your robot butler, but like, that's just not the point of this course. This is a survey course designed to familiarize students with the high-level concepts being explored in a huge variety of ways within the knowledge-based school of AI. I will concede that the course could have used more practical implementation examples to help solidify how you'd actually apply the concepts, but what I took away is that there are lots and lots of ways to implement the concepts we discussed. I think that's the main point: this class doesn't teach algorithms, it teaches high-level approaches to problems that can be realized through a number of different algorithms. So go into it with that understanding.

This class felt like it had two, almost separate components.

The lectures, homework, and exams were very theoretical. They covered many interesting topics of AI learning. As others have said, the homework was very time consuming. I did enjoying doing the homework. The grading rubric is very literal, I always started each homework with an outline of each question and what was required. Unfortunately after I figured out this formula, I realized I was able to bullshit and still get nearly perfect scores.

The project to solve Raven's Progressive Matricies felt disconnected from the lectures. It was still very fun and challenging, but I ended up using conecpts from computer vision and machine learning which were outside the scope of this class. Be prepared to do a lot of self learning to complete it.

I really enjoyed the peer review system, although about halfway through the semester I had maxed out my review score and didn't give any other reviews.

Good course and lecture material. Lecturers were engaged with the students via Piazza.

I made an account here just to write to a review for this subject! I took this course in Fall 2019 after they updated it last year and it has just gotten worse. Now the aim of the projects is to make a chatbot that answer questions about the class. No more Raven's matrices. Also don't get exicted about the chatbot. You won't use and NLP, neural nets, semantic nets or any cutting edge language AI.

Even if you want an easy A don't take this class. GT is a top ten CS school. There are much better classes offered here which are tougher but actually useful.

Course lectures cover a huge swath of techniques for storing and accessing knowledge in efficient ways. I found these lectures interesting and thought provoking. The lectures were pertinent to some strategies for approaching projects, The lectures do not give you an algorithm to work from though, more a rough description of what a technique might look like. 1/3 of the HW questions, and the exams. I think that the project was good, but I think the paths for working through it to a passing level might be a little too well trodden. The course is very writing heavy, the minimum amount of writing required for full credit is ~42 pages, the maximum maximum is 69 pages. If you're not strong in English, or words do not come to you naturally, this class might be one to avoid. There's enough questions that I found exceeding the page count was more of a problem than going under. Some may benefit from CV, CP before taking this course.

This was a pretty good course! I had just taken AI which was pretty intense but wasn't always engaging. This class really got me thinking about making really Intelligent systems, not just clever algorithms for solving simple tricks.

The professors do a great job of presenting the information. The assignments weren't too difficult but required some thinking. The project was interesting and so I didn't mind devoting quite a bit of time to get it working. A knowledge of numpy will serve you well for the Raven's Progressive Matrices.

The final was pretty intense, as you have to do a pretty thorough write up. I scored very well on it, so maybe I went a little overboard and it really isn't as intense as I thought it was. But as a rule, the more effort you put into making things clear and easy to read/understand, you will be rewarded for it.

(I took this in Fall 2018, but this website isn't letting me select that!) This course was fine. I appreciate Dr. Joyner's general approach to ed tech. He's great. The lectures were so abstract that it was hard to follow. The project seemed very detached from the lecture material; we had only the vaguest guidance on how to connect the two. I felt that I had to teach myself and be extra resourceful to be successful with the project. The exams were mostly rote memorization; I didn't love them. Piazza was quite active.

tl;dr: Amazing course, well presented, effective teaching, interesting project!

Only three homework/papers written, but six peer review assignments. Excellent way to focus on exploring interesting areas of the material. Loved how students had freedom to choose which topic(s) they wanted to explore. Peer reviews were great way to have students review other papers, learn how to review other topics, see examples of writing from peers, and judge their work against others.

Project(s) were to explore Ravens Progressive Matrices, an IQ test based upon images. Challenging as I had avoided graphics much of my career, and students were not allowed to use advanced image processing features. Forced to be creative, and consider how humans examine images and find similarities. I interviewed over 20 colleagues to learn how they approached RPM, and incorporated some of their strategies into my agent. I loved how the projects revisited the same problem as we learned and applied more AI techniques and refined our approaches.

The review of peer student papers and projects has been unique so far in the program (9 courses completed), and one of the most effective techniques for teaching/learning.

Final exam was take-home, open book, open notes. Enabled student to really explore material and explain what they learned.

I would suggest that a student delay taking KBAI until they have completed 1-2 courses and adjusted to the program. They will gain more benefit from the course as a result.

As others have mentioned, there is a good bit of writing for this course. The topics are partly philosophical and partly on the lecture material, but overall the prompts feel "squishy" and subjective. There is a project writeup portion where you can discuss your code implementation in practical terms, but even there you have to add interpretations of "how your agent relates to human cognition".

I strongly disliked the RPM project and that killed my motivation for the course. At least in other courses where you have various projects, there is probably one that you end up liking, but with KBAI, you have to grind away at the same problem without learning any useful techniques from the lectures. I signed up for this course hoping to work on a chatbot, but that project was only offered for one semester and apparently it did not go well enough to continue supporting.

If you like psychology, then you'll probably like the lectures. I'm sure the course creators spent a lot of time consolidating the material into the lectures, but it's a very high level introduction to a lot of different ideas. Having finished the course, I don't really know that I learned much.

Though Dr. Joyner is engaged on Piazza, there isn't an avenue to discuss the course material, which means that if you have questions about the lectures, you better hope that one of your class peers can explain it. The syllabus lists a Slack channel for office hours, but none of the teaching staff or TAs answered any questions posted to that channel during the entire semester. There are two instructors for this course, but one disappeared towards the end of the course, maybe due to health reasons, and the course structure deteriorated a bit.

I dislike the grading process. Dr. Joyner does not like to release the grading rubric and I found that the feedback I received wasn't useful or explanatory. Also, make sure to keep submitting project attempts to Bonnie, even after you have a passing grade. Points are deducted if you don't keep trying to improve your score and you haven't made very many attempts.

Clearly some people love this course, but it did not match my expectations based on other courses in this program.

I do not like this course because I feel I learned nothing. The lecture is very high-level, which keeps talking about some obvious things and skip technical details for each topic.

We had 3 writing assignments and each is about 10 pages. The homework asks weird questions (e.g. to summarize paper/political document/news).

We had 3 exams throughout the semester and they are open book. The content is related to lectures and each exam has 15 multiple selection questions. It is not difficult to get an average score if using ctrl+f to search in the book, but it is still challenging to get a high score.

We had 3 projects to solve Raven's Matrix Problems. This is the only component that I feel is interesting in this course. An AI agent needs to be designed to solve the problems given and either Java or Python can be used. The grade of projects is based on three components, the best performance of your agent, the effort in making progress of your agent, and the report. I feel this kind of rubric is very reasonable.

Overall, if you like high-level discussions about AI topics and if you are ok with a lot of writings, then this might be a good course for you.

A lot of busy work and the lectures feel pretty disconnected from the project. That said, the project is kind of fun.

Be prepared for a good amount of writing!

This course goes over artificial intelligence and the techniques used to design it. The course has 3 HWs (with multiple sections), 3 Projects, and 3 Exams. The workload is easy to manage and it is very easy to work ahead if you need to.

Pros:

1. easy to work ahead
2. very interesting information
3. some programming but not ONLY programming

Cons:

1. you don't actually get to build real AI systems

Needed knowledge:

1. either Java or Python

Highly recommend this course for a first or early course.

To see my full review on the course, check out my youtube channel: https://www.youtube.com/watch?v=wqOIhHa8TbI

Knowledge-Based AI is probably the most well structured OMSCS course that I have taken so far. You can front-load all of your work. The TAs are very involved and Dr. Joyner is the most active instructor I've met so far. There were numerous cases where students requested more time for projects and were actually granted it!

The quality and interest of lectures is pretty great, as are the exercises and questions they pose. However, there is definitely some hand-waviness to them as some of the deeper concepts are not fully explained to the level I would expect in a CS Masters.

Homeworks are easy points and attempt to quiz you on material from the lectures. In reality, they are just long writing assignments. I consider them to be busy work as I've learned very little besides some ethical points of view on AI. I recommend banging them out in a day or two and spending time getting ahead on the projects. I was able to do this and get a 20/20 on 2/3 homeworks. (homework 3 grade is still tbd at this point in time)

Tests are easy and open notes. You will have no problem getting a decent grade on them, and I don't even think you really need to study. Just watch the lectures, take some notes, and you'll be fine.

Projects are based on Raven's Progressive Matrices, a visual human intelligence test. Never has there been a larger disconnect between course lectures and application of that material. You will apply exactly 0 of the lectures to the project. Instead, you will spend 90% of your time doing visual processing, so get comfortable with numpy. (And forget PIL, PIL sucks) Try as much as possible to use vectorized operations instead of going pixel by pixel so that your performance doesn't suffer. There were many students who did not apply the visual approach until Project 3, and they struggled a LOT! Also, do yourself a favor and read the relevant sections of the ASTI model of solving these matrices. It will pretty much guarantee you will meet the performance requirements of the first two projects using the visual approach.

My biggest complaint with the course is that literally none of the lectures will apply to the projects you work on. I want to give this course a higher rating, but I know that in a month, most of the material I have learned will be forgotten because I never got to apply it. I cannot forgive that, and all I can really say is that I have a faux-intelligent RPM solver with a lot of overfitted if-else conditions and a bunch of useless notes at the end of the day!

I would not even care to write a full review on this course.

KBAI is an absolutely useless course, which does not provide any kind of knowledge, practical, or theoretical, not even philosophical, at all. Concepts are hand-wavy gibberish, assignments are 10-page essays on ethical and legal topics not related to CS, projects are only good, if you like writing 1000+ line if-then apps. This course is like an undergrad course for philosophy majors with occasional elementary programming problem, not related to taught material.

Only take this course, if you need an easy A or a pair for a hard one. It is not even good for the latter purpose, as it requires writing those huge meaningless assays, excuse my French.

Quite frankly, this course feels more like an undergraduate sophomore level CS course, not a graduate course at a top 10 CS masters program. You'll have the opportunity to tackle a fun project, but you likely won't really learn anything useful.

Pros

• The project is a 3 part project where you solve Raven's Progressive Matrices). It's pretty interesting and fun. You have a lot of freedom to solve the problem however you want and you can build on your previous work in the later projects.
• The class is well run. TAs and the professor are reasonably active on Piazza* and seem to care about creating a positive experience.
• If you're into ethical AI dilemmas or thought experiments involving AI, the homework problems can be quite interesting.
• The exams are not difficult - they basically require that you watched the lecture and took organized notes.

Cons

• The lecture material is way to high level to be useful. Literally every lecture would ask "how can we get an agent to do X" and then fail to answer the question. For example, the question that asked "how could we get an agent to understand a sentence?" talked a lot about a specific framework that can be used to more meaningfully store sentences, but said diddly-squat about how you would actually get the agent to recognize different parts of the sentence to actually build the representation.
• (*) The course staff tends to ignore questions about actual course material. I don't think I've seen an instructor response to any questions that ask deeper questions about course material. They also tend to ignore good faith questions about the course management process or ways to improve the course.
• If you're not into ethical AI dilemmas or thought experiments involving AI, the homework problems will be tedious.
• It's really easy to "game" the project if you find the right resources on google.

If you're looking for a reasonably easy course that will give you some food for thought (or if you're looking for a busywork class that you can get an easy A in), you may enjoy this class. However, if you're looking for a course that will teach you something about AI, I would recommend giving this class a miss.

In short, this class doesn't teach anything useful outside of solving toy problems. The real world isn't a 3x3 grid of shapes with 8 answers. I'd much rather take a class on Probabilistic Graphical Models, Bayesian Statistics, Deep Learning, Natural Language Processing, or any other topic that has applications to the real world. If you agree with my sentiment, stay away from this course.

The lectures are devoid of substance; they basically consist of defining terms that are never used for anything useful. Here's an example of what you can expect from the lectures:

Lecture: Abduction means given a rule and an effect, abduce a cause.

Me: Okay, great, how can we use this 'abduction' to solve the problem at hand? What algorithm can we apply? This is a CS course afterall.

Lecture ends

The homework assignments are essentially busy work (lots of writing) with no return on investment. The project (IMO) doesn't leverage any of the course material. In fact, I'd wager that you'd be worse off if you tried to apply the course material (somehow) to the project, as opposed to just implementing a paper that describes a visual-based algorithm.

The exam questions focus on how well you understood their esoteric AI terminology that isn't used anywhere else outside of the course.

To end on a positive note, Dr. Joyner is an enthusiastic professor who actively participates on Piazza. If he freshens up or modernizes the material then perhaps KBAI can be salvaged.

This is a perfect class. You learn a lot, the project is great, the lectures are solid and it's fun.

I did 2/3 of the class before it started because I had 2 weeks off and they upload everything online pretty early.

Python or Java are needed to do the projects. Some computer vision could help but is not necessary.

I heeded advice of a previous poster to keep it simple on the projects. You don't have to do things perfectly to get an A.

Homeworks are "easy" in that you can do well with effort alone. They are long, however. 10 pages of essay work that often took me about 8 hours.

Exams are all based on lectures and studious watching/note-taking are all that's needed to get high grades on them.

Like all of Dr. Joyner's classes, there is good use of Piazza.

I'm never a big fan of the peer review process, but it's not that much work.

It was my first course in the program along with RL. All the concepts you learn are very applicable if you happen to design an AI system. But, the course gives all the information at the surface level. You will need to google up for more details on the topics covered. The class has 3 Homeworks, 3 Projects and 3 Exams. The Homeworks are document-writeups on either recent trends in AI and questions framed from the lecture. For projects, we had Raven's Matrices, but I heard they are experimenting with other projects. The Homeworks and Projects are tedious but give you a new angle for thinking than the usual implementation thought process. Overall, liked the class, learned​ a lot of new things but, ended up hungry for deep info.

Great course... if it's what you're looking for

This is like taking a philosophy course that also has a programming component.

Do you want coursework that will let you go into your office and solve all sorts of new problems because of what you learned? If yes, then you should look elsewhere.

But if spending 20 minutes pondering whether or not an anthill is conscious and then another 20 minutes writing half a page on your thoughts sounds interesting to you, then you will really enjoy this course.

Course Quality

This course is amazingly well run. It is clear that a lot of time was spent putting together thoughtful lectures that built on each other and introduced complex topics in a way that makes them seem easy.

Side note: I feel like many of the complaints are that this course is too "easy" and not "graduate-level" work, but I'm sure that worse instructors could make the topics seem very difficult. That is what smart, thoughtful people do, they make complicated things easy to understand.

Homeworks

You will have to write. You will write a lot. Are some of the questions busywork-ish? Yes. But if you've got the time to put thought into the questions, most are as interesting as you want to make them.

Exams

These are kind of, meh. I mean, they have to make sure you've watched the lectures, so if you've watched all the lectures and can ctrl+f through a pdf, it's nothing to stress about.

Projects

Solving the Ravens Progressive Matrices was a really enjoyable series of challenges, and each project builds on the previous one. Like another reviewer said, if you go visual for the first project, you can save yourself a world of pain for project 2 and 3.

Overall

If you take this course simply because it looks easy on OMSCentral and you want to churn through some credit hours, then you can, but everything will feel like pointless busywork and you'll hate it (but hey, you'll have only spent 6 hours/week and gotten a B and are 3 credit hours closer to a degree).

However, if you don't mind stopping and smelling the roses for a bit instead of just churning out lines of code, then you could have a really nice time in this course.

The content of this course just isn't relevant to anything I can imagine working on outside of academia. Some may find it interesting, but at a practical level any of the other AI/ML courses offered are far more likely to give you what you're looking for if you're at all like me.

Useless Crap

This class is a waste of time and money. It is a scourge on the earth, and an affront to human intelligence. There must a place in hell where people have to take this class over and over again. I only took it because I have to graduate soon, and don't have many classes left to choose from. I got a B.

The class is a mishmash of topics. Videos teach a topic that has zero real-world applicability. Projects are primarily image-processing based. Homework is a combination of lecture content questions and ethics. I like ethics when it's taught properly. I took a class on ethics in college and loved it. The way this class forces students to think about ethics makes me hate it.

This course tries to do too many different things and does none of that well. On top of that, the last homework solicits homework and project question ideas from students. Sigh, is this a crowd-sourced class? No wonder it's so bad. It's awful. Don't take it if you can avoid it.

If you must take this class, know this: max out your word limit to get full points on your homework and projects.

Any less, and TAs will complain that you didn't go into depth and take off an arbitrary amount of points.

This was my first and favorite class. The material was interesting, and the projects challenging. I loved the open-ended nature of the projects. The written assignments prompted me to think of some projects that were interesting enough to put on my for-real implementation backlog.

Pros:

• NO GROUP PROJECT. This already raises this class two letter grades in my book.
• The projects are exposed so you can work early! I forget if the assignments were as well but I feel like yes. Can work ahead, woohoo!
• Some of the assignment questions were fun.
• The project was fun. You could brute-force your way to victory if you didn't actually have time for Grad School (this was my situation as I was working and taking another class), or you can really apply what you learn and try to do interesting things. This seems like a pipe dream to me in this program. There are other assignments and tests and life so I felt that I had no time for that, but some people did really cool things.

Cons:

• This is a cognitive science class with some computer science mixed in. Other than the project, you will not be doing any programming. Only writing and writing about theories of the mind and AI. If that's your thing, cool. If not, you're gonna tear out your hair answering questions like "what is an example of a good\evil AI in media?" Like... really? What is the point of this question?
• The assignments are really time consuming.
• There are tests... ugh.

Overall, it's a required class for some specialties so no choice, but also did I mention NO GROUP PROJECT?

Joyner is a fantastic professor, and the the material is really interesting. The topics can be somewhat loosely defined and don't always connect well to the projects, but you'll still learn a lot. Definitely one of the better-managed classes, with clear timelines, responsive TAs, and incredible breakdowns of the exams.

KBAI (as it is called), is a very fun course and I learned a lot. Prof. Joyner, and Prof. Goel are amazing, and work well together. The course is also laid out very well. I did find the course very 'heavy' though. I took it in Spring 2019, and it had 3 exams, 3 assignments and 3 exams. The project are all cumulative and involve solving via AI the famous Raven's Progressive Matrix. I enjoyed this part of it, as it forces (literally) you to learn Python, however, it is just a a very time consuming class. Not recommended for your first class.

Overall, a decent course. It covers a lot of material. Don't expect to take away "practical" knowledge as most of the stuff taught are very generic and abstract concepts about intelligence and representation, extraction, understanding of information/knowledge.

The course has 3 exams - which is good pacing because there are just too many concepts to learn and it would be difficult if these were to be crammed for just 2 exams. No additional reading required for the exams. But, you need to properly understand the lecture material. You can't get away using just ctrl-f to search for stuff and answer the questions... (these are open-everything tests)

The tests were fine, but I wish they were more "application" oriented - meaning, it would have been better if the questions asked how concept x can be used to solve problem p or something like that.

The homeworks were the most interesting part of the course for me. Lots of interesting questions to be answered.

I hated the supposedly popular "raven's matrices" projects. The aim is to build an agent to solve intelligence test problems - probably using the concepts taught in the class, but I did not feel like I learned anything by doing these projects (even though my agent got pretty good scores). The methods I (and probably most of the students) used are nowhere near how humans think about solving these problems and for me, it was just "use and do whatever" to get the highest possible score so I don't really understand the point of this project... I think the NLP related chatbot would have been a better option, but that was not offered as a choice in my semester.

I found KBAI to be an interesting course. Dr. Joyner and team have been good at returning grades in a timely manner and progress on participation points throughout the semester.

I found myself working on the projects last minute, which is a bad idea (but that's just who I am, and I'm working on that!), but I found the projects interesting nonetheless. I didn't find any use for the lecture videos in the projects, though each of the 3 homework assignments touched on the lectures for one question each. The rest of the questions in each homework were thought provoking and I loved peer reviewing other peoples' thoughts on the same question.

I definitely had a hard start in the beginning, as I was moving into a new apartment, so I would recommend not having too many outside-of-your-degree distractions while you work. I took CS 6400 alongside this course and found both classes manageable for the semester.

This is my first course and I loved it, mostly because of my interest in this subject and the project.

Prerequisites in my opinion,

1. You need an interest in AI more specifically human-like or general purpose AI, else you might get frustrated soon.
2. All 3 projects will run fast, you really need to be comfortable with Python(Numpy) or Java.
3. If you have not taken CV already you might need to quickly read some paper and be able to implement them. But this should be perfectly fine as long as you are comfortable with the chosen language.
4. You really need to surf a lot online to do the 3 assignments. Like, read very fast, summarize and present the ideas in 2 pages along with your own opinion.
5. You should be able to take brilliant notes and keep them handy for the exams. The 3 exams are the weirdest I've ever taken. Good understanding of the concepts taught in the lecture is a must to crack the exams.

What I liked?

Definitely, I liked the theories that were taught in this course. It is a fuel to your thoughts and imagination, you will learn concepts that you can apply to any AI problem, the problem is it will NOT be as easy as it sounds and you might feel they are too abstract.
The project is interesting, you will most probably enjoy the project itself with the journals and peer reviews. On the other side, they don't necessarily relate to the theories you learn in this class. You can use them for the project but eventually, you will find easier ways to get the agent working that will drive you away from the course materials.

If you want to get an A, you can do it with minimal work. I did more just because I am interested in this track.

This was my first course, and I enjoyed it. More theory than practical/technical than I would have liked, but my main goal was just to test how I could balance a easy/medium difficult class for the start of my grad school career with the rest of my life.

Full disclaimer, my goal was to put in the minimum amount of work necessary to get an A. The number of hours per week was about 6, but that's an average, there were definitely weeks where I put in 0 hours, and the week before a project was due I would put in >6. It's very much a 'get out what you put in' type of class. There's tons of optional readings that I'm sure are interesting if I decided to read them.

So the wide variance in #of hours people put in is because of the projects. The projects are as hard as you want them to be. If you want to fine tune your AI agent's performance, try lots of different techniques, read a bunch of technical papers and try the algorithms explained there, go right ahead. You'll probably learn a lot more than I did and have fun doing it.

But DO NOT believe the reviews that complain how time intensive they are. The bar for getting an A on these projects is very low. You don't need to be a python wizard. You don't need to be a numpy wizard (I had never used it before. I barely can say I know anything about it now). You don't need to use any fancy algorithms. I implemented the dumbest thing possible to get the bare minimum results necessary to get full points. And since the projects build on each other, I just had to tweak them slightly to get those results for each subsequent project. And for a graduate class full of current/aspiring software engineers/technologists, I was shocked how many did not understand how to KISS (keep it simple, stupid).

Do yourself a favor if you're trying to save time and start with a visual approach from project 1. It'll make your life a lot easier by the time you get to project 2 and 3, and it's honestly quicker to solve the problems than the verbal approach, albeit a bit more intimidating/more upfront work/learning.

And for those reviews complaining about the exams. Personally I thought they were pretty easy. But even so, they're worth so little of your grade that you can fail them and still get an A in the course.

This was my first OMSCS course, and it was a good introduction to what kind of expectations are required from you in the whole OMSCS. It's a gentle ramp-up, and since it's a medium difficulty course, you can gauge what type of effort will be required for the more harder courses in the future.

There are 3 homework assignments, 3 proctored exams, and 3 projects. Projects have more weight, followed by exams and homework. Homeworks and projects require a lot of writing. 50% of the project grades are dedicated to the journal, where you explain your thought process behind the code you submit. Homework is fully written assignments, so be prepared to write a lot.

There are grade points for participation as well (posting on Piazza, doing peer feedbacks, etc.). Very easy to get if you log in once a day to Piazza and take 2 mins answering very easy questions some classmates might put up. Also, peer feedback can be fun. Reading approaches to projects your classmates have used might end up being helpful, but do not rely on you getting good feedbacks. Most of the time, people just copy paste "Great job" to every feedback and you can do the same.

TAs and Dr.Joyner (the professor) are really helpful and participate in piazza very frequently. It's also easy to get an A in this class. I did all my assignments the weekend before the submission date (one long night per alternate week) and could complete all of the work a few hours before the deadline. It's very easy to frontload the work (you should especially do that with projects). Exams were open-book and comparatively easy to score.

The only problem is this course is very theory-centric. It teaches abstract concepts about AI which might not help you at any point in the future or offer any good insight into the current world of AI development. The project is unrelated to the coursework and requires you to build logic around solving problems rather than an AI-like approach towards problem-solving.

Overall a great course. A very theory focused, but slightly enjoyable course nonetheless.

The course had three main components:

1. Video lectures: They were 30 minutes to 1 hour long and generally informative and entertaining. I recommend taking detailed notes because the exams basically test exact wording and can be very tricky.

2. Homework. Three homework assignments of ~10 pages each. I would say these are the least fun things in the course. Some questions allow for some creative and fun responses, and some include valuable review of course topics, but there are too many about AI ethics and unrelated stuff. The formatting required is also a little annoying (though not difficult because of the provided template). The difficulty is not high, it just takes a while.

3. The project. This required designing a program to solve Raven's Progressive Matrices. You can choose Java or python, and you can use a verbal or visual approach for the first two project submissions, and only visual for the last one. I HIGHLY recommend using python and a visual approach from the start. This is the biggest time sink, though it's pretty engaging. If you're a whiz and choose a good implementation, you might have a good enough solution halfway through the course and be able to take it easier later.

This was my first OMSCS course, and I came into it with only C++ experience and no python, numpy, or AI knowledge, and I was able to do fine. I took this course alone (but with a fulltime job), but I was never pressed for time. Assignment due dates are spread out, and you can work ahead if you have a trip or something. I would be perfectly content if all OMSCE courses were like this one.

If you enjoy english and/or psychology classes you might enjoy this class. Otherwise consider AI4R or CP which are similar programming wise. Dislikes: Programming logs/reports (30 pages) , written homework assigments (30 pages total), written peer feedback (40 assignments, read and write meaningful comments without knowledge of correct answers), proctored exams (scores weeks later, with no feedback on what you missed), piazza points (spamming and trolling at maximum), convoluted lectures on psychology with a sprinkling of computer science.

Overall, this course was really good. The lectures were informative and interesting and the projects while challenging, provided a lot of insight and depth. There were exams for this course that use ProctorTrack and they proved to be more listen to the lectures and spew back information. You can however use any notes you've taken for these exams. The projects are broken into core parts that all build off of each other. The goal is to solve raven's progressive matrix problem. If you take this course, take my suggestion and theirs and solve based on images from the start (not the descriptions). Doing so will save you a lot of rework time in the future. The course also heavily uses PeerFeedback, a tool to review papers from others students. Throughout the course your project papers and general homework papers will go on here to be reviewed by other students. I rather enjoyed the papers and the project papers as well as reading and reviewing others' work. Overall I really liked this course, the format, and the projects. Could live without the exams because in all reality, exams are just professors way of "making sure you watch the lectures."

This review is actually for spring of 2019

General review

The course is interesting. It goes over different areas of knowledge based AI. A lot of what is seen in the course is not used too much in the industry, but you can draw many relationships between the course material and other areas such as ML (at a really high level). You can really do the course in any order that you want. The course consists of a breadth and a depth component.

## Breadth component

Each lecture explains a different concept of KBAI. At the beginning of the course, there's a lot of relations between the content, but it starts to drop as you go further in the lectures. The 3 homeworks consist of 4 questions, one or two of them will be directly related to the lectures. The other will ask you to write. Be ready to write and read a lot. In the whole semester I've written around 18K words. Each homework will be 8-10 pages long. Some of them are interesting questions that connect general aspects of AI with society and ethical issues.

## Depth component

There are 3 projects which focus in solving Ravens Progressive Matrices. When watching the lectures, you can see how you can connect the concepts from the lectures with RPMs. In the practice, there are simpler ways of solving the problems (like using simple heuristics) that have decent performance. Some people program thousands of lines in this course, but this is not a programming intensive course. To be fair, I wrote <100 lines for each of the projects.

# Workload I did an explanation of the workload:

Course content - 25 hours

3 projects - 15 hours each - 45

3 homeworks - 15 hours each - 45

Peer feedback and participation- 10 hours

3 exams (including prep.) - 10 hours

Total time: 8 hours aprox. You should probably estimate a bit higher. There are a lot of optional readings so this number can go a lot higher. You make what you want from this course. The material is not too hard. The tests are a bit tricky because of the wording, but the average is quite high.

I do not know why average workload from history review only 13hours/week. (That the reason I choose this class and it seem like a mistake). For newbie in AI field like me, I spent a lot of time on this class. This class is not difficulty but a lot of assignments. 3 homework (10 pages per homework), 3 projects include journal writing, 3 exams. To finish assignments, you have to spend a lot of time.

Unlucky, I was very busy with my work and family this semester too. I did finish most assignments but the performance is not good. Prof is not active frequently. TA answered most question on behalf of prof, sometimes I did not know exactly prof post or TA post the answer. However, very slow response from TA at the end of semester.

• 3 homework: each homework have 4 long questions, require a lot of researching, reading a lot of papers, write a 8-10 pages paper. Be careful with format paper and citation.

• 3 projects: The project is solving Raven Progressive Matrices problems. Not too difficulty, but require deep programming skill to optimize the source code. If you select python, be sure you are master of numpy. You have to submit multiple times with different approach. You have to write a journal for each project, at least 5 pages.

The biggest issue I got at the last day of project 3 due date. It is too late. They used auto-grader called Bonnie to grade your project. I used python and did calculation at bit level (using a lot of loop 2d array). That is a very big mistake. Bonnie is very slow with bit calculation. I found out at the last day of project 3 due day when I submitted my agent. It took 42 minutes to run at my laptop but ran forever after I submitted to Bonnie.

I wished I know this issue before. TA and prof did not tell you anything about the optimization. That the reason why I wrote review here. If you select this class, you have to consider this issue. You should master numpy. Do not use bit level calculation.

• 3 exams: the exams only cover the lectures. But you need to understand deeply. if you are the newbie in AI, maybe you cannot get high score. The answers for questions are much similar. Some answer sound like True but it actually False. It is very abstract.

• You have to did 6 peer review for 3 homework and 3 project journals to earn participation grade. Each review requires 4 papers at least. So total you could read 3x4x10 + 3x4x5 = 180 pages at least for review.

The exam/homework/project are not relevant. Student can get high grade in project but may be get low grade in exam.

This class is excellent, when it is a good fit for you and your interests. As someone who is very interested in AI, I found this class to be spot on for helping to further introduce me to the field. They discuss cognitive architectures and do a great of of helping you to understand how they work and what they focus on.

The projects build off of themselves so you can continue to improve your approach throughout the semester. This was my favorite part of the course. By the end, I felt like I had built something to be proud of but this came with a large, but sporadic, time commitment.

It was my first course in the program so a large part of my learning was around how to work more efficiently. I highly recommend this as a first course, especially if you are interested in true AI.

The TA's and professor were fantastic and made it feel like a community. Class participation is 10% of your grade, but it is easy to obtain points.

Overall I'm very happy that I took this course!

This course was a total waste of time. The course content is not at all relevant/updated and still teaches very abstract AI topics which cannot be used/build upon today. There is a lot of writing work (3 homeworks - 10 pages each) which is boring and pointless. The only bearable things are the programming assignments which ask you to solve RPM problems. Overall, I would not recommend taking this course at all.

This class helped me get into understanding very basics of creating a program that can to a degree understand context and think for itself. The lectures were completely useless and not helpful at all for someone who has no background in ML/AI. Lectures were very high-level and interesting but did not go over any implementation or guidelines for what should be done in the projects (which is majority of your grade). There were 3-4 other written essays that were somewhat relevant to what was taught in lectures (easily BS-able). Good class if you have a basic understanding of ML/AI.

This is hard for people weak or not so strong programming background in Python or Java. For software ninja's this will be medium to easy. I end up dropping it because I graduated a Python CS class, been coding for 3 years and still was not able to use PILLOW library and create a program that compares graphics and selects a pattern. You need to have your data structures, data patterns, problem solving skills in check for this subject and probably to a lot of OMSCS subjects

I'm writing this almost a year later.

I've several years of experience with Java but had no prior experience with Python or AI/ML/NLP.

This was my first OMSCS course and it was nothing short of an amazing learning experience. Professor Goyal was amazing and very engaged as an instructor.

KBAI is more of a classical view of AI, unlike the AI that is heavily reliant on humungous amounts of data. The projects involved solving Raven's Progressive Matrices increasing in difficulty. There was also peer-peer evaluation of the assignments (only the report parts) which gave a chance to view others approach towards the same assignments.

There was an option to opt for an NLP based alternate project instead of continuing with the RPM project. It was about implementing a chatbot agent that could answer course related queries. I had opted for this. The course officially did not cover NLP in the lectures and we had to do our own research on it.

Another really interesting aspect of this class: few of the TAs were actually chatbot agents! The class itself was also an ongoing research on AI by Dr. Goyal. For more on this see https://www.youtube.com/watch?v=WbCguICyfTA

The grading was curved and I ended up with a low A.

TAs did a commendable job. Overall this was a very well managed class.

This used to be an easier class, but like everything on omscentral the Professors are using this site as a way to gauge what courses to make more difficult each semester. I took the Fall 2018 course but the menu is not letting me select that semester as an option. The course is very informative and well run, but you will do a lot of writing and you are not allowed to rewrite anything, and the tests are designed to trick you so studying is rather pointless; just guess and pray.

I will have to retake the entire semester because one of my essays was not well written as I was so busy with another very hard class, I dropped the other class but it was already too late. Just take one class at a time at GAtech, even courses like this one that are not initially hard will be revamped until you start bleeding. I really liked the material but the grading has nothing to do with how much you have learned.

No curve(anymore), no regrades(anymore) and the extra credit required you to have the top results in class, so unless you're already a python wiz you won't get that either. I am so burnt out and cannot wait to finish this degree, but it's my fault I was really trying to learn and grow before I took this class. Not at GAtech, just pass the autograder; like in highschool that's all that matters is a grade. Do your research and real learning elsewhere.

Instruction The course content was interesting. The lectures are some of the best in OMSCS. There's plenty of supporting content and recommended texts if you want to learn more about a particular topic. TAs are awesome. Joyner is awesome. Piazza is active.

Homework 3 writing assignments that cover a mix of concepts, applying the concepts, and ethics in AI/ML. Can work ahead and knock these out early which is nice.

Exams 3 exams which cover concept definitions, applied examples, and details about specific concepts. Very much a Joyner exam if you've taken one of his courses before. Open everything with a 1 hour time limit. No curve.

Projects You build an AI agent that can solve Raven's matrices problems (intelligence test problems). The project is broken into three phases, and you submit your agent along with a reflection/write up through the semester. The project was interesting, but I didn't change my agent's strategy after the first submission. I recommended taking the visual approach from the start. It's a little more work up front, but you have to use the visual approach on the third phase of the project.

Future iterations might have a different project focused on NLP. Would love to see that.

Pre-reqs You don't need a ton of background to do well in the course. Some experience programming in Python or Java will help. If using Python, you'll make extensive use of the PIL library for processing and working with images if the Raven's project stays as the core project in the course.

KBAI was my third subject in the program, previous 2 being CV and DVA. I could not appreciate the subject matter enough. The paper does a good job at introducing you to the AI world, but it barely even scratched the surface - I found the complexity of the video lectures, the programming assignments(3), the non-programming assignments(3), and the exams unfitting for a graduate paper in a top grade CS program.

Barring that, make no mistake that the paper was extremely well-run - the instructor (Prof Joyner) was very active and responsive on both piazza and slack; the TAs were extremely committed and helpful and there was nothing to complain about on the administrative side of things either.

Overall, I recommend this course more as a filler course if you want an easy one to club with a difficult paper, but from a learning standpoint, I feel disappointed.

Best professor of the program (Dr. Joyner) for sure. The one who cares the most about the learning process itself and the students. This reflects on the TAs' behavior and the overall quality of the course. There is a lot of writing involved, which it was a plus for me as I love it. But it is something to consider if you don't like writing that much. There is simply no way around it as all homeworks and projects require a 10-page essay. The course was taken on Fall 2018, and some changes were introduced to the course in relation to past semesters. For example, the projects used to have a curve and be graded solely on the performance of the AI agent submitted. For this semester, that component was reduced to be 30% of the grade, with another 20% coming from the improvement progress presented and the other 50% from the essay about the submitted agent. I hear the professor is considering some other changes that, if implemented, in my opinion, will improve the course even more for future semesters.

This is one of those courses that one gets back what ones puts in. On my case, I ended up putting over 30 hours/week, not by necessity for the A, but simply because it is a subject that interests me a lot. But I can see people still getting the A with maybe 12-16 hours/week. Especially if you come with a solid Python background. Not a difficult course for an A, supper interesting topic, engaged students and great professor. Can't go wrong with that combo!

The concepts were interesting to me. I liked how learning was primarily via the lectures as opposed to a book. I didn't think the projects were super conducive to learning the concepts in the course. My investment in this course was very sporadic. Some weeks I wouldn't put any time into it and other weeks I'd be working on a project for the whole weekend. But the effort required is manageable, especially if begin working early, little by little. I highly recommend summarizing each lecture at the end (as they suggest) as it helps you solidify what you've learned and it is useful for reviewing the material before taking the test.

Script for lectures: http://www.coursedocs.org/gatech/cs7637/index.html

A very manageable first course. The lectures are good and the homework/exams draw from them in a way that never felt unreasonable. The projects rely on you either creating and implementing your own version of an algorithm that solves a complex series of visual analogies or doing the research to find approaches in papers and then implementing them yourself. Start the projects well in advance to allow for this and make sure you're comfortable with either Java or Python.

Very well thought out class. There are a total of 3 homeworks, each about 8-10 pages long, and 3 projects. I found the last project to be very time consuming, much more so than any of the other projects and homeworks. All the assignments are clear with almost no ambiguity and this class truly sets the standard for an online class. Overall, the material is interesting, the professor and TAs are very engaged on piazza and the class is manageable. Stay ahead of the lectures and projects.

KBAI was revamped for Fall 2018, so I think reviews are needed. You can see the syllabus for Fall 2018 term at http://lucylabs.gatech.edu/kbai/fall-2018/ .

The class content is interesting but a bit theoretical; while it's grounded in AI, and you'll find examples of such topics when doing other AI classes, it's hard to really apply what is taught in the lessons to most of the things you'll do in the class.

The course revolves around three homeworks, which are 10-page written essays about both class topics and other thems, three projects, which is actually the evolution of more or less the same task (creating an agent for solving Raven's progressive matrices, with harder and harder problems while going on), and three open-book, proctored one-hour exams.

Homeworks are interesting; they invite you to actually reflect about various topics.

The Raven's solver is interesting as well. You'll need to experiment with various techniques in order to solve the different kinds of problems around. I didn't especially like the "implementation points" section, but actually it seems that it's mostly free points for many people, so, it's not bad either. You must write a report along your implementation, and that report is 50% of your project score.

Personally, I didn't like the exams. They felt more about wordplay and discerning ambiguities, rather than verifying if people understood or knew some content. But that doesn't mean they're overwhelming difficult.

You can mostly frontload work, since the syllabus is complete from the beginning, but while you can implement your agent, you won't be able to test it his "matching" set from the beginning, so you may be forced to revisit it later on.

All in all: a solid, well run, medium-difficulty, interesting class.

This was my first course in OMSCS and I really liked it. It would be a great first course for anyone. There is a lot of theory and no mathematics at all, there are 3 homework assignments, 3 projects and 3 tests. Tests are open book and simple, if you have watched lectures carefully, you will be able to get good marks on the exam. All the projects are connected to each other, there is an option to choose Verbal approach for first 2 projects but final project involves reading images and processing on it. I would recommend to start on visual approach from first project itself. Prof. Goel no longer teaches this course and Prof. Joyer is no less, he is actively involved in the Piazza discussions so as all other TAs. If you have any questions rest assured it will be answered very quickly on Piazza. There is a lot of writing involved in this course. Apart from homework assignments which are expected to be 10 pages long, each project has to have a reflection report which is again 10 pages long, so be ready to write up to 60 pages throughout the course. The good news - There is no team project !. The bad news - The experimental project of NLP was not offered in this semester.

This was an excellent class to get a good introduction to Knowledge Based AI.

It gave me a practical view of how to use AI along with the development team's knowledge and to consider ways to build confidence in the AI with your users.

Dr. Joyner and the TAs are very helpful and responsive, and it's clear that they care about the students' progress and learning. Course syllabus, grading and schedule are very clear and available at the start of the course. We had 3 homework assignments, 3 projects and 3 exams. The projects used Java or Python, and you can work ahead. Overall, an interesting course on AI, with lots of theory and also practical work in the projects. This semester, we had Raven's Progressive Matrices in the projects, but it looks like there will be some new projects in the upcoming semesters. It's not a very hard course, so it's suitable for students early in the program. Enjoyed it quite a lot and made me think both about AI and my own thinking.

Overall, an excellent course with a very engaged professor. I learned a lot and really enjoyed the projects. I learned a lot from the piazza interaction as well--a lot of great posts with related articles. There's also a great opportunity to think about the ethics of AI through the homework assignments, which I see as difficult but important. Easy to work ahead, which is a huge plus for me, although Exams must be taken during a given week. A significant amount of writing is involved in the course, which surprised me--this was my first course in OMSCS. 3x 10 page homeworks, 3x 10 page Project Reflections. I found that I wanted to continue working on the projects after they were turned in ... they're that fun. This was a great first course. I put in decent effort and received a solid A.

Definitely not a course I would have taken if I could have helped it. The lecture material is wholly unhelpful for the project and you're graded based on the performance of your project compared to your peers, which varies wildly based on the KBAI techniques that you use. I scraped by with an A from being ahead of the curve in the early stages.

This was my first OMSCS course and was very well-organized. The professor was heavily involved, and this was the most "academic" course I have taken in the program. By that I mean it feels more like a grad class - you're encouraged to experiment and explore and not obsess about grades. I loved the lectures and I spent way too much time on each of the assignments, so this was a big time sink for me. I am a decent python programmer and found the projects consumed multiple weekends to complete. I rated this class to be "Hard", but I spent a lot of time on it and got an A, and I think you would find similar success. Outside of the repetitive projects, this class was one of my favorites.

I loved how enthusiastic and engaged the professor, and the TAs were. They were all very helpful and responsive. It's clear that they care about the class very much. The rules of the class are well thought out and very clear.

I was able to get into the alternative project (doing a chatbot), and it was a great experience. The rules were not as clear as in the main project (because the project was still in the experimental stages - we were warned about that beforehand), but being a part of the group helping to define it was thrilling.

On the other hand, I didn't really care for the lectures. I felt the material was outdated and without much practical application (that's just my opinion - professor Goel would disagree).

You have to write a lot in this class (essays, not just software). I think it was a great introduction to OMSCS - after taking KBAI writing-assignments in other classes don't seem scary at all ;)

KBAI is like a good game: You can have a lot of fun on the main quest (get raw points re-implementing the CV-focused known path), or a lot of fun on side quests (implement something else entirely and loosely tie it back to lecture content), and there's no way to lose.

The course was well organized and let me work ahead. KBAI offered projects and coding to make the concepts concrete and applicable. Cannot recommend it highly enough. You do have to work ahead some as the assignments were uneven in complexity at least from my perspective. Some just seemed easy to do and others required struggling to get them to work. This may have been my lack of background in robotics. The extra project work was worth doing.

The course involved a lot of writing. For me, the concepts were very high level and didn't cover things to the detail that I would have liked. The project was interesting for the first few weeks but got tiring/boring towards the end of the semester. The exams also required a ton of writing, which wasn't really the best way to learn concepts (for me).

I don't think that the projects supported the material well. Because each project built off the prior one, if you didn't have great results in the first stages, you ended up not being able to really make any breakthroughs in learning because you were perpetually behind in subsequent projects. At least, that was my feeling.

Well organized with great communication between instructors and students. I would have appreciated more direction in the projects and more practical examples in the lectures. I felt the alternate chatbot projects were harder, more interesting, and more applicable to the course material.

There is a non-trivial amount of writing in the course. Three assignments, two exams, and peer feedback were entirely writing. The three projects have a coding component and a writing component.

This was Dr. Goel's last semester teaching this course.

I took KBAI as my first course in OMSCS and was very impressed with the organization and quality of the course. The interaction with TAs, Professor and fellow students on Piazza was one of the highlights. Much of the course centers around 3 projects that implement an AI agent to solve Raven's Progressive Matrices. This semester there was an alternate project offered for projects 2 and 3 for a select number of students that implemented a chatbot. In hindsight I wish I had taken the opportunity. I believe the chatbot project will be offered to more students in future semesters. My only gripe is that we didn't have more project based work that allowed us to implement techniques learned later in the course. The Raven's projects really only implemented techniques learned in the first few weeks. Be prepared for a lot of writing. Also, you can put as much time as you want into this course so it is a little dangerous. The homeworks and projects are very open ended.

One of the courses with the most genuinely involved instructors. They are actually around all the time and are still experimenting with and improving the course even though this is one of the oldest courses in the program. Professor Goel is going to stop teaching this course starting next semester, but it will still be taught by Professor Joyner (and Bobbie Eicher), so you can still expect a lot of instructor involvement. The course does open book exams without proctortrack, which is personally my favorite mode of doing exams since proctortrack is so constraining. Decent amount of freedom to explore and experiment in the assignments if that's what you want to do.

My main issue (and it is a big one) is that the material itself feels pretty dated: knowledge-based AI isn't really in fashion in our age of ML and deep learning, so I took this course to see if there was still interesting techniques in that domain, and frankly I don't think I've been convinced: there is a lot of material in this course, but much of it seems obvious, brittle, or excessively vague. Also there seems to be a lot of repetition in the material, where techniques that are extremely similar get presented separately due to what I think are very minor differences.

In summary: this is a well-taught course. It does require you to write a lot but you don't need to be a genius to get an A, just do your work consistently. However, don't expect your mind to be blown by the material, and be aware that you are learning about an area of AI that is now fairly outdated.

This is a very well-structured class. The material is very interesting and presented very clearly, and all course material is available at the outset of the course. There are 3 assignments, a 3-stage class project, and peer-reviews for all assignments and project stages.

Assignments:The 3 assignments are essentially essays that ask you to leverage class material to either a specific topic or a topic of your choosing (depending on the assignment). You often have a choice between which material you wish to discuss, so as long as you illustrate you understood those topics and provide a reasonable answer to solve the posed problem it's not too difficult. I would recommend using lots of figures, since the word limit can sometimes be tight, so flowcharts, pseudocode and illustrations in general are very helpful. Make sure to answer all rubric questions provided for each assignment.

Projects:The class project is broken into 3 stages. The main overall class project is to develop an AI agent that can solve Ravens Progressive Matrices, a standardized test of intelligence. I say main project since they also allow you the option to complete an alternate project for projects 2 and 3, which involves developing an AI agent chatbot that can answer questions based on answers from an FAQ. At each stage, you deal with progressively harder requirements / problem sets, and you will need to also write a project reflection describing your approach, what you learned and how it connects to KBAI topics. Start projects early, so you don't feel overwhelmed trying to rush things last minute. Don't neglect the written reflection too, as it's normally 40-50% of each project, and make sure to again follow the project rubric to make sure you answer all questions on each rubric.

Exams:There are 2 take-home examinations, which aren't too difficult. They are essay-based, much like the rest of the course aside from project implementations, and you have a week to complete each exam.

Peer Review:You will also need to complete peer review for all assignments, all 3 project reflections, and the mid-term and final exams. They don't want single sentence sort of peer reviews, so you will have to put a bit of effort into leaving some good feedback here.

TAs: TAs and the prof were all very active on Piazza. There were a few grading hiccups towards the end of this semester, but they were rapid in addressing these issues and correcting mistakes where necessary. I believe the prof, Dr. Goel, is stepping down and there will be a new prof so I'm not so sure if the exact structure of the course will be as described above, so take these notes with a grain of salt.

Prep: This is a good first class, but if you aren't comfortable with Python or Java then you should get brush up on one of these prior to starting the class. Most people use Python, and if you want to complete the alternate Chatbot project, it is only Python. Prepare for a lot of writing, as in total I wrote about 11-13k words across all assignments, project reflections, and exams.

This is a very well run class. The material was interesting for a bit, but it soon felt extremely dated. The main project was to to write an AI to take a visual IQ test. Some students took part in an alternate NLP QA project. If you have the chance, definitely get into that alternate project. The IQ test was interesting at first, but quickly grew tiresome. The NLP project was very open ended, but a lot of fun to work on. Overall, solid class, reasonable difficulty and pace, the alternate project really made it.

I feel KBAI is a great course to begin OMSCS. My background is in electrical engineering so my software development skills are limited compared to others working through their OMSCS degree. This course provides the option to utilize either Python or Java to work through the three projects that build on each other throughout the semester in order to develop an AI agent that is able to solve Raven's Progressive Matrices problems. I found the material extremely interesting. It is a bit of a jump for those with limited software development experience translating the theoretical course material and applying it to the projects, but extremely manageable after dedicating the expected amount of time. Three assignments must also be completed throughout the semester that are 1000-1500 word essays on various topics taught throughout the course. The midterm and final exams are both take home essays that must be completed within one week and the expected word counts are 2000 and 3000 words respectively. It is a very well run course and the TA's and professor are extremely active within Piazza.

Pros:

• course are well organised and contents are understandable
• TAs and Profs are very responsive

Cons:

• The concepts taught here might be too generic, it feels like the same contents are being repeated again and again in different terms
• Tons of writing involved in this class, think about taking this class twice if you are not good at writing essays
• The grading of writing assignments are largely based on the diagrams you draw. Yes, we do agree diagrams will help illustrate the ideas, but it shouldn't play such a large part in grading
• The Projects are about solving RPM problems by building an AI Agent, it sounds like a real AI project, however from my personal experience, it feels like a normal programming assignment, the Intelligence part is not that much...

Final Exam Drama:

• So the prof posted final exam paper, which is a writing assignment. After three days when many people have finished the paper, they found out that the solution to one question (Q3) is available online. They took that question done and posted another version of final exam paper, many people's efforts in that question are now in void.
• The worst part occurred in grading Q2, Q2 is a perfect example to be solved using version space as per discussed in lecture videos, it could be solved using Incremental learning concept as well, they are largely interchangeable and there is no absolutely right or wrong. Students who use version spaces concept didn't get much credit, when being questioned, the prof's response is like below

Briefly, the original final examination contained a specific question on version spaces using the same data as for Q1 and Q2 in the current final exam. Given that we had a question on version spaces in the original final exam, it was clear that Q2 referred to Winston's method of incremental concept learning (and not version spaces).

• So the grading principle is, because the original problem Q3 is using version spaces, thus Q2 cannot use version spaces concept. That is indeed ridiculous as Q2 and Q3 are not related, and students taking the exam shouldn't guess which concept to use based on a question that has been deleted from the paper! Disappointed and cannot understand what they are thinking.

Great class. Professors Goel and Joyner are obviously extremely interested in the topic matter and it shines through in the incredibly well constructed lecture videos. The class is rigorous enough to make you feel like you're really learning, but not so challenging or time consuming that you have to give up other aspects of your life.

Projects: This was my first class in the program, so I chose to stick with the regular Raven's Progressive Matrices (RPM) projects. Prior to this class, I had no experience in Python or visual processing so I chose to implement the verbal method for Project 1. However, I regret going this route and wish I would've jumped into the visual method right away. I found that when I switched to the visual method, I was able to finish coding my project in < 10 hours whereas I spent well over 3x that amount of time trying to account for all the edge cases in the verbal method. Lectures: The lectures were very interesting in the beginning! However, towards the end, the topics seemed to overlap quite a bit so I started to lose interest in them. Assignments: The writing assignments were definitely interesting and allowed you to be creative in developing solutions for real-world AI problems. However, a common complaint among the class is that there was a larger focus on well-made diagrams as opposed to technical writing ability. Exams: The exams also required a large amount of writing (2k words for midterm, 3k words for final) and had ambiguous rubrics, which was frustrating because our responses were largely up to our interpretation of the problems presented. Teaching Staff: The teaching staff was great! Professor Goel is pretty active on Piazza, and the head TA (Yan) was generally quick to respond to any questions we had. Grades were consistently returned 2 weeks after submission, with the exception of Project 2 and 3. This was because they included opportunities for "recovery credit" in the regular project and also normalized the grades for alternate project with the regular project to keep the class average fair.

This was my first class in OMSCS, so my review is also affected by how difficult I found balancing full-time work and personal life with this course. I found the class to be difficult. I thought the lectures in the first half of the semester were fantastic. I started liking them less later in the semester, but there were still some that I really enjoyed. I really like how Professor Goel made the classes interactive. What I found difficult about the course was the projects. The projects build on each other, which is cool if you feel you have a good grasp on the project and a good way to solve it, but if you don't have a good approach at first, you could potentially need to do a lot of refactoring. I have no experience with visual processing and am overwhelmed by the third project as a result. There are a lot of writing assignments, but personally I did not find them so difficult. However, you have a word limit and I think a lot of detail is expected.

I love this course, well-constructed. Peer feedback is useful. A lot of writing like other reviewers said. All 3 assignments, midterm and final are writings but need to have good understanding of the course materials. projects are not quite related to course materials, requires some work.

Think about this course - where are you going to apply this learning. The entire course runs around solving Raven's progressive matrices using one software program. What practical insight does it give you besides learning Python Pillow library to scan images and using your own software development approach to do math and compare the images, find similarity and differences. I did find any value from AI or ML perspective in this course. TA's are okay, sometimes their responses are vague, sometimes okay. They like lots of writing on out of the world scenarios. More diagrams, more flow charts and spend lot of time writing and making nice drawings.

There is a big disconnect between theory being taught and what you are expected to do in assignments. Videos are nowhere connected to assignments. overall not a very useful course if you want to utilize the knowledge in any of the practical scenario.

I took this class already expecting lots of writing assignment based on the review. And that is exactly what I got. You will have 3 assignment write-ups, 3 project reflections and 2 exam essays. Each assignment will have 3 peer feedback so 24 peer feedback in total. That is a lot of writings but dont get me wrong, you will learn much of the concept through all of these.

Lectures are good and well prepared but mostly only concepts. You need to take extra steps to convert it into working code. I chose RPM project since it had more guidance and stable grading criteria. But if the chatbot assignment is improved in the future, YOU SHOULD TAKE IT! It is more valuable, used in the industry, and looks impressive in your portfolio (compared to RPM solver..). Piazza and Slack were active and really helpful.

Overall a good survey course to KBAI concepts but expect to spend 20-30 hours a week for the assignments.

This was my first class in the OMSCS program. I thought that the lectures were fleshed out really well in a way that was easy for me to understand. Taking this by itself is pretty manageable and mainly only gets busy around the the due dates of projects and exams. Take note that you will be doing a lot of writing and self-reflection for this class. Every single assignment, project, and exam will consist of a decent amount of writing. I would recommend this class for any new OMSCS student.

KBAI was my first course and i must say it is very well prepared, all TA's and professor was very helpful throughout the course. Classes were organized in proper way along with active discussion among your peers. Initially everyone was suppose to do same project but later on students provide an option to work on other project based on their performance in first project. With this class there is lot of writing which consume a lot of time but there is an opportunity to get your writing published if it is unique and innovative. Though there are many concepts taught in the class about AI, but it was very hard to implement the same in practical life. To start with your program its a good course and one can easily learn python which is highly recommended to finish your project, Good Luck!!!

This was my third course in the program. Overall, KBAI is well run compared to my previous two courses and the TAs were second to none in terms of responsiveness, interaction and timely grading. The good of this course is that the professor is passionate, the TAs are active, and the course is well organized with pace and material being just challenging enough without completely pushing students over the ledge. The grading is fair and peer feedback proved to be very helpful.

The bad of this course is that the projects build upon each other with minimal help when initially trying to implement a solution. Only a half of the lecture videos are relevant to the course. There is a ton of writing and research involved in this course.

Note that all of the negatives I spoke about above could also be seen as positives. This is purely dependent on the student. I had never programmed with python before this course, so perhaps this would have improved my overall experience since I was hamstrung at times learning Python and the NumPy and PIL library. Overall, a challenging course and the best I've taken in the program so far.

It is a time consuming course due to its emphasis on writing and expectations in terms of diagrams, flow charts/ Pseudocode etc. Both mid term and final are take home exams of answering 6 questions. The project is incremental which is solving raven's progressive matrices. It feels overwhelming initially. Project 1 and 2 can choose verbal/visual approach and project 3 is just visual. I felt it is better to start with just visual from beginning which will make life easier as it progresses. Projects require coding in Python. I had not much prior experience but going through the required pillow library once helped a lot. Overall, a normal yet time consuming course to start the program with. The grading is liberal, answering the rubric questions with appropriate headings will do the trick. I took this course along with ML which caused a lot of trouble as both being time consuming. The Professor and TAs are very active and the course is planned very well. Overall, a good course with fixed expectations.

This was my first semester, first course so I can't really compare KBAI to any other OMSCS class. That being said it felt like a well-run class. Professor and TAs are active on Piazza. Good, well-known and communicated structure. Good lectures. Interesting projects. Generous grading. Medium workload, not very difficult. I could not have wished for a better start into the program. I will say, however, that there is a lot of writing (in total we had to write 8 essays for a total of about 15.000 words) and reading for peer feedback (24 peer feedbacks in total, 3 for each essay) which means you will read and critique another 120.000 words.

For me it was perfect to get my writing in shape, get familiar with python which I didn't know before, get familiar with Piazza, T-Square and Peer Feedback in a class that was busy at times but not too bad in total. I recommend taking it.