DEV Community: Olaoyo Michael

Naturals Detection Using Python.

Olaoyo Michael — Sun, 23 Apr 2023 13:09:47 +0000

The earth is blessed with lots of natural phenomenons such as Forests, Glaciers and all sort. In this article, I'll be taking you through how to use computer vision to detect these things. In this article we will be detecting Forests, Glaciers, Mountains, Seas and Buildings. In this article, we shall be using a pre-trained model called VGG16 to train our model. The VGG16 is an example of a transfer learning model.

Now let’s get started with the task of detecting Naturals within an image. The most challenging task in this project is to find a dataset that includes some images that we can use to train our neural network.

Getting Datasets for the Neural Network

To get the dataset, we will use chrome extension of zip downloads which will download all the images we have from google.

First, we head to google, search for Forest, the we use the chrome extension Zip downloader to download all the images for our forest images
We go google, search for Glaciers, then use the chrome zip downloader to download all the images.

We continue in that order, till we have the five data folders needed for classification to train the neural network.
After getting all the five folders(Froret, Glacier, Sea, Buildings and Mountains), we save all these folders into a single folder which hold all the five datasets folders.

Removing Doggy Images

When we download the images from google, there are some images which will be downloaded by the extension that we dont want to feed into our network. These are called outliers. They tend to reduce the learning of our models and reduce the accuracy. We need to get rid of them.

# Import the libraries and Modules
from PIL import Image
import os
import numpy as np
from sklearn.model_selection import train_test_split
import cv2
import tensorflow as tf
import matplotlib.pyplot as plt
import imghdr

# Loading into a path
data_dir = 'The path to which the folder that contains all five folders to the dataset is' 
image_exts = ['jpg', 'bmp', 'png', 'jpeg']
for image_class in os.listdir(data_dir):
    for image in os.listdir(os.path.join(data_dir, image_class)):
        image_path = os.path.join(data_dir, image_class, image)
        try:
           img = cv2.imread(image_path)
           tip = imghdr.what(image_path)
           if tip not in image_exts:
              print('Image not in exts list {}'.format(image_path))
              os.remove(image_path)
           except Exception as e:
           print('Issues with image {}'.format(image_path))

This block of code will remove outliers and doggy images.

Load and preprocess the Data

img_size = 128
def load_data():
    training_data = []
    for category in CATEGORIES:
        path = os.path.join(DATADIR, category)
        class_num = CATEGORIES.index(category)
        for img in os.listdir(path):
            try:
                img_array = cv2.imread(os.path.join(path, img), cv2.IMREAD_COLOR)
                new_array = cv2.resize(img_array, (img_size, img_size))
                training_data.append([new_array, class_num])
            except Exception as e:
                pass
    x = np.array([i[0] for i in training_data]) / 255.0
    y = np.array([i[1] for i in training_data])
    y = tf.keras.utils.to_categorical(y, len(CATEGORIES))
    x_train, x_val, y_train, y_val = train_test_split(x, y, test_size=0.2, random_state=42)
    return x_train, x_val, y_train, y_val
x_train, x_val, y_train, y_val = load_data()

Creating the Model

# Load the pre-trained VGG16 model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(img_size, img_size, 3))

# Freeze the pre-trained layers
for layer in base_model.layers:
    layer.trainable = False

# Add new trainable layers on top of the pre-trained model
x = base_model.output
x = Flatten()(x)
x = Dense(1024, activation='relu')(x)
output = Dense(len(CATEGORIES), activation='softmax')(x)

# Define the new model
model = tf.keras.models.Model(inputs=base_model.input, outputs=output)

# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Train the model
model.fit(x_train, y_train, epochs=10, validation_data=(x_val, y_val))

Evaluating the model

test_loss, test_acc = model.evaluate(x_val, y_val, verbose=0)

Print the test loss and accuracy

print('Test loss:', test_loss)
print('Test accuracy:', test_acc)

Using the model to predict new images

import numpy as np
from PIL import Image
from keras.models import load_model

# Load your trained CNN model
model = load_model('my_model.h5')

# Load the image you want to classify
image = Image.open(r'C:\Users\mine\Desktop\natural\mountains\images344.jpg') # Now you can use any image the model hasn't seen before to see the prediction

# Preprocess the image
image = image.resize((128, 128))
image = np.array(image) / 255.0
image = image.reshape((1, 128, 128, 3))

# Make a prediction
preds = model.predict(image)

# Find the index of the highest probability value
pred_class = np.argmax(preds)

# Map the predicted index to the corresponding class label
classes = ['buildings', 'forest', 'sea', 'glaciers', 'mountains']
pred_label = classes[pred_class]

# Display the result
print('The predicted class of the image is:', pred_label)

I hope you got and the model predicted well. If there is question, feel free to ask in the comment section and I'll be very happy to help.

Check out the full code and results on my GitHub account

I deployed the model on streamlit. You can try it out here

Flower Recognition with Python

Olaoyo Michael — Sun, 23 Apr 2023 11:54:17 +0000

The edge and color properties of flower photos are used in flower recognition to categorize flowers. I'll introduce you to a Python machine learning project that focuses on flower detection in this article.

What is Flower Recognition?

The planet is home to numerous flower species. Some species, like roses, have a variety of hues. The names and details of every flower are tough to recall. Additionally, people could mistakenly identify similar floral species.
For instance, although having similar names and flower forms, white champaka and champak have different colors and petal lengths.

Currently, the only way to identify any specific flower or flower species is to search for information based on one's own knowledge and professional experience. The availability of such expertise may provide a challenge in this investigation.
Today, the only real options for finding such content online are keyword searches and word processors. The problem is that even then, the searcher would still need to come up with suitably relevant keywords, which they are unable to do.

This post will demonstrate how to use Python to recognize flowers using machine learning.

Machine Learning Project on Flower Recognition with Python

4242 flower photos make up the dataset I'm utilizing for this job of flower recognition. Data is gathered using photos from Yandex, Google, and Flickr. This data collection can be used to identify the flowers in the image.

Five categories—chamomile, tulip, rose, sunflower, and dandelion—are used to categorize the photographs. There are around 800 images for each class. The images have a resolution of just 320 x 240 pixels, which is not very great. Photos have varying proportions and are not scaled down to one size.
Let's import the required Python libraries now to begin the Python work of flower recognition: Download Dataset

import os
import cv2
import numpy as np

#Encoding and Split data into Train/Test Sets
from sklearn.preprocessing import LabelEncoder
from tensorflow.keras.utils import to_categorical
from sklearn.model_selection import train_test_split

#Tensorflow Keras CNN Model
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten, Activation, Conv2D, MaxPooling2D
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.optimizers import Adam,SGD,Adagrad,Adadelta,RMSprop

#Plot Images
import matplotlib.pyplot as plt


folder_dir = 'dataset path' # Choose your path

Now the next step is to read each image in the data and create a label for each with the name of the folder:

data = []
label = []

SIZE = 128 #Crop the image to 128x128

for folder in os.listdir(folder_dir):
    for file in os.listdir(os.path.join(folder_dir, folder)):
        if file.endswith("jpg"):
            label.append(folder)
            img = cv2.imread(os.path.join(folder_dir, folder, 
                                                            file))
            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
            im = cv2.resize(img_rgb, (SIZE,SIZE))
            data.append(im)
        else:
            continue

Now let’s convert the data into numerical values:

data_arr = np.array(data)
label_arr = np.array(label)

Now let’s use the Label encoder and normalize the data:

encoder = LabelEncoder()
y = encoder.fit_transform(label_arr)
y = to_categorical(y,5)
X = data_arr/255

The next step is to split the dataset into 80% training and 20% test sets:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=10)

Now let’s build a neural network model for the task of Flower Recognition:

model = Sequential()
model.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same',activation ='relu', input_shape = (SIZE,SIZE,3)))
model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Conv2D(filters = 128, kernel_size = (3,3),padding = 'Same',activation ='relu'))
model.add(Conv2D(filters = 128, kernel_size = (3,3),padding = 'Same',activation ='relu'))
model.add(Conv2D(filters = 128, kernel_size = (3,3),padding = 'Same',activation ='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dropout(rate=0.5))
model.add(Dense(5, activation = "softmax"))

Before compiling the model we need to create more training images to prevent overfitting:

datagen = ImageDataGenerator(
        rotation_range=20,
        zoom_range = 0.20,
        width_shift_range=0.3,
        height_shift_range=0.3,
        horizontal_flip=True,
        vertical_flip=True)

datagen.fit(X_train)

Now let’s compile the neural network model:

model.compile(optimizer=Adam(lr=0.0001),loss='categorical_crossentropy',metrics=['accuracy'])
batch_size=32
epochs=64
history = model.fit_generator(datagen.flow(X_train,y_train, batch_size=batch_size),
                              epochs = epochs,
                              validation_data = (X_test,y_test),
                              verbose = 1)

Now let’s let the model if it recognize flowers properly:

categories = np.sort(os.listdir(folder_dir))
fig, ax = plt.subplots(6,6, figsize=(25, 40))

for i in range(6):
    for j in range(6):
        k = int(np.random.random_sample() * len(X_test))
        if(categories[np.argmax(y_test[k])] == categories[np.argmax(model.predict(X_test)[k])]):
            ax[i,j].set_title("TRUE: " + categories[np.argmax(y_test[k])], color='green')
            ax[i,j].set_xlabel("PREDICTED: " + categories[np.argmax(model.predict(X_test)[k])], color='green')
            ax[i,j].imshow(np.array(X_test)[k].reshape(SIZE, SIZE, 3), cmap='gray')
        else:
            ax[i,j].set_title("TRUE: " + categories[np.argmax(y_test[k])], color='red')
            ax[i,j].set_xlabel("PREDICTED: " + categories[np.argmax(model.predict(X_test)[k])], color='red')
            ax[i,j].imshow(np.array(X_test)[k].reshape(SIZE, SIZE, 3), cmap='gray')

I hope you liked this article on Machine Learning Project on Flower Recognition with Python programming language. Check out the full code and results on my GitHub account