Hello, there! You have done a fantastic job with preprocessing the Iris dataset. Now, it's time to apply what you've learned by building a multi-class classification model using TensorFlow. We will guide you through each step of constructing and training this model specifically for our problem. We'll also unpack the history object returned by the model's training process. You're in good hands. Let's get started.

Before we start building our multi-class classification model, we need to load our preprocessed dataset. To maintain modular code, we use the load_preprocessed_data function from our previous lesson, stored in data_preprocessing.py. This function handles loading, splitting, scaling, and one-hot encoding the Iris dataset, providing the data in a format that is ready to train our model.

Load the preprocessed dataset:

Here's a brief recap of the data_preprocessing.py:

With the dataset loaded, we're ready to build our multi-class classification model.

The next step is building our multi-class classification model. TensorFlow makes it easy for us to construct models using the Sequential API which allows us to create models layer-by-layer.

Our input shape aligns with the four features (sepal length, sepal width, petal length, petal width) in our Iris dataset. The model includes two dense layers, each having 10 neurons and ReLU (Rectified Linear Unit) as the activation function, which will help us introduce non-linearity into our model. Finally, we have an output layer with three neurons representing our three Iris species.

Our output layer uses the softmax activation function, which helps in multi-class classification problems by converting the raw output scores (logits) into probabilities. Softmax takes the output of each neuron and turns it into a probability between 0 and 1, with all probabilities adding up to 100%. Essentially, it tells us the likelihood that the input data point belongs to each of the three classes (Iris species) we have in our dataset. The class with the highest probability is selected as the model's prediction.

Before we can train our model, we need to compile it. Compiling the model signifies that we're set with the architecture and ready to smooth the weights to better predict our data.

Let's compile our model:

We use the adam optimizer — a combination of RMSprop and Stochastic Gradient Descent with momentum. It adapts the parameter learning rates based on the average of recent weight updates. For the loss function, we're using categorical_crossentropy, which suits multi-class classification problems. And finally, we're using accuracy as our evaluation metric.

Now comes the moment of truth — training our model on our preprocessed Iris dataset. Training involves the iterative process of feeding our data through the model (forward propagation), calculating an error (loss), and back-propagating through the model to adjust the weights.

We will use our test set as a validation set to monitor the performance of the model on unseen data during training. The validation set is not used to train the model; it is only used to evaluate the model's performance each epoch to ensure it generalizes well to new data.

Let's train our model:

We use the fit method for training. We're training for 150 epochs, meaning the entire dataset will pass through the model 150 times. We've set a batch size of 5, which means that after the model has seen 5 samples, it will update the weights. We also pass in our test data for validation.

You might have noticed that model's fit method returned an object called history. But what exactly is it? history is an object that TensorFlow provides out of the box and contains a record of training loss values and metrics values at successive epochs, along with validation loss values and validation metrics values (if applicable). Analyzing its values can help us understand the training process and possibly diagnose issues (such as overfitting). Let's see how to extract the data from this object:

The output of the above code will have following format:

This output summarises the model's performance over 150 epochs, showing accuracy and loss for both training and validation data sets. This kind of data is crucial for understanding how well our model is learning and generalizing to new data.

Great job! You've learned how to build, compile, and train a TensorFlow multi-class classification model and how to interpret training results through the history object. Continue practicing these steps with the following coding exercises to solidify what you learned. Stay tuned for more lessons that will expand your TensorFlow and machine learning capabilities. Keep up the great work!