Fast.ai Part 2: Deep Learning from the Foundations(course.fast.ai) |
Fast.ai Part 2: Deep Learning from the Foundations(course.fast.ai) |
Happy to answer any questions you all might have.
You mentioned you studied philosophy as an undergrad. How did you end up working with analytics and DL?
(I know this is an old thread but I couldn't resist)
Looking forward to the release of v2 of the library that was prototyped during the course!
Just implement your model's architecture in Python. Export it. Invoke it at runtime via Swift and TF.
This question is addressed extensively in the course. Check out the last two lectures, they do a great job of going over lots of different reasons.
My problem is that I can't think of any use cases for it, either in my personal life or work life.
I understand that the technologies have a lot of potential, and are currently used in many major projects and endeavors. I just keep drawing a blank when trying to answer the question, "what would I do with this?"
If I am someone who is goal-driven (rather than, say, learning something for the sake of learning), how can I motivate myself to pick this up?
I find it useful to think of DL as just another way to get computers to do what you want. Rather than focusing on control flow and setting/reading variables, you focus on providing examples to learn from. Both approaches can do many of the same things, but each has areas that they're better at. Eg DL is better for things that are hard to explain just how you do them (e.g. seeing pictures, hearing sounds, reading text) and traditional coding is better for things that need specific logical steps. A combination of the two is often best for solving end-to-end problems in practice.
1. Take webcam at desk. 2. Build model that detects whether he himself is sitting at his desk. 3. If it is not him, you've detected an intruder, so spray the intruder with a squirt gun or something.
We only got as far as a model that distinguished between him and other people, even deploying it according to this guide. https://course.fast.ai/deployment_render.html
Also the material is just really interesting. If you want to know how a lot of products work, this is one of the most fun ways to learn.
In the other hand, I'm very exited to try the audio features
That being said, this course is completely different than anything done before. This course takes a look at the very most basic functionality of neural network libraries and proceeds to implement the fastai library totally from scratch. So it's really a great deep learning + tooling + api design + programming language + research implementation course all in one.
The last two lectures on Swift were especially fun. Python isn't great for deep learning because you always have to live at arms length from the implementation through a c++ wrapper. Swift can compile straight to the low level system commands. LLVM, MLIR. Still learning this so I'm not the best person to answer questions about this specifically. :)
So Swift has this awesome feature set of being well designed, pretty similar to Python, statically typed, and low level. These lectures are hosted by Jeremy Howard and Chris Lattner. Sometimes the most valuable learning I can do is to just listen to the banter between two exceptionally experienced experts, so this make the course that much more enjoyable.
Five starts would recommend. Get the t-shirt.
For one project, I adopted what Jeremy taught about building code for processes, which our team has then used for a couple other things as well. For another project, I was able to easily put together the code for training on a set of data with a somewhat complex structure.
For custom kernel code, what you really want to use is a custom TF op. But I doubt that's what you're getting at anyway, because that's for more advanced use cases.
Edit: HN isn't letting me reply deeper, so I'll reply to "what are the benefits over C++?" here. The first is that MLIR has dialects that support stuff like polyhedral compilation, which result in much more concise and understandable code, which is often faster too. The second is that using the same language from top to bottom means you can profile/debug/etc your code in one place, which is much more efficient. And you don't have to learn two languages. And you don't have to use C++, which (for me at least) is a big win! ;)
You can achieve the same efficiency in C++ via a custom TF op. You end up with native instructions either way. And you have access to the entire memmapped model in the op, allowing you to do as you please.
You're only debugging in one place, because the same C++ code runs during training in your notebook that runs during inference on your device.
You're getting ease of implementation and usage of Swift. But your code will be less portable; you won't be able to run the same model on Android or on the server. And there's not necessarily any performance benefit over doing the same in C++, definitely not if your kernel is simple.
If you need to debug something, you don't need to use some mixture of pdb and gdb.
Swift is a relatively young language, meaning it does not (yet) have weird hairy bits to work around design decisions made 20 years ago.
Similarly, Swift is still getting defined in many areas. There is (theoretically) the opportunity to influence language design decisions to patterns that mesh better with ML needs.
This is largely my paraphrasing of the reasons stated by Jeremy https://www.fast.ai/2019/03/06/fastai-swift/
You're still debugging in two places; in Swift and Python. Debugging Swift is probably easier than C++ though.
I think using Swift is a valid solution for special cases, but not the best solution for most cases. The TF authors already provide a suitable, general solution in the form of custom TF ops.
And if you don't need a custom kernel, and the chances are you don't, then stick with pure Python for maximum ease of use and portability.