In this chapter, we will work on a sample model, built using Python in a Jupyter notebook. Jupyter is an open source technology that allows you to create interactive web pages that contain sections of Python code, Markdown, and HTML. It makes it much easier to document your code and assumptions you made while building your deep learning model.

If you've installed Anaconda using the steps defined in Chapter 1, Getting Started with CNTK, you already have Jupyter installed on your machine. Should you not have Anaconda yet, you can download it from: https://anacondacloud.com/download.

You can get the sample code for this chapter from: https://github.com/PacktPublishing/Deep-Learning-with-Microsoft-Cognitive-Toolkit-Quick-Start-Guide/tree/master/ch2. To run the sample code, run the following commands inside a Terminal in the directory where you downloaded...

In the previous chapter, we looked at the basic concepts of a neural network. Let's map the concepts we've learned to components in the CNTK library, and discover how you can use these concepts to build your own model.

Neural networks are made using several layers of neurons. In CNTK, we can model the layers of a neural network using layer functions defined in the layers module. A layer function in CNTK looks like a regular function. For example, you can create the most basic layer type, Dense, with one line of code:

from cntk.layers import Dense
from cntk import input_variable

features = input_variable(100)
layer = Dense(50)(features...

Now that we've learned what concepts CNTK offers to build a neural network, we can start to apply these concepts to a real machine learning problem. In this section, we'll explore how to use a neural network to classify species of iris flowers.

This is not a typical task where you want to use a neural network. But, as you will soon discover, the dataset is simple enough to get a good grasp of the process of building a deep learning model. Yet it contains enough data to ensure that the model works reasonably well.

The iris dataset describes the physical properties of different varieties of iris flowers:

• Sepal length in cm
• Sepal width in cm
• Petal length in cm
• Petal width in cm
• Class (iris setosa, iris versicolor, iris virginica)

Now that we have all the components for the deep learning defined, let's train it. You can train a model in CNTK using a combination of a learner and trainer. We're going to need to define those and then feed data through the trainer to train the model. Let's see how that works.

There are several learners to choose from. For our first model, we are going to use the stochastic gradient descent learner. Let's configure the learner and trainer to train the neural network:

from cntk.learners import sgd
from cntk.train.trainer import Trainer

learner = sgd(z.parameters, 0.01)

trainer = Trainer(z, (loss, error_rate), [learner])

To configure...

One of the most satisfying things after training a deep learning model is to actually use it in an application. For now, we'll limit ourselves to using the model with a sample that we randomly pick from our test set. But, later on, in Chapter 7, Deploying Models to Production, we'll look at how to save the model to disk and use it in C# or .NET to build applications with it.

Let's write the code to make a prediction with the neural network that we trained:

sample_index = np.random.choice(X_test.shape[0])
sample = X_test[sample_index]

inverted_mapping = {
    1: 'Iris-setosa',
    2: 'Iris-versicolor',
    3: 'Iris-virginica'
}

prediction = z(sample)
predicted_label = inverted_mapping[np.argmax(prediction)]

print(predicted_label)

Follow the given steps:

1. First, pick a random item from the test set using...

You will quickly learn that building and training neural networks takes more than one attempt. Usually, the first version of your model will not work as well as you hope. It requires quite a bit of experimentation to come up with a great model.

A good neural network starts with a great dataset. In nearly all cases, better performance is achieved by using a proper dataset. Many data scientists will tell you that they spend about 80% of their time working on a good dataset. As with all computer software, if you put garbage in, you will get garbage out.

Even with a good dataset, you still need to spend quite some time to build and train different models before you get the performance you're after. So, let's see what you can do to improve your model after you've built it for the first time.

After you've trained the model for the first time,...

In this chapter, we've built our first neural network and trained it to recognize iris flowers. While this sample is really basic, it shows how to use CNTK to build and train neural networks.

We've seen how to use the layer library in CNTK to our advantage to quickly define the structure for our neural network. In this chapter, we've talked about a few basic building blocks, such as the Dense layer and the Sequential layer, to chain several other layers together. In the coming chapters, we will learn other layer functions to build other types of neural networks such as convolutional networks.

In this chapter, we've also discussed how to use learner and trainer to build a basic algorithm to train our neural network. We've used the train_minibatch method, together with a basic loop, to construct our own training process. This is a pretty simple...