Image processing with CNN | Beginner's guide to image processing (2023)

The images contain data of an RGB combination. Matplotlib can be used to import an image from a file into memory. The computer doesn't see an image, it just sees a number field. Color images are stored in three-dimensional arrays. The first two dimensions correspond to the height and width of the image (the number of pixels). The final dimension corresponds to the red, green and blue colors present in each pixel.

Three CNN shifts

Convolutional Neural Networks, specialized in image and video recognition applications. CNN is mainly used in image analysis tasks such as image recognition, object recognition, and segmentation.

There are three types of layers in convolutional neural networks:

1) Convolutional Layer: In a typical neural network, each input neuron is connected to the next hidden layer. In CNN, only a small part of the neurons in the input layer are connected to the hidden layer of neurons.

2) Pooling layer: The pooling layer is used to reduce the dimensionality of the resource map. Within the hidden layer of CNN, there will be several layers of activation and grouping.

3) Fully connected layer:fully connected layersform the lastTo herIn the net. the entrance tofully connected layeris the output of the final or convolutional poolcapa, which is flattened and then inserted into thefully connected layer.

Source: Google Images

registro MNIST

In this article, we examine object detection in image data using the MNIST handwritten digit recognition dataset.

The MNIST dataset consists of digit images from a variety of scanned documents. Each image is a 28x28 pixel square. In this data set, 60,000 images are used to train the model and 10,000 images are used to test the model. There are 10 digits (0 to 9) or 10 classes to predict.

Source: Google Images

Loading the MNIST dataset

Install the TensorFlow library and import the dataset as a training and test dataset.

Draw sample output image

!pip install tensorflowfrom keras.datasets import mnistimport matplotlib.pyplot as plt(X_train,y_train), (X_test, y_test)= mnist.load_data()plt.subplot()plt.imshow(X_train[9], cmap=plt.get_cmap ('grau'))

Salida:

Deep learning model with multilayer perceptrons using MNIST

In this model, we will create a simple neural network model with a single hidden layer for the MNIST handwritten digit recognition dataset.

A perceptron is a model of a single neuron that is the basic building block for larger neural networks. The multilayer perceptron consists of three layers, namely, input layer, hidden layer, and output layer. The hidden layer is not visible to the outside world. Only the input layer and the output layer are visible. For all DL models, the data must be numeric in nature.

Stage 1: import key libraries

import numpy as npfrom keras.models import Sequentialfrom keras.layers import Densefrom keras.utils import np_utils

Step 2: Refactor the data

Each image has a size of 28 x 28, that is, 784 pixels. Thus, the output layer has 10 outputs, the hidden layer has 784 neurons, and the input layer has 784 inputs. The record is then cast to the float data type.

number_pix=X_train.shape[1]*X_train.shape[2] X_train=X_train.reshape(X_train.shape[0], number_pix).astype('float32')X_test=X_test.reshape(X_test.shape[0], número_pix).astype('float32')

Step 3: Normalize the data

NN models typically require scaled data. In this code snippet, the data is normalized from (0-255) to (0-1) and the target variable is hot-coded for further analysis. The target size has a total of 10 classes (0-9)

X_train=X_train/255X_test=X_test/255y_train= np_utils.to_categorical(y_train)y_test= np_utils.to_categorical(y_test)num_classes=y_train.shape[1]print(num_classes)

Salida:

10

Now we are going to create a function NN_model and compile it.

Step 4: Define the role of the model

def nn_model(): model=Sequential() model.add(Dense(number_pix, input_dim=number_pix, activación='relu')) mode.add(Dense(num_classes, activación='softmax')) model.compile(loss= 'categorical_crossentropy', Optimizer='Adam',metrics=['accuracy']) Rückgabemodell

There are two layers, one is the hidden layer with the ReLu activation function and the other is the output layer with the softmax function.

Step 5: Run the model

model=nn_model()model.fit(X_train, y_train, validation_data=(X_test,y_test),epochs=10, batch_size=200, detallado=2)score= model.evaluate(X_test, y_test, detallado=0)print(' Der Fehler lautet: %.2f%%'%(100-score[1]*100))

Salida:

Epoch 1/10300/300 - 11s - Loss: 0.2778 - Precision: 0.9216 - val_loss: 0.1397 - val_accuracy: 0.9604 /10300/300 - 2s - Loss: 0.0726 - Precision: 0.9790 - val_loss: 0.0750_3accuracy /08 - 4val_accuracy /0 300 - 2s - loss: 0.0513 - precision: 0.9851 - val_loss: 0.0656 - val_accuracy: 0.9 0 5/ 6: 0.9 0 5/ 6 /300 - 2s - loss: 0.0376 - precision: 0.9892 - val_loss: 0.0717 - val_accuracy 73 6/10300/300 - 2 s - loss: 0.0269 - precision: 0.9928 - val_loss: 0 .0637 - val_accuracy: 0.97/300.030 Epoch - 2 s - Loss: 0.0208 - Precision: 0.9948 - val_loss: 0.000.030 Epoch - 0.02 Loss08 - 0.02 Precision: 0.9948 - val_loss : 0.00.9600 10300 /300 - 2 s - loss: 0.0153 - precision: 0.9962 - loss_val: 0.0581 - precision_val: 0.9815 - 2.030 9/s - loss: 0.0111 - precision: 0.996s31 - 0.996saccuracy - 0.996s31 - 0.906s31 -0.906s31 loss: 0.0082 - precision: 0.9985 - val_loss: 0.0609 - val_accuracy: 0.9828 The error is: 1.72 %

From the model results, it can be seen that the accuracy improves as the number of epochs increases. The error is 1.72%, the smaller the error, the higher the precision of the model.

Convolutional neural network model using MNIST

In this section, we build simple CNN models for MNIST demonstrating convolutional layers, pooling layers, and dropout layers.

Step 1: Import all required libraries

import numpy as npfrom keras.models import Sequentialfrom keras.layers import Densefrom keras.utils import np_utilsfrom keras.layers import Dropoutfrom keras.layers import Flattenfrom keras.layers.convolutional import Conv2Dfrom keras.layers.convolutional import MaxPooling2D

Step 2 – Set the seed to reproducibility and load the MNIST data

Semilla=10np.random.seed(Seed)(X_train,y_train), (X_test, y_test)= mnist.load_data()

Step 3: Convert the data to float values

X_train=X_train.reshape(X_train.shape[0], 1,28,28).astype('float32')X_test=X_test.reshape(X_test.shape[0], 1,28,28).astype('float32 ')

Step 4: Normalize the data

X_train=X_train/255X_test=X_test/255y_train= np_utils.to_categorical(y_train)y_test= np_utils.to_categorical(y_test)num_classes=y_train.shape[1]print(num_classes)

A classic CNN architecture looks like this: