# RMDL: Random Multimodel Deep Learning for Classification > RMDL trains several randomly structured DNN, CNN and RNN classifiers in parallel and combines their outputs. It is a research artifact for people who want a working ensemble baseline rather than a maintained library. **kk7nc/RMDL** — RMDL: Random Multimodel Deep Learning for Classification - Repository: https://github.com/kk7nc/RMDL - Website: https://rmdl.readthedocs.io/ - Stars: 426 · Forks: 119 - Language: Python - License: GPL-3.0 - Published: 2026-09-10 · Updated: 2026-09-10 · Language: en - Canonical page: https://hysenlabs.com/projects/kk7nc-rmdl ## 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. ## 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. ## FAQ ### What exactly does the RMDL architecture combine? Three randomly constructed models trained in parallel: a DNN classifier, a deep CNN classifier, and a deep RNN classifier whose recurrent unit can be LSTM or GRU. Each model is built with a random number of layers and a random number of nodes, and their results are combined. ### How do I install RMDL and its dependencies? The git path is `git clone --recursive https://github.com/kk7nc/RMDL.git`, and the correct pip form for the requirements file is `pip3 install -r requirements.txt`. The other two published variants in the documentation are malformed, and the conda form does not accept a pip requirements file. ### Which version of RMDL will I get from a package index? The most recent tagged release is 1.0.9, published 2020-12-07, while the packaging file in the default branch declares version 1.0.8. The default branch itself was last pushed on 2026-04-22, so a package install trails the branch by roughly five years. ### What GPU setup does RMDL document? CUDA Toolkit 8.0 with matching NVIDIA drivers, cuDNN v6, a GPU with CUDA Compute Capability 3.0 or higher, and the `libcupti-dev` library. The page lists no newer toolkit or library version as an alternative. ### Which datasets do the RMDL examples cover? The examples target CIFAR-10, MNIST, IMDB, Reuters-21578, 20Newsgroups, three Web of Science variants and the Olivetti faces data, and one script targets LFW, which the dataset documentation does not describe. The text classification instructions break off while pointing at a GloVe download. ## Sources - [kk7nc/RMDL on GitHub](https://github.com/kk7nc/RMDL) - [License: GPL-3.0](https://github.com/kk7nc/RMDL/blob/master/LICENSE) - [Project website](https://rmdl.readthedocs.io/) - [README](https://github.com/kk7nc/RMDL/blob/master/README.md) - [Releases](https://github.com/kk7nc/RMDL/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kk7nc-rmdl