We’ve written previously about the rapid growth and adoption of ML tools in the AutoML family. Specifically, we broke down AutoML into 4 categories:
- Citizen Data Science / ML
- Efficient Data Science / ML
- Learning to Learn
- Transfer Learning
Advancement has been especially rapid in tools designed to make Data Science/ML more efficient, and in learning to automate/optimize model architecture design. While these frameworks and tools have continued to mature, their prominence has unveiled another set of challenges. Even when using automation, building out useful, semi-custom deep learning models takes a lot of code! Popular libraries like TensorFlow and Pytorch offer incredible power in that data scientists (who also happen to be experienced software developers) have the ability to tailor model architectures granularly to fit specific use cases. However, all of that power comes at a cost, and that cost can include hundreds of lines of code–and all of the technical debt that comes with it. Add in the need to programmatically implement many iterations of experiments, and one could easily end up maintaining a highly complex codebase simply to train, test, and experiment with a single deep learning model.
Photo by Markus Spiske on Unsplash
To address this challenge, a new genre of ML capabilities has surfaced, pioneered by what we like to call ‘Low-Code ML Toolboxes.’ Projects like the Allen Institute’s AllenNLP, fast.ai and Uber’s [Ludwig] (https://uber.github.io/ludwig/) seek to abstract much of the programming complexity inherent to building deep learning models, while preserving the above-mentioned power of libraries such as Pytorch and TensorFlow. These toolboxes are not limited to AutoML applications. As a result, they address codebase management challenges for many types of ML projects.
These projects advertise themselves as a way to make deep learning much easier to accomplish and more accessible to the masses, and while this is technically true, it’s important to point out that in this case we aren’t talking about GUI-based approaches to ML/DL such as Lobe, KNIME or even building lambda function-based models. Instead, tools in this category seek to holistically reduce the programming load of data scientists by providing higher level text-based interface with which to specify a model’s configuration.
Both Ludwig and AllenNLP leverage the JSON format as a way to allow for custom configuration of a model architecture/approach, while still enforcing a standard structure, which is needed in order to provide abstraction. Ludwig offers YAML as the primary user interface, which is then used to generate JSON model specifications. AllenNLP uses jsonnet for the same purpose. Ludwig does also feature a programmatic API, and many of AllenNLP’s core capabilities can easily be integrated/extended to existing software projects.
Fast.ai takes a different approach, relying heavily still on its users to develop models directly in Python. However, through both the library’s built in functions, as well as the project’s well documented DS practices, management of the codebase supporting a model is much simpler.
These projects are also showing high levels of adoption with the older AllenNLP Github boasting over 100 contributors and 6,000 stars. Ludwig, though only recently released, has nearly 4,500 stars at the time of this article and has strong support within Uber’s extended AI community. Because fast.ai is also paired with a human learning course, it also boasts a large community (over 13,000 stars and hundreds of contributors).
Increasing Data Scientist productivity is the primary benefit of low-code ML tools, but not the only one. In addition to making it faster to experiment, these tools also seek to provide a repeatable and structured way to capture experiment results as well. Both toolchains automatically log the details of each training run into a pre-specified directory/file hierarchy. Once one is comfortable with this structure it’s easy to pinpoint key moments in the experimentation process for further analysis or configuration.
In addition, since these low-code toolboxes are essentially built on top of well-maintained deep learning libraries (PyTorch and Tensorflow), it’s easy to take advantage of other adjacent capabilities like TensorBoard to visualize/inspect models.
As discussed above, the developers of low-code ML tools make a lot of assumptions about how these tools will be used. These assumptions are wide ranging, due to the level of abstraction provided. One of the most important assumptions concerns how input data will be structured and preprocessed. For example, Ludwig’s standard toolchain expects data to be formatted into CSV, and currently only supports a limited number of datatypes and preprocessing functions. While it is of course possible to extend the supported datatypes and preprocessing steps, you will need to write some code to do so. Users who lack this skillset or become complacent during the experiment design process might run into trouble here.
A primary component of many modern deep learning approaches is transfer learning (TL). The benefits of this technique are plentiful and well-documented. However, there is an inherent tradeoff to employing TL: it’s sometimes impossible to know exactly on what and how someone else’s model was trained, and thus very difficult to be sure if that model (or any derivative models) are fair, without inspection. Though the lack of automatic in-depth fairness analysis is not unique to the low-code toolboxes we are exploring, it’s worth noting that just because experimentation and training processes are easier, one shouldn’t assume the outputs are fair.
There are still no tools which replace a solid conceptual foundation in ML and software development. However, for experienced practitioners, low-code toolboxes can help make the data science process much easier and faster.
More from the Blog
May 29 2019
by — The goal in open-ended text generation is to create a coherent portion of text that is a continuation from the given context. For example, given a couple of sentences, this capability makes it possible for machines to self-write a coherent story. One can imagine using such a system for AI-assisted writing, but of course it can also be repurposed to generate misleading (fake) news articles. Ovi...
Jul 8 2019
by — Active learning, which we explored in our report on Learning with Limited Labeled Data, makes it possible to build machine learning models with a small set of labeled data. The typical simplified workflow when tackling a supervised machine learning problem is to i) locate the data, ii) create labels for all available data (the more the merrier), and iii) build a model. Instead of labeling all a...
Jul 17 2019
by — We’ll be discussing this research as part of our virtual event on Wednesday, July 24th at 10:00am PT (1:00pm ET). Register for the event here. Machine learning powers systems that can translate language, guide searches, and interact with humans. All around us we are seeing automated systems that are getting better and better at processing natural language. Machines that can work directly wi...