I got asked a question at the end of my stream by @lukemshepherd I didn't quite get to answer:
Do you have any advice for someone who wants to get into contributing to the @fastdotai library who has experience with fastai but not software development?
Let's try to answer:
If you have absolutely zero, I recommend watching the first few lectures in the latest part 2 (yes of a few years ago!). Since it's building a library from scratch, Jeremy covers how he approaches software design, which can help you understand the design
From there, start small. Look at the simpler areas of the library, and try and add some documentation, etc. Then slowly build yourself towards not understanding how fastai works, but how the DESIGN process works. Apply yourself towards seeing how classes interact, etc
A little toying goes a long way.
After getting comfortable in some specific area, try writing some newer functions, or perhaps try to fix a bug that got noticed. It will be challenging, and you probably will struggle a bit. It's not easy and that's okay. Why?
With the discord, forums, and twitter combined, you can find someone (or many someones) to help you understand how to get from A -> B, and that's what's wonderful about this community!
To take that further, if the part 2 videos are still too high a level, try finding some educational tutorials and courses on Object Oriented Programming, and try and bring up your foundations (pun intended). You can stay in Python for those, so don't listen to nay-sayers*
*Other languages are important, and there is a strong belief in starting with C++ or Java as your first language, but I usually reserve that for if you're actually a CS major or don't know where to start (which you are Social Sciences learning ML, so that's okay!)
That's my take on it from my own perspective and belief, I hope some others might be able to chime in on this!
HTH :)
This comes with the stipulation of:
I did/am majoring in software design and development, so where fastai intersected with my college progress was late enough to where many fundamentals were already found, but learning fastai taught me much quicker advanced concepts 1/
I wouldn't get into a year or two later.
So, while you should take it with a grain of salt, I will extremely accredit fastai development work with advancing how I can program
• • •
Missing some Tweet in this thread? You can try to
force a refresh
With school over, I'll reveal one of my secrets. I'm making a new course!
Running with @fastdotai! Times and dates are TBD, but I'm shooting for this Fall to hold the course. This will be a continuation on Walk with fastai, building on what we learned there and applying it 1/
The plan is to split it up into three sections: Debugging, Implementations, and Guest Speakers.
The first section I want to be covering debugging in fastai, bringing raw torch code over (direct 1:1 conversions), and exploring inference heavily
The second will be walking through a few implementations of other libraries that have used fastai (and writing one or two ourselves) in a much more complex manor rather than "set your data up so the DataBlock works". Situations will arise where the DataBlock doesn't exist yet!
It's a very big day for me today, as I'm officially releasing version 0.2.3 for the @AdaptNLP project. With it comes a slew of changes, but what exactly?
Thanks to the lib2nbdev package (novetta.github.io/lib2nbdev), we've completely restructured the library to become test-driven development with nbdev, with integration tests and everything else that comes with the workflow 2/9
Next @fastdotai and #fastcore, I'm restructuring the internal inference API to rely on fastai's Learner and Callback system, to decouple our code and make it more modularized. With the fastai_minima package as well, only the basic Learner and Callback classes are being used: 3/9
Deploying with @fastdotai isn't always learn = load_learner(), learn.predict. There are numerous scenarios when you might only want some, part, or none of both the API and the library as a whole. In this thread we will be exploring your options, how they work, and what to do: 1/n
Ideally we have the following context:
DataBlock -> DataLoaders -> Model -> Learner -> Train
This can then stem off to a few things:
1. learn.export() -> Model and DataLoaders (which are now blank) ...
In this scenario, we need to ensure that ALL functions which were used in relation to the data are imported before loading in the learner. This can run into issues when using fastAPI and other platforms when loading in the Learner is done in a multi-process fashion 3/
Can anyone tell me the difference between this @fastdotai code? How does it behave differently:
Answer: There isn't!
One is more "verbose" in my opinion (get_x and get_y), but neither lose any flexibility as you use it.
2/
But what if I have three "blocks"? Don't I need to use `getters` for that?
Not necessarily. Since we can declare an `n_inp` (as seen below), we can simply load in our `get_x` or `get_y` with multiple functions to be utilized instead for those types:
lib2nbdev has been on my mind for months now, and finally it exists! What's the biggest struggle with @fastdotai's #nbdev? Using it on existing projects. This tool aims to fix that.
You are then guided through the process of setting up nbdev's `setting.ini` file and afterwards all of your existing code will be converted directly into fully functional notebooks!
But wait, don't you just throw it all into one big cell?
NO! Instead lib2nbdev will determine what should be private or public, what's an import, and what particular cell tag it should be generated with, such as below which has both private and public tags: