Image classification example in Python

Python is a widely used programming language that is very popular in computer vision and image processing. In this article, we will explore image classification examples in Python. Image classification is a fundamental task in computer vision that involves identifying objects or scenes in images. This article will introduce how to use the deep learning framework Keras in Python to implement the training and prediction of image classification models.

Preparation

Before performing image classification, we need to install the necessary software packages. Here is a list of necessary packages:

• Python 3.x
• Keras
• TensorFlow
• NumPy
• Pillow

You can use the pip tool to install the above software packages. Execute the following command on the command line to install the necessary software packages:

pip install keras
pip install tensorflow
pip install numpy
pip install Pillow

Dataset

Before doing image classification, we need a data set. A dataset refers to a set of annotated images that are used to train and test image classification models. In this example, we will use the MNIST dataset. The MNIST dataset contains images of handwritten digits and is a widely used dataset for testing the performance of image classification algorithms.

The MNIST data set contains 60,000 training images and 10,000 test images, each image is 28x28 pixels in size. The pictures have been labeled with one of 10 numbers from 0 to 9.

In Keras, you can use the following code to download the MNIST dataset:

from keras.datasets import mnist

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

Build the model

Before building the image classification model, we need to define the architecture of the model. In this example, we will use a convolutional neural network (CNN) model. The CNN model is a deep learning model that performs well in image classification.

Keras provides an easy way to build CNN models. The following is the code for an example CNN model:

from keras import layers
from keras import models

model = models.Sequential()

model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Flatten())

model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

model.summary()

In the above code, we define a CNN model containing two convolutional layers and two max pooling layers. The model also includes two dense layers, each using the ReLU activation function.

Training model

After defining the model, we need to train the model. During training, the model learns how to map input images to the correct numeric categories.

In Keras, the following code can be used to compile and train the model:

model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

train_images = train_images.reshape((60000, 28, 28, 1))
train_images = train_images.astype('float32') / 255

test_images = test_images.reshape((10000, 28, 28, 1))
test_images = test_images.astype('float32') / 255

from keras.utils import to_categorical

train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

model.fit(train_images, train_labels, epochs=5, batch_size=64)

In the above code, we first preprocess the image and then compile the model with the optimizer as " rmsprop", a model whose loss function is cross entropy. We then use the training images and labels to train the model. At the end of each epoch, we test the model using test images and labels.

Test the model

After the model training is completed, we can use the test data set to test the accuracy of the model. The model can be tested using the following code:

test_loss, test_acc = model.evaluate(test_images, test_labels)
print('test_acc:', test_acc)

Next, we can make predictions using the following code:

predictions = model.predict(test_images)

import numpy as np

print(np.argmax(predictions[0]))

In the above code, we predict the first image of the test image set , then use Numpy to find the maximum index value and print the prediction results.

Conclusion

In this article, we introduced how to use the deep learning framework Keras in Python to implement the training and prediction of image classification models. We use the MNIST dataset for testing and the CNN model for training. Finally, we test the model's accuracy by making predictions on a test image set. This example can be used as an introductory example of deep learning and computer vision, allowing beginners to understand how to use Python to implement image classification tasks.

The above is the detailed content of Image classification example in Python. For more information, please follow other related articles on the PHP Chinese website!