TDM 30200: Project 05 - Computer Vision: Image Classification

In this project, we will continue to use our dataset of high quality ice cream images. If you look through this folder of images, you should notice that there are primarily 3 different types of ice cream images: Scoops of ice cream in a bowl, ice cream bars, and cutouts of pines of ice cream. We will build a classifier to classify these images into one of these three categories.

To make things easier for you, here is a dictionary containing the file names grouped into their correct labels:

Our first step is to load all of these images into a simple dataset. Please load all images into a dictionary named labeled_images_loaded of the same format as above, but instead of the file names, store the actual images. We recommend using the cv2.imread() function to load the images.

After your done, please run the below 2 blocks of code to ensure that your code is correct:

Block 1:

Block 2:

If you look at what these code blocks are doing, you can see that one part is outputting the shape of the first image in each category, and the other part is displaying the first image in each category. If you are observant, you may notice that the select scoop image is smaller than the other images. Additionally, if you investigate the size of each image in each category, not all of them are the same size either. If we were to train a model directly on these images, the model may be confused by the different image sizes, so it is a good idea to resize all of the images to the same size. Another reason we may want to resize the images is to reduce the amount of computation required to train the model. Larger images have more pixels which means more computations, exponentially so. Please resize all of the images to be 128x128 pixels. Please place these results into a new dictionary named labeled_images_resized of the same format as labeled_images_loaded.

After your done, please run the below block of code to ensure that your code is correct (if it is correct, no output will be produced):

Then, output the resized images using the below block of code:

Now that our images are the same size, we need to convert them into a format that our model can understand. Firstly, we need to flatten the image into a 1D array. Then, we need to convert our label: image array format into an array of images: array of labels format. This can be accomplished with the below code block. Please fill in the missing code:

Now that your data is in the correct format, let’s train our classifier. It’s been a while since we’ve looked at machine learning, but hopefully you remember the extremely extremely important idea of train/test split. Last semester, we used the train_test_split() function from sklearn.model_selection to split our datasets into training and testing sets. This function randomly splits the dataset into these two sets, however it does not guarantee that each class will be represented equally in each set by default. If you recall from Question 1, the number of images in each category varies greatly. In order to ensure that our splits are representative of the entire dataset, we need to stratify our split. For example, if our split was 80% training and 20% testing, we would want 80% of the scoop images, 80% of the bar images, and 80% of the cutout images in the training set, and the remaining 20% in the testing set. This can be accomplished by setting the stratify parameter in train_test_split() equal to the labels array you just created. Please use train_test_split() to split the data into training and testing sets, with 80% of the data in the training set and 20% in the testing set, using a random_state of 60. Save the results into variables named train_images, test_images, train_labels, and test_labels.

To ensure that your code is correct, please print out the length of the train and test sets, as well as the shape of the first image in each set.

Now that we have our train/test split, let’s train a simple classifier. We will use the cv2.ml.KNearest_create() function to create a k-nearest neighbors classifier. Then, we will train the classifier using the train() method. Please read and run the below code block:

How well did the model perform? If you did everything correctly, you should have gotten a model with a pretty high accuracy (The accuracy may vary depending on how you split the data, particularly the order in which you shuffle the data).

Now that we have a working model, let’s see how efficient our model is. Please use the time library to measure the time it takes to train the model, and the time it takes to test the model. Save these in variables named train_time_color and test_time_color respectively. Please print out these values.

Now that we’ve seen how our model performs with color images, let’s lower the amount of data even further by converting the images to grayscale. Please start back at the labeled_images_resized dictionary, convert all images to grayscale, save them in labeled_images_grayscale dictionary, and repeat the process from the previous question

We can even further compress our images by making them binary. We can simply use Otsu’s method to binarize the image with cv2.threshold(). Please start at the labeled_images_grayscale dictionary, binarize all images, and repeat the process from the previous question. Save the times it takes to train and test the model with Otsu’s binary images in variables named train_time_otsu and test_time_otsu respectively. Please print out these values.

After we have these 3 models, please compare the accuracy and time it took to train and test each model. Which model was the most accurate? Which model was the fastest? Which model was the slowest? Which model do you think is the best overall?