Recent developments in machine learning have ushered in an era of unprecedented opportunities for data scientists. Tools such as K-Nearest Neighbors, Naïve Bayes, Logistic Regression, and Random Forest are no longer limiting factors in algorithmic success.

Many companies now use these tools effectively in their production ML models due to their ease of use and accuracy. However, most people who use pre-packaged algorithms do so with little or no understanding of how they work under the hood.

This is problematic because it can be difficult to tell whether the model’s predictors were effective due to chance alone, or if there was truly significant correlation between them and the outcome.

Furthermore, even when predicting only one binary target (yes/no), many people lack formal training in probability theory, which makes interpreting prediction intervals quite tricky.

Luckily, this article will take you through all of that! You will learn how to build your own k-nearest neighbors classifiers, naïve bayesian classifiers, logit regression models, and tree ensemble classification methods using the powerful open source software package called PyTorch.

You will also get some insights into why certain architectures perform better than others, along with tips and tricks for improving the performance of your models.

Create a model

A very common use case for keras models is creating an architecture that can be trained using either backprop or gradient descent with stochastic optimization.

With backprop, you learn by taking steps in the opposite direction of the error, which means if your model is not working, trying changing what part of the model you are training!

Stochastic optimization uses different parts of the model at each iteration, so even if some parts do not work, there’s still potential to get good results since another part may. This also allows us to apply regularization (limiting overfitting) because we are limiting only one component of our model instead of every single layer as normal.

In this article, we will create a simple convolutional neural network (CNN) to recognize images of buildings. Because it is a relatively small dataset, we will evaluate test accuracy both on the full set and then after jittering, or adding random noise, to see how well the model performs overall.

We start by defining our base CNN architecture. Here, we define our number of input layers, batch size, learning rate, and other hyperparameters. We choose a VGG-16 style network configuration due to its simplicity and popularity.

After that, we build up our model by stacking additional blocks onto our initial structure.

Compile the model

The second step in developing your architecture is compiling it! This process takes away some of the work from you so that you do not have to worry about it. Once compiled, this will create a file that can be run or configured.

When you develop an architecture yourself, it is important to compile it at least once before deploying it into production. By doing this, you take control over when changes are made to the code and how frequently they are updated.

There are many different ways to compile models in Keras. Some people like to use the functional API while others prefer using the sequential API. This article will go more in depth with the sequential API as that is what most beginners start out learning first.

Test the model

The next step in developing your architecture is testing it! Once you have finished training your network, you can test how well it works by feeding it an example image or set of images and seeing what it outputs.

There are several ways to do this, but the most common way is to use the Inception V3 Network as our base network and design layer structure. You can check out our article here for more information about using that network as a starting point.

Once you have designed your network, you will need to pick some appropriate test data to evaluate it on. If you use the same dataset used during training, the network may overfit the data which could result in poor accuracy and/or incorrect predictions.

That’s why we recommend using one of two datasets for evaluation. Either the *Imbrium-Webcam* collection or the *UrbanCam* collection. These two collections include high resolution (up to 1080p) video files of natural environments such as landscapes, buildings, cars, etc.

We chose the second Urban Cam collection because there are around 10 different scene types within each file, making it more diverse than just having a single environment like the first collection.

Use the model

One of the most fundamental concepts in AI is understanding what kind of computer program or algorithm you want to use!

In this article we’ll go over how to print an architecture for your neural network using keras, which is one of the most common deep learning libraries out there.

After that, we'll take a look at some different types of architectures and why they're useful.

Save the model

It is important to save your model so that you do not lose all of its information when it is no longer active. When designing or developing an algorithm, there are often times where you will need to remove some components or features, close down the program, and then reopen it later.

If you do not have this process pre-prepared, all of your previous work can be lost! The same goes for if something goes wrong and you have to restart.

There are several ways to save your trained neural network. You can choose to use PyTorch’s built in torch.save() function, TensorFlow’s saver module, or one of the many other dedicated saving modules out there.

For our purposes here, we will be using Torch’s built in functions to create and load our saved models. To begin, open up your favorite Python notebook or script and add the following lines at the very end:

torch.save(model_name, model.state_dict())

Where model_name is your current name for your trained neural net, and state_dict()is the dictionary representation of your net (this includes all layers, weights, etc).

Create a new project

So let’s get started! First, you will need to create an empty project using either PyCharm or Eclipse. You can name the project anything you want, but we will refer to it as “Architecture-Keras-Printing” in this article.

Once your project is created, go into Settings > Plugins and install both of the plugins mentioned below. Make sure you update each one immediately after installation!

Now that those are installed, make sure both have at least check marks next to Activate and Refresh. Once done, close any open windows and launch the software again!

Settings -> Plugins -> Check mark (activate) -> Refresh (immediately afterwards) Now that they are active, take some time to configure how each plugin functions!

For these two plugins, there isn’t much configuration needed beyond making them work. After that, you can safely leave them alone and focus more on developing your model!

Thank you for reading our article! We hope it helps you develop your skills and/or learn something new about programming.

Install the library

In order to use this tool, you will need to first make sure that you have installed the software package correctly. The link we shared above contains all of the information needed to do so!

Once the installation is completed, you can now access the program via your computer or device by navigating to modelarchitecture.com. You will then be asked for permission to install the app onto your device which has been verified as compatible with keras. If this is okay, tap “Download” and enjoy!

This article should not be mistaken as an endorsement of the paid version of the app, however, it does clearly state how to get started using free accounts which are enough to create simple architectures and evaluate them.

Create a new project using the library

If you have done some basic programming before, then creating a model with Keras should be pretty easy for you! Creating a model is no different than any other software like Photoshop or Microsoft Office. You can create your own models by just taking an already-made one as a template and editing it!

Keras allows you to easily use their pre-built architectures as templates. All they ask is that you change the number of layers in the network and what layer properties are set (like activation functions and dropout ratios). They even make sure all of the layers are properly connected so you know what comes after what.

They also release very detailed documentation and examples showing how to do every part of the architecture. This makes it very easy to understand how to use their networks as templates!

There are many ways to use this feature in Keras, such as building upon another network’s structure, creating new structures from scratch, adding onto an existing structure, and more.