- 9 reviews
- 9 completed
Class wasn't bad, it's a tutorial of many different computational methods. Having a lot to cover, it doesn't go deep at all, but at least the teacher identifies some key points (e.g. time vs. frequency in analysis) and illustrated them well. In the end, I don't think this class gave me much for the time I spent (lectures are quite long) as it was too superficial for my interests. The best part was probably showing what matlab functions and toolkits can be used for the various problems; even though only a few commands were used for each domain, it can be a good start for a beginner needing to get oriented.
Great class, starting at very basic level (it even covers what matrixes are!) but still covering a lot and going enough in depth especially on some important topics like how to detect model overfitting. The class covers only a subset of the main machine learning methods used today, but it does that well and is an excellent starting point for the machine learning uninitiated. The programming assignments are the best ones I've ever seen on coursera so far, with all the tedious parts already taken care of for you, good hints on how to fill in the important functions. Good and clear explanations and visualizations.Programming assignments were in Octave (a sort of free Matlab clone) and learning it was a good skill to gain (although I also find the Windows version of Octave a bit frustrating due to many bugs).
Very interesting topic, but even more superficial treatment. There was a good part, which consisted in simple Python assignments, setup with a VM worked well and I liked it because I had never used Python before. Might also be interesting to someone new to the idea of automatic trading and sharpe ratio (but very little beyond that, and at introductory level only). The teacher was kind to share his framework to run python script over stock data. Overall, however, in my opinion it's been the most shallow class I've attended on coursera so far (of about a dozen). It's incredible how little material was covered each week in the main lecture, and with no depth at all, whereas other classes on Coursera like the one about Financial Econometrics were able to cover quite thoroughly 100 times the amount of material in one week. While writing code to look at financial data can be fun, this class didn't even start to attack the meat of writing financial models and there was no real treatment of the very important topics of how to test models, how to get a sense of how much results can be trusted and the various tradeoffs in modeling. I wouldn't recommend the class I took as it only skims the surface, but it's an interesting topic and I have great hopes for the class to be overhauled and go deeper in the future.
Not sure this has many applications, but it was a fun class, and probably the only coursera class where I continue to improve the code started in class over a month after it has ended. The videos didn't add that much over the written material, and the written material may need some smoothing, but overall it's good. A few of the exercises were ill-conceived as even following instruction could result in a low grade, but this was only the first course iteration and all the other exercises were useful. The staff also seemed receptive to criticism and willing to further improve it. You can complete the class with or without programming, but for it to be a good experience I think you need to write your code. They offered a gamer framework in Java that could be expanded and resulted in many people writing their own players. I'm a programmer, but didn't know much about Java (but know C# which has many similarities) before this class and found it easy enough to implement a player once the first step of orienting oneself within the framework and where to find the various tools. They pointed to Eclipse as the IDE and I was quite pleased with it, except for code profiling I could do everything from the IDE and it even offered to-the- point suggestions to fix errors due to my lack of familiarity with Java. The 'logic' part of the class was a bit hard due to nomenclature, but looking at the game definitions and the examples in the notes cleared it up. A couple of things that I thought were weird about GGP: 1) all good implementations seem to use a coding approach called 'propnets' (similar to a digital circuit implemented in software that represents the game rules) that is only hinted at in class and requires much work without guidance if you aim at an efficient implementation. 2) some of the games seem specifically tailored to be exploitable (e.g. factorizable games) by algorithms that I guess may be of interest to the authors of the discipline or of those games but I still don't know how much of those methods translate to 'traditional' games. At the end of class the staff organized a competition, it was good fun. Writing a player to participate in the competition should be easy enough, but writing one that is not hopelessly dumb in all games is actually a LOT of implementation work beyond what was covered in class. Overall, I wrote a (general) game player (although its level of play is still medium-poor) as a result of this class, which is something I always wanted to try but never found the time before. I might even continue to improve it for months or years. General game programming has many similarities (e.g game trees, alpha-beta search, transposition tables) but also some differences with programming for a specific games. One difference is the performance hit of having to interpret the rules, but an even bigger difference is that you can't pre-build an euristic to evaluate game tree nodes (it was interesting to see how Monte Carlo tree search can partially address this).
This is a series of lectures on Beethoven's sonatas, plus a small introduction to Beethoven and music in his times in general. The lectures were great and had some well-played small examples interspersed that added a lot to the understanding. What you'll get from the lecture will vary depending on the level of your musical background, but I think listening to the lectures will be fruitful and pleasurable at all levels. The assignments (peer graded essays) I didn't do, I don't think I have good enough listening skills to write meaningful essays about music I listen to, and I was not able to find the time to hunt for and listen to the lesser known sonatas that I don't already have. After the class I hope to eventually and gradually take a deeper look (and multiple listening sessions) at the sonatas discussed in the lectures. Some good discussions in the forums, too, and high quality video production. I've learned a lot and finally understand what the sonata form is about and how Beethoven brough successive innovations to it and music in general.
This one is hard to review, but overall a good class and an excellent instructor who seems to really love teaching and who can clearly explain all concepts in very simple terms. Half of it is about very basic image processing, in fact I found it a bit too basic for my goals, but may be good for beginners. The other half is about a few advanced topics and shows exciting applications. It even gives a good idea of what the advanced methods are based on, but can't necessarily go in too much depth as the class seems targeted to introductory level and because it would require much more time. I wish there was a MOOC that focused on these more advancied topics like PDEs for image processing or compressed sensing! Overall this class is a good overview of image processing and applications, recommended!
This class touches some very exciting computational photography topics, points to a few good papers, but only gives a very general, high-level treatment. The programming assignments are in python, which I had only previously used in another Coursera class. If you know about pixels, the problems solved in the programming assignments are trivial (e.g. convert an image to grayscale), while if you don't know about pixels it might be a good introduction. I spent most of the assignments time to understand how to do simple things in python (e.g. data type conversions), so while this may be useful, it feels wrong (see the Machine Learning class as an example of a better structure for assignments, where the trivial parts of the assignments were done for you and you had to spend most of the time implementing the interesting parts and even solving some real problems). Good class to get an overview of what computational photography is and get excited about it, but you will learn nothing in practice other than very simple operations like greyscale conversion (huge disconnect between class topics and programming assignments). It could become a very good class if the programming assignments actually taught us how to register images and implement other algorithms, even if using various libraries as building blocks. For example, the class introduction gives the impression that you will then be able to register images, but it doesn't tell you that you will only be able to do that by using ready-made applications (which anybody can already use even without taking this class) and only gain a little more insight of how those apps might work, but not by coding it yourself, or gaining detailed enough knowledge to be able to do it. I really hope that this class may be followed by more advanced classes where we actually implement a subset of the covered algorithms. One algorithm which had a slightly deeper treatment (and even a simplified programming assignment for it!) as it's a field of research for the author was automatically creating seamless loop animations from movies (think Bing webpage videos), although only at a basic level... pretty fascinating!
Wow, one of a few truly great classes I've taken on Coursera. Also the hardest from the math point of view and assignments. The quizzes had some hiccups (e.g. some questions were initially ambiguous, but later corrected) and were hard and required lots of thought, but I really learned a lot from them, especially about how to get the learning formulas for networks with arbitrary sequences of different types of layers. Good treatment of both basic and advanced neural network topics, with great insights about how different areas are related and about practical issues and solutions when working with neural networks (mini-batches, many different methods to avoid overfitting, etc.). The lectures and slides were not perfect as at times they seemed to jump into new topics without much preparation or the jargon changed without explanation from one topic to the next... but they were small issues and overall the lectures were great. Programming assignments were great, although runtime was long (good luck trying to do it starting only a couple of hours before the deadline) and I wish there was deep network practical coverage. It's great to see how much neural network have progressed since I studied the basics at the university long ago. The class gives a quick overview of great application results of the last years for deep networks, and points to some good papers for those interested in learning more details. If this class is offered again (and if you have basic math skills like derivation), don't miss it!
Most of the class is spent in a detailed review of basic statistics, with an eye to applying it to financial data series. I really needed that, plus we were taught how to do all computations in R, with useful examples. Great treatment of confidence and the bootstrap methods. Final weeks were about basics of portfolio theory (efficient frontier, etc.) again enabling us to do all computations. I also appreciated the teacher mentioning that the theory's value decreases when the market is unstable (as correlation increases) and showing how wildly the theoretic results can vary depending on when the data is collected. Overall I now feel confident with basic statistics (also beyond financial applications) and have continued to use R for statistics and data analysis since this class.