Reviews

Liked the instructors a lot. They did good job explaining the concepts. But I felt it is sitll hard to understand them. The 4 asignments get harder each time and I had very hard time finsihing them. (I was taking Deep learning at the same time and did not put more hours to it. That could be the reason I did not do well in RL.)

The name of the game is copy the algorithm. Each homework requires useing pseudocoded algorithms from the textbook that need to be followed to the letter. The nuances are tricky at first, but you'll understand the notation with enough practice. Really interesting course content. Teacher are okay, exam is a bit rough. It gets curved though, don't worry. Definitely take Deep Learning first.

I heard lots of praises for the textbook, but I found the writing difficult to understand without having to read it couple of times. Granted, it is an incredibly well structured textbook that builds on from the foundational concepts to build onto somthing pretty complex by the end of the course. The course isn't very demanding - I found myself reading the textbook, answering weekly problems sets, and occasionally doing the programming assignments. The course sets you up with basic vocabularies and concepts to understand maybe more practical work on reinforcement learning happening in the world today.

Pros: 1. Was honestly really cool writing a compiler (for a toy, example language though) and learning how a basic one actually works 2. Lectures were surprisingly engaging. Subject is dry but the professor does seem like he genuinely likes to teach 3. No big final project (I hate final projects) 4. You get to practice your Java (you don't need to know it ahead of time, it's very easy to pick up the couple Java-isms needed) Cons: 1. Professor can come across as an annoying personality especially if you ask questions (I do think he is nice though in terms of how he grades and structures the class. I'll say he averages out as just average then) 2. Midterm and final were okay but seemed sorta pointless, did not learn much from them 3. Pacing of projects was very off. 2nd by far took the most effort. I think they should have spread it out better. Not sure why you had to go all the way up to level 3, when they could have made you go to level 2 first, and call that its own project. Detailed Review: Pro #1 definitely holds. Used to get very annoyed by compiler errors, now I get less annoyed :). Makes a lot of sense in hindsight, but I never realized a compiler is really just doing a massive string parse of your entire program. So it now makes sense when an error is thrown because it's not in the format it expects. Again, sounds dumb and basic writing it out, but it was cool for it to actually click. Advice for actually completing the projects: takes a bit to wrap your mind around the first project and the second one too. For the very first one, they'll post examples on the forums which help a lot. You'll quickly realize you basically always want a space for your return value, then your input variables right at the top, then do your operations on those by first making copies of them, consuming them as you do your operations. Then once you have your final result, go store it to the space you made for the return value, and then pop everything else off. To make your life a whole lot more easier for project 2, make sure that your push and store operations are only the relative ones, not the absolute position ones, and that all the code you write works so long as your inputs are on top of the stack, doesn't matter how big the stack is. So like make sure your concat will, no matter how big the stack is, so long as there is two strings at the very top, once you entire concat code runs, you will be left with just the concatenated string at the very top, the inputs will be consumed and gone. If want to make your life even more easier, make sure any named labels you do use are unique for each function you write. You'll understand why that's needed when you do project 2. Get used to debugging here too by stepping over each line and command. You will definitely need to do that a lot later on For project 2, I think there a couple ways to do it, as in formatting your code and the overall approach you take. I think the least amount of issues will occur if you are fine with doing the entire compilation in not just one go around (I can't remember if it's this project or the next one, but you will realize that you can use functions before they are declared so you need some way to know whether they exist, which means you need to loop through the program text twice). The hardest thing to figure out is expressions: just remember that it doesn't matter how much spaghetti code you write, and you can definitely take advantage of global variables since you are writing java code, all you have to make sure is you return a correct program that passes all the test cases. It's useful to have a temporary file that you can write example test cases on and try to compile that with your code often. For the documentation they give you, all you really need is the one page that shows you the token type and all the commands you can call on it. It's useful to find the actual Java class code that does this and have it open in a separate page in your IDE and get used to the various functions you can use. Finally, making a recursive function for each grammar/language line that will return a string of compiled code is definitely the best way to structure your compiler. If you can do the above project, you will be completely fine for the rest of the class. You have quite a bit of time to get it done, just be sure to start early and really think about it how to do it, and take it one grammar rule at a time. It's pretty satisfying when you get it all working. Midterm/final were kinda annoying with some tricky questions. Make sure to watch and rewatch the lectures. Midterm was mostly just multiple choice and fill in the blank, but final actually required paragraph answers. Again, if you understand the practice tests given to you (and carefully read the diagrams and/or understand the question being asked) and really understand the concepts being discussed in the lectures, you will be fine.

Need to do a fair amount of reading to really understand how to complete the projects properly. Follow the course readings and the additional documentation for the homeworks. It's dry, but worth your time. If you don't know C, you should be able to get up to speed just by completing the assignments. You'll probably start to feel more comfortable after the first few. Had a light C++ background, a bit of assembly knowledge, and a Computer Architecture course under my belt before taking this class.

This class gives back what you put into it. If you just want to pass and get an A you can do that without too much effort. However, if you want to really dive deep into Android Programming, this class gives you the tools to start doing that and get familiar with the Android environment. Personally I did not watch the lectures after the first few weeks as I didn't feel the videos were very useful, so I just did the assignments with a lot of Googling and finding specific relevant parts of the lectures that I needed. The assignments themselves are mostly fill-in-the-blank stuff, where the prof and TAs set up the hard stuff for you in starter code and you just have to finish it off by figuring out what's left to make the apps work. The final project is a full app from scratch, and it's pretty fun. People made some very cool stuff and put a lot of effort in. Overall, this was a pretty fun class and a good intro to Kotlin/Android. Also note that he says you should know Java or Kotlin when you come in, but I didn't know either and still kept up fine, you will learn along the way.

Pros: 1. Very good overview of deep learning in relation to pytorch 2. Assignments were manageable and challenging when appropriate 3. Course schedule allowed you to work ahead with good time management Cons: 1. Final project can be stressful and confusing without much guidance 2. Quizzes can be pesky 3. Detailed Review: Overall this is a very good class that covers a reasonably good amount of relevant information on deep neural networks and different types of deep learning. Other people have mentioned that the content is becoming a little outdated, which is somewhat true; however, the more up-to-date models and frameworks in the field are addressed in the last lectures, albeit without too much depth or any evaluation. The course could probably use a bit of a revamp soon to make it fresher and a little more relevant. The assignments are reasonable and provide a nice neural network in pytorch introduction with #1 and 2. Assignments 3 and 4 ramp up quite quickly, so it is advantageous to work ahead to try to complete 1 and 2 very quickly and save more time for the more challenging assignments. These also will require more training time (could be up to 10-12 hours), so plan accordingly for how much time the model needs to train. Quizzes can be sneaky and tricky, especially for computing gradients. You get two attempts per question, so make sure that you carefully review computations, as the 10% for quizzes can matter at the end. Also, DO NOT forget to complete the quizzes on time, as they are at a self-directed pace. As mentioned before, the final project continues to be difficult and stressful as there is minimal guidance on what approaches to take. Unless you are very confident in your abilities, I would choose to work in a group. Our group went for a state-based agent, and while we were just over the lower quartile for the code portion, our report received very high marks. Suggestion: work extra hard on the report and make sure that you cover every little item in the rubric, as well as format using Latex/Overleaf and make it look like a professional research paper. Since the code is worth only 9%, even a "failing" implementation can still give you a good mark in the class if you perform reasonably well on everything else. We tried many different approaches to the learning for the state-based agent, but ultimately our performance sort of flat-lined. Overall this was one of the better courses in the program and I came away with a much better sense of how deep networks train, and how different parameters/choices of architecture can improve performance.

Very well taught course. Professors are nice and responsive and the workload is very manageable. You'll get good practice solving math problems involving vectors/matrices, as well as using MATLAB. Might help to brush up on your undergrad linear algebra beforehand (but not vital) - you can check out their undergrad course, or maybe Gilbert Strang's (MIT) 18.06 course on MIT OCW.

Pros: 1. Optimization: found it very relevant as a data scientist - I actually decided to use Nesterov acceleration for an NLP project to speed up training time. 2. Online learning: interesting topic and also can be relevant for data scientists. 3. Both professor were fairly active on Piazza. Cons: 1. Peer grading - most were chill - I just hate peer grading. 2. Since optimization is its own course (with quite a bit of overlap I'm told), I'd rather wish OL portion was more fleshed out as a full course. There is no reason to combine these two, as they are fairly standalone topics. Detailed Review: I'm just glad I didn't have to take Optimization. Both halves of the course were decent. The two halves course is something I'm still getting used to - it was quite similar to ML - except these are fairly disjoint topics. In the first half (optimization), the lectures were quite verbose going through all the proofs in detail, while in the second half (bandits), the lectures rarely covered any proofs and told us to read the notes, and also made good portion of the material optional. Spent about 6-7 hours/wk for optimization and 3-4 hours/wk for bandits.

Pros: 1. Serverless and Container lectures were super interesting 2. Groups of 3 was nice 3. TA's were responsive Cons: 1. Projects were hard and lectures didn't help with them 2. Some of the lectures were out of date (although he mentions this) 3. TAs tended to give overly vague guidance which didn't help Detailed Review: I really really hope they refactor the projects -- throughout the semester, you're working on an Academic VM which is not really well-written and there's some sloppy comments that guide you but for the most part you're on your own to figure it out. It was really cool to learn more about serverless and containers; I can talk intelligently about those now. Really hope one of the projects is tailored towards those sometime in the future because it would be nice to get some hands on practice with them. I also think that some of the papers we looked over are really interesting but it's been years since they were published; let's see where those studies are at now? Basically, a new batch of videos per semester would make sense, to me. I did email the professor with those recommendations so let's see what happens.