- 7 reviews
- 7 completed
Overall, a good course, which requires relatively little background other beyond basic probability theory. The distinguishing feature of the course is that the lectures are duplicated by an interactive book from the Berkeley website: <http://www.stat.berkeley.edu/~stark/SticiGui/index.htm> The instructor recommends to use both lectures and the book, but I found that ambiguous. The lectured seemed slow-paced and not enough technical to me, so I switched to the book. Unfortunately, the order and segmentation of topics do not match, so it is not easy to follow the book in parallel with the course. The book itself contains recordings of videos by Prof. Stark (winter is coming!) and interactive exercises, which help a lot. Probably, instead of taking the course you would benefit from just reading/watching that book, which is not tied to specific dates (relevant chapters are 26-31). The only things you will miss are the more verbose video lectures (they are not deeper, just require less background), and the quizzes, which are quite good in making you really understand the limitations of the tests and models. Exercises therefore can be tricky, so read them carefully. The main disadvantage of the course is its limited scope: you will learn about z-test, t-test, chi-squared test, one- and two-sample tests, confidence intervals and p-values. I don’t feel like that covers the field of statistics well.
Having completed this course, I have somewhat mixed feelings about it. On the one hand, I learned the basic concepts (like Activity lifecycle or ContentProviders), on the other hand I don’t feel ready to write more or less serious application from scratch. It seems fine overview course, but the practical part is weak. Lectures. I agree with the others who think that the lectures can be more engaging. Every lecture has a predefined pattern: 1) discuss a concept, 2) show the example application, 3) show the code how it is done. From those three, only the first point is necessary. Examples are predictable, so you don’t need to spend that much time to watch them, the code is in contrast shown quickly, so you cannot really get into that (yes, you can stop the video, but in practice I did not often want to). Said that, the set of example applications used in the course is amazing (and you can download them). May be the lecturer could skip that part in the lectures and ask students to explore the applications, providing a quiz to make sure they understood what the particular lines of code do. Quizzes. They either require documentation lookup, or bring up the details from lectures, which I often forgot since the lectures were quite boring (see above). Not really useful. Assignments. You needed to fill some lines of code and run tests. While that improved towards the end of the course, I often could guess what to insert without full understanding of that code. The latter assignments provided more freedom, but still not enough to require deep understanding. This seems like a constraint of an automated testing. Final project. Complete disappointment. I allocated a whole day thinking that it would require some creative effort (it was peer-graded), but it was once again a fill-line assignment. Since it was hard to go the wrong way, the peer grading turned out to be formal and unnecessary: I gave out the maximum score to all peers. To summarize, in my opinion the course should spend less time on lectures and instead provide more challenging assignments/projects where you need to implement a significant part of an application. Personal/group projects would be very useful.
This is quite a practical course on the recommender systems design. The lecturers seem to be nice persons who are close to applications. However, the lectures may benefit from more brevity and mathematical strictness. Mistakes are quite common. Overall, most concepts are too simple to spend that much time on them. The strong side are the interview lectures: the hosts invite some people from industry to tell about the systems they designed, which gives a clue on what is really useful in practice. Tests generally help to control yourself, though the options are sometimes quite vague. Peer-graded assignments are good exercises, but they lack a good grading system: there is no field for textual feedback, so you cannot point out to the problems / possible improvements in your peer’s work, and thus don’t get any explanation of your grade. However, reading about peers’ projects is quite fun. The weakest part of the course IMHO is the programming assignments. They typically provide practice not to learn the algorithms, but to learn the API of LensKit, the Java framework created in the lecturers’ lab. That is an enterprise-style system with dependency injection and database access objects, so I typically spent a lot of time figuring out dependencies between classes and routines to transform different kinds of immutable vectors to write several lines that actually solve the problem. It was fun to test the algorithms on real data (movie ratings collected from the course students), but the downside was that computation could last an hour or more. Overall, the course was useful for me, though it could be more useful given the amount of time it took. I have some background in machine learning, so the course looked to me like a set of heuristics. I think this in not the problem of this particular course; the field of recommender systems is just too young, and I hope a lot of methodology is yet to be developed.
I decided to take this course bypassing the part I, since I had already known most algorithms covered in it (as well as half of the part II algorithms), but was interested in string algorithms and compression. It was relatively easy to dive in, although the style of presentation chosen by Robert Sedgewick is quite untypical for a fundamental algorithms course. It is very implementation-oriented, he literally discusses the specifics of Java implementation: some may appreciate that, but I didn’t. Still, the theory is covered well: for all algorithms the time complexity is discussed. The lectures contain some fun facts and clever jokes. Assignments also reflect this implementation-oriented nature of the class: you solve interesting practical problems (which is good), and test scripts estimate the computation time and coding style. This is debatable, since—yes, you can implement all sorts of caching, but what’s the point to do it in a throw-away academic exercise, you have already implemented the required algorithm correctly, after all. For the coding style: you may be used to another one; it does not contribute to the final score though. This is one of few courses that do not issue any form of certificate (so it is not listed as a completed course on the records page), which may be important for some students. In spite of that nagging, I liked the course. Robert made a good counterpart to his famous book. I wonder why there are too few reviews here; hopefully they will come soon.
Quite nice theoretical course on linear programming and discrete optimization methods that can be reduced to that. The theoretical part is good, and quizzes are quite challenging. In particular, they help to learn the tricks emerging during translation of the domain tasks to optimization problems. Programming assignments are too easy. They require to only fill some blanks in Python code, which tests basic understanding of the algorithms. They would benefit from greater amount of analytical questions.
The course is quite introductory. If you are familiar with basic computer vision, 3D geometry and optimal control, you are not going to learn much more from the lectures, although the instructors mentioned that the survey results encourage them to make the lectures more advanced in the future sessions. The lectures contain several demos of working autonomous quadrocopters, though. After completing the course I don’t feel ready to take a copter and make it fly, as I initially expected. The instructors provided a really wonderful simulation environment, but the programming assignments themselves did not encourage to solve difficult practical problems, which is especially daunting given that great environment. To sum up, I think the course is too basic now, but has a great potential.
This course gets quite diverse reviews. Probably, some students had incorrectly estimated the difficulty and/or practical importance of the course. The course is probably one of the most challenging ones in Coursera both in terms of workload and theoretical depth. I used to spend 15+ hours per week (though it was 9-week long during the first run), and I doubt anyone could complete it successfully without basic Matlab knowledge or without prior exposure to machine learning or statistics (would be very difficult to catch up given the workload). I was a PhD student in a related field while taking the course, still the course gave me a lot of knowledge. It contains several advanced topics that are not always covered by alternative courses or books (like learning of graphical model structure). Comprehensive programming assignments (reminding small research problems) and quizzes help to make yourself really familiar with the topics. Some people even made T-shirts with a caption “I survived PA5” — that was an assignment on Gibbs sampling, was challenging indeed, but the experience was that rewarding. Some PA’s really require figuring out the data structures involved, but this is a compromise between having students developing complex software from scratch and spending reasonable amount of time. Daphne, as Coursera co-founder, made her best to show the capabilities of the platform (it was one of the first MOOCs). Unlike some other courses, you feel like you are really taking a quality graduate- level course comparable (though not identical) to the ones the author teaches at her university. To sum up, prospective students should take into account that the course is quite advanced (vs. introductory), academic (vs. practical), and demanding (vs. laid-back), when deciding whether it fits their goals.