{"id":4150,"date":"2026-02-27T03:49:02","date_gmt":"2026-02-27T08:49:02","guid":{"rendered":"https:\/\/blogs.mathworks.com\/matlab\/?p=4150"},"modified":"2026-02-27T03:49:02","modified_gmt":"2026-02-27T08:49:02","slug":"building-an-app-for-training-deep-learning-models-with-app-designer","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/matlab\/2026\/02\/27\/building-an-app-for-training-deep-learning-models-with-app-designer\/","title":{"rendered":"Building an app for training deep learning models with App Designer"},"content":{"rendered":"
Today's guest blogger is Phil Brown. Phil is a development lead on the Deep Learning Toolbox, working on app development. In this blog post he describes how to build an App Designer app for training deep neural networks to classify images. This post covers building more advanced apps with App Designer, including thinking about architecture, unit and system testing.<\/span><\/div>

The Problem<\/span><\/h2>
Deep neural networks are excellent at classifying images - whether that's pictures of <\/span>cute dogs<\/span><\/a>, images from a production line for <\/span>automated quality control<\/span><\/a>, or <\/span>sequences converted to spectrograms <\/span><\/a>to predict whether a machine is running smoothly.<\/span><\/div>
\"\"<\/img><\/div>
Learning how to use a deep neural network to classify images is often how people get started with deep learning. It's easy to understand the problem, very visual - '<\/span>The network says this is a golden retriever because of its lustrous floppy ears!<\/span>' - and quick and easy to get started. You can use a pretrained neural network like <\/span>GoogleNet<\/span><\/a> or a <\/span>Vision Transformer<\/span><\/a>. With <\/span>transfer learning<\/span><\/a> (fine-tuning a neural network already trained on a large dataset on your own data), you can teach a large and powerful model to classify your labelled images, without spending hours or days building models from scratch.<\/span><\/div>
We wanted to provide a way for users to get started with deep neural networks with MATLAB's Deep Learning Toolbox, using a fun app for image classification built with <\/span>App Designer<\/span><\/a>. The app lets you load and visualize your data, modify existing networks or build your own using the <\/span>Deep Network Designer app<\/span><\/a>, train the network, understand network productions with interpretability, and finally generate MATLAB code for reproducing and sharing your training workflow. The Image Classifier app is <\/span>available now<\/span><\/a> on <\/span>MATLAB Deep Learning GitHub<\/span><\/a>. This post goes into some of the considerations we had along the way.<\/span><\/div>
\"\"<\/img><\/div>

Working out the requirements<\/span><\/h2>
In building an image classification app, we knew we needed the standard pieces of this workflow available in Deep Learning Toolbox: import and augment image data, choose a network and adapt it to your data, configure training options, train the network, interpret the results, and share the code. Given this workflow, we also tried to work out what other requirements we were trying to meet.<\/span><\/div>
We needed the app to be <\/span>easy to use<\/span>. We wanted someone new to deep learning to be able to get started quickly and easily, without needing to worry about any of the harder stuff like network architectures or minibatch sizes.<\/span><\/div>
We wanted the app to make use of <\/span>existing cool features in MATLAB<\/span>, like the Deep Network Designer app. This app in Deep Learning Toolbox lets you build neural networks from scratch with a drag-and-drop interface, or choose existing networks like GoogleNet and modify them for transfer learning onto your new data. You can also use it to <\/span>import networks<\/span><\/a> from PyTorch or TensorFlow.<\/span><\/div>
We wanted to <\/span>showcase how users could do this themselves<\/span>. We've talked to a few Deep Learning Toolbox users who have built their own apps for model training, usually with <\/span>App Designer<\/span><\/a>. This lets them build really focused apps which exactly meet the needs of their research group or team. We were trying to demonstrate how to do that for the simple case of image classification, to provide ideas users might want to put in their own apps.<\/span><\/div>
We therefore wanted users to be able to <\/span>edit and modify our code<\/span>. People might want to use ideas in their own apps, or extend this app with their own features. For example, a good project for an undergraduate learning about <\/span>interpretability and explainable AI<\/span><\/a> would be to integrate a new explainability method into the app, or a research group might have their own customized deep neural networks which they want to support for transfer learning. <\/span><\/div>

Using App Designer to build apps<\/span><\/h2>
When we build large apps with the product, like Deep Network Designer, they're authored by a team of contributors with the expectation of long lifetimes. That usually means investing heavily in architecture and testing from the start. Those constraints are important for product-scale software, but not always the right start point for something more focused. Code written this way is more for other developers.<\/span><\/div>
For the Image Classifier app, our goal was a bit different. We wanted the code to be readable, adaptable and useful as a starting point for other users building their own MATLAB apps. App Designer was a natural fit; it lets you construct the UI quickly while still writing structure code behind the scenes where needed.<\/span><\/div>
\"\"<\/img><\/div>

Separating model and view<\/span><\/h2>
Apps often have complicated non-linear workflows, and users like to interact with them in ways we haven't foreseen as developers! This can mean lots of bugs<\/span> <\/span>if you're not careful with how the code is structured.<\/span><\/div>
For apps that ship with MATLAB or the toolbox, we think about how to structure code so we can isolate issues and make it easier to extend the app in the future. This means using splitting code up with patterns like <\/span>model-view-controller<\/span><\/a> (or other variants like 'model-view-viewmodel'). That makes it easier to make changes or bug fixes to the app, and also to write automated tests which verify the app works as you want.<\/span><\/div>
\"\"<\/img><\/div>
We wanted to retain the benefits of these ideas, without writing something that required extensive software engineering knowledge to modify. We chose a lightweight separation of concerns. The App Designer file handles the UI and interaction logic, while a separate <\/span>Model<\/span> class contains the core network, training and data processing functionality. This hybrid approach keeps the code understandable and easy to modify, while enabling more unit and system testing. Depending on the scale and complexity of your app, you should consider where it needs to live on the spectrum of architecture and testability.<\/span><\/div>

Testing apps in MATLAB<\/span><\/h2>
Testing apps can be a challenging topic (but luckily MATLAB makes it pretty easy). So what's the point of doing it? There's two big reasons it's worth writing tests for your apps:<\/span><\/div>