#214 overall
Deep Learning Course (Hugo Larochelle)
YouTube
2 recommenders · 4 threads · recommended in 4 years, 2014–2018 · score 2.0
A free YouTube lecture series on deep learning by Hugo Larochelle, covering neural networks from feedforward models through convolutional and other architectures. The playlist is the course's main link.
Commenters call it a very good, great-for-beginners reference for deep learning, often placed alongside Hinton's Coursera course and Nando de Freitas's lectures.
Machine Learning & AIbeginnerfreevideo lectures#deep learning#neural networks#feedforward networks#convolutional networks#larochelle
Recommendations by year
20062026
For deep learning: Surprised no one's mentioned Nando de Freitas's YouTube lectures, great series! Hugo Larochelle's YouTube course is great as well!
Don't forget Nando's Deep Learning lecture series! Admittedly it's a little bit math heavy, but don't let that scare you off!
Also Hugo Larochelle's course is great for beginners!
There is a nice book by my profs (Y. Bengio, A. Courville) and a former student of the lab (I. Goodfellow) here: http://www.iro.umontreal.ca/~bengioy/DLbook/ The chapter on RNNs is pretty enlightening. You probably want to start with something the goes through feedforward networks, convolutional, etc. first though.
Andrew Ng's Coursera course does a super basic NN in MATLAB which might be good to shake the rust off [1]. Hugo Larochelle's youtube course [2], Geoff Hinton's Coursera course [3], and Nando's youtube Deep Learning course [4] are all very good. There are also some great lectures from Aaron Courville from the Representation Learning class that just finished here at UdeM [5]
If you want to do this for real (not self teaching RNN backprop on toy examples) tool-wise you generally go with either Theano (my preference) or Torch - implementing the backwards path for these (and verifying gradients are correct) is not pretty.
Theano does it almost for free, and Torch can do it at the module level. Either way you definitely want one of the higher order tools!
[1] https://www.coursera.org/learn/machine-learning
[2] https://www.youtube.com/watch?v=SGZ6BttHMPw&list=PL6Xpj9I5qX...
[3] https://www.coursera.org/course/neuralnets
[4] https://www.youtube.com/watch?v=PlhFWT7vAEw
[5] https://ift6266h15.wordpress.com/
Bookwise, Yoshua Bengio, Aaron Courville, and Ian Goodfellow are nearly finished with their MIT Press book on deep learning: http://www.iro.umontreal.ca/~bengioy/dlbook/ . It is pretty strong on the true theory of what is going on in deep networks, and has fairly good intuition for how and why things work. Paired with the deep learning tutorials http://www.deeplearning.net/tutorial/, as well as the content from UFLDL it is a pretty strong foundation for advanced study.
Michael's book seems to target a more introductory level - a beginner might be better off to start with that, follow with Andrew Ng's ML course, which has a section on neural nets including an assignment implementing backpropagation, then continue with the deep learning book and the {deep learning, UFLDL} tutorials. This should be solid enough to at least read most of the cutting edge work and papers, if that is the aim.
Hugo Larochelle's youtube course https://www.youtube.com/playlist?list=PL6Xpj9I5qXYEcOhn7Tqgh... and Hinton's coursera course https://www.coursera.org/course/neuralnets are also great references.
I would not dive into GANs right off the bat. Ng's course is a good start, maybe also buy or borrow a copy of Russel and Norvig's "Artificial Intelligence: A Modern Approach"[0]. If you decide to look into deep learning, I've heard good thing about Bengio's book (see also Hugo Larochelle's lectures on YouTube) and if you want to learn more about reinforcement learning, "Reinforcement Learning: An Introduction" by Sutton and Barto is frankly amazing (and there's a great course on YouTube by David Silver).
From reading your code, you're probably familiar with most of the stuff you need to learn ML, so I thought I would take a stab at explaining how you get from "no machine learning experience at all" to "surely GANs will solve all our problems". Broadly speaking, a lot of machine learning is just deciding what your goal is (carve an image, play a game, classify objects, group similar data points, etc.) definining an objective function (e.g., number of sharp edge removed, player score, a classification loss function[1], distance over points in a cluster) and then maximizing or minimizing that objective function.
In classification, you want a function `f(.)` such that given a data point `x`, `f(x) ≈ y`, where `y` is the correct label for that data point. Say you have a bunch of these data points in a matrix `X`, and a vector of correct labels `y`–– how do you come up with a function that correctly classifies the data in `X`, and how can you do it so that data you might collect in the future would also be correctly classified?
You could do this with linear least squares (come up with weights `w` to minimize `|f(x) - y|`, with f(x) = x^T w) but unless your data is cleanly separable, that probably won't work so well. There are a lot of possible techniques people have tried, but lately neural networks have become popular because they are powerful approximators, relatively easy to deploy, and pretty versatile. But the training process[2] still boils down to tweaking weights until `|f(x) - y|` is as low as you can make it.
General adversarial networks are kinda a tweak on this idea-- you start with a bunch of images, and you train a network to generate images that are "similar" to them; call the initial images the "real" images and the generated ones "fakes". You want your network to generate fakes that are similar to the real images. How do you define similar? Well, you have a second network whose objective is to distinguish between real and fake images. You train both at the same time, using feedback from the second network to improve the first network, and using the images generated by the first network as training examples for the second.
Initially, the first network will generate splotchy garbage that the discriminator can easily tell apart from the real images. Over time, the first network improves, creating increasingly realistic fakes, while the second network gets better at determining whether an image is real or generated. After much training, you have two networks: one that is good at generating images that are similar to the seed images, and another network that is good at identifying if an image is real or fake.
––––––––
0. It even has a website and example code http://aima.cs.berkeley.edu/
1. https://en.wikipedia.org/wiki/Loss_functions_for_classificat...
2. See here for a nice explanation of the backprop algorithm, http://neuralnetworksanddeeplearning.com/chap2.html or if you want the OG (original Geoff) paper on the topic, it's in the proceedings for Parallel Distributed Processing 1986 -- "Learning representations by back-propagating errors", Rumelhart, Hinton, and Williams.