RMDL: Random Multimodel Deep Learning for Classification

The architecture search problem RMDL tries to sidestep

Picking a network depth and width for a new classification dataset is guesswork. RMDL's answer is to stop guessing and train a population of randomly configured models instead. The README describes it as training multiple DNN, CNN and RNN models in parallel and combining their results, where each model is built with a random number of layers and nodes. The stated motivation is that finding the suitable structure has been a challenge for researchers, so the ensemble absorbs that uncertainty rather than resolving it. The intended audience is researchers and practitioners working on text, image, video or symbolic classification who want a general procedure rather than a tuned architecture. The repository's own evaluation covers MNIST and CIFAR-10 for images, WOS, Reuters, IMDB and 20newsgroup for text, and the ORL face database. That spread is the point: one configuration is meant to travel across data types.

What the random ensemble actually contains

The README's architecture figure names three random models: a oneDNN classifier, a deep CNN classifier and a deep RNN classifier, where each recurrent unit may be an LSTM or a GRU. Randomness enters at the structural level, in layer count and node count, not in the weights, which are learned normally. The three families see the same labelled data and their outputs are combined into a single prediction. This is a heterogeneous ensemble, so the diversity comes from architecture type rather than from bagging or different feature subsets. For text, the README points at GloVe embeddings as the input representation, which means the pipeline expects a pretrained vector file before any model can be trained. The practical consequence is that RMDL is not a drop-in scikit-learn estimator over raw strings: you supply numeric or embedded inputs, and you supply the label set. The paper links in the README (arXiv 1805.01890 and 1808.08121) are the reference for how many models are trained and how their votes are combined, and the repository does not restate those hyperparameters in the README text itself.

Installation and the dependency trap

Two install paths are documented. The pip route is a single command:

pip install RMDL

The source route clones with submodules:

git clone --recursive https://github.com/kk7nc/RMDL.git

Requirements are then installed from the pinned file, and the README offers three equivalent forms:

pip -r install requirements.txt pip3 install -r requirements.txt conda install --file requirements.txt

Note that the first form as written places -r after pip, which is not valid pip syntax; use the pip3 form or conda. The stated baseline is Python 3.5 or later plus TensorFlow, scikit-learn, Keras and scipy. GPU support is documented against CUDA Toolkit 8.0, cuDNN v6, a card with compute capability 3.0 or higher, the matching NVIDIA drivers, and libcupti-dev. Those are old targets. A modern TensorFlow install will not match them, and the README does not describe a CPU-only fallback configuration beyond omitting the GPU section. Budget time for environment work before you budget time for modelling.

Where RMDL stops being the right tool

The ensemble design has a direct cost: you train many models instead of one, so wall-clock time and memory scale with the population size, and the README gives no guidance on how large that population should be for a given dataset. On small or heavily imbalanced label sets, a random architecture draw can produce a model that never predicts the minority class, and the README does not document per-model validation or pruning of weak members. There is also no documented inference API for exporting a trained ensemble to a serving format; the material describes training and evaluation on the named benchmark datasets, not deployment. If your problem is tabular with a few dozen columns, gradient boosting on the same features is faster to train and easier to explain, and RMDL's CNN and RNN members have little to work with. Finally, the release history is a limitation in itself: 1.0.9 shipped in December 2020, and the two releases before it were 1.0.8 in July 2020 and 1.0.7 in June 2018. That cadence tells you what to expect from bug reports.

How this differs from AutoKeras and from plain scikit-learn ensembles

The closest genuine alternative in spirit is AutoKeras, which also searches over neural architectures but does so by optimising a search objective and returning a single best model. RMDL does not search toward a winner; it fixes a population of randomly drawn architectures and averages them. That is a real methodological difference with consequences: AutoKeras spends compute on evaluation to concentrate on one architecture, while RMDL spends compute on training every member and keeps them all. If you want one deployable network, the search approach is the better fit. If you want a variance-reduced predictor and do not mind carrying the whole ensemble, RMDL's approach is defensible. Against scikit-learn's RandomForestClassifier or GradientBoostingClassifier, the difference is representation: those operate on the feature matrix you hand them, whereas RMDL's CNN and RNN members learn representations from sequences and images. On the text datasets the README lists, that is the reason to prefer RMDL; on dense tabular data it is the reason not to.

Maintenance, licence and what to check before committing

RMDL is GPL-3.0. That is a copyleft licence, and it is worth reading in full before you link the library into anything you distribute, because the obligations differ from permissive licences like MIT or Apache-2.0. Nothing here is legal advice; if your product ships RMDL code, talk to someone qualified. On maintenance, the material shows a project whose last release was 1.0.9 in December 2020, with the repository still receiving pushes (most recently April 2026) but no new tagged release in the window covered. The README still lists CUDA 8.0 and cuDNN v6, which no current TensorFlow build targets, so the upgrade cost is not a version bump: it is re-establishing a working TensorFlow and Keras pair against code written for an older API. Before you invest, run the install in a throwaway environment, confirm that the text path can load GloVe vectors, and train one small ensemble on a dataset you already understand so you can tell a modelling failure from an environment failure.

Editorial conclusion

Adopt RMDL if you are reproducing the paper, teaching ensemble behaviour, or want a quick multi-architecture baseline on a labelled dataset and can pin TensorFlow 1.x era dependencies. Do not adopt it for production serving or for anything needing active maintenance: the last release, 1.0.9, dates from December 2020, and the requirements list CUDA Toolkit 8.0 and cuDNN v6. Verify first that your TensorFlow, Keras, CUDA and Python versions can satisfy requirements.txt, and that the GPL-3.0 licence is acceptable for how you intend to distribute the result.

Official sources

1. kk7nc/RMDL on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases