Last Updated on 20/09/2025 by Eran Feit
Introduction
Welcome to our comprehensive Dinosaur Image Classification Tutorial!
Let’s learn a simple way for Dinosaur lower Classifications 🦕
Check out our tutorial here : https://www.youtube.com/watch?v=ZhTGcw0C3Dk
Link for the full code : https://ko-fi.com/s/a902042be9
This hands-on tutorial walks you through building a Convolutional Neural Network (CNN) to classify 5 dinosaur categories from images.
We’ll cover dataset prep, model architecture, training, and evaluation — and finish with tips to improve accuracy.
We’ll learn how use Convolutional Neural Network (CNN) to classify 5 dinosaur categories , based on 200 images :
- Data Preparation: We’ll begin by downloading a curated dataset of dinosaur images, neatly categorized into five distinct classes. You’ll learn how to load and preprocess the data using Python, OpenCV, and Numpy, ensuring it’s perfectly ready for training.
- CNN Architecture: Unravel the secrets of Convolutional Neural Networks (CNNs) as we dive into their structure and discuss the different layers—convolutional, pooling, and fully connected. Learn how these layers work together to extract meaningful features from images.
- Model Training : Using Tensorflow and Keras , we will define and train our custom CNN model. We’ll configure the loss function, optimizer, and evaluation metrics to achieve optimal performance during training.
- Evaluation Metrics: We’ll evaluate our trained model using various metrics like accuracy and confusion matrix to measure its efficiency and robustness.
- Predicting New Images: Finally , We put our pre-trained model to the test! We’ll showcase how to use the model to make predictions on fresh, unseen dinosaur images, and witness the magic of AI in action.
You can find more tutorials, and join my newsletter here : https://eranfeit.net/
Prerequisites
- Python 3.9+
tensorflow,keras,opencv-python,numpy,matplotlib- A folder layout like:
Link to the dataset 5 Classes of Dinosaur s: https://www.kaggle.com/datasets/cmglonly/simple-dinosurus-dataset
Simple Dinosaur Dataset/
├─ ClassA/
├─ ClassB/
├─ ...
Here is the code for the project :
1) Setup & Data Loading
import os
import numpy as np
import cv2
from keras.preprocessing.image import ImageDataGenerator
# Path to your dataset (change to your path)
path = r"E:/Data-sets/Simple Dinosaur Dataset"
# Derive classes from folder names
categories = sorted(os.listdir(path))
num_classes = len(categories)
print("Classes:", categories, "| #:", num_classes)
# Parameters
BATCH_SIZE = 32
IMG_SIZE = (224, 224)
# Train/valid generators with light augmentation
datagen = ImageDataGenerator(
rescale=1./255,
validation_split=0.2,
horizontal_flip=True
)
train_ds = datagen.flow_from_directory(
path,
target_size=IMG_SIZE,
batch_size=BATCH_SIZE,
subset="training",
class_mode="categorical",
shuffle=True
)
valid_ds = datagen.flow_from_directory(
path,
target_size=IMG_SIZE,
batch_size=BATCH_SIZE,
subset="validation",
class_mode="categorical",
shuffle=True
)
Link for the full code : https://ko-fi.com/s/a902042be9
2) Build the CNN
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense
model = Sequential([
Conv2D(16, 3, activation='relu', padding='same', input_shape=(IMG_SIZE[0], IMG_SIZE[1], 3)),
MaxPooling2D(2),
Dropout(0.25),
Conv2D(32, 3, activation='relu', padding='same'),
MaxPooling2D(2),
Conv2D(64, 3, activation='relu', padding='same'),
MaxPooling2D(2),
Dropout(0.25),
Flatten(),
Dense(128, activation='relu'),
Dropout(0.5),
Dense(num_classes, activation='softmax')
])
model.summary()
Link for the full code : https://ko-fi.com/s/a902042be9
3) Train with Checkpoints
from keras.callbacks import ModelCheckpoint
import math
model.compile(
optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy"]
)
steps_per_epoch = math.ceil(train_ds.samples / BATCH_SIZE)
val_steps = math.ceil(valid_ds.samples / BATCH_SIZE)
checkpoint = ModelCheckpoint(
filepath=r"E:/temp/dino_best.h5",
monitor='val_accuracy',
save_best_only=True,
verbose=1
)
history = model.fit(
train_ds,
steps_per_epoch=steps_per_epoch,
epochs=50,
validation_data=valid_ds,
validation_steps=val_steps,
callbacks=[checkpoint]
)
Link for the full code : https://ko-fi.com/s/a902042be9
4) Visualize Training
import matplotlib.pyplot as plt
acc = history.history['accuracy']; val_acc = history.history['val_accuracy']
loss = history.history['loss']; val_loss = history.history['val_loss']
epochs_range = range(len(acc))
plt.figure(); plt.plot(epochs_range, acc, label="Train accuracy"); plt.plot(epochs_range, val_acc, label="Val accuracy"); plt.xlabel("Epoch"); plt.ylabel("Accuracy"); plt.title("Accuracy"); plt.legend(); plt.show()
plt.figure(); plt.plot(epochs_range, loss, label="Train loss"); plt.plot(epochs_range, val_loss, label="Val loss"); plt.xlabel("Epoch"); plt.ylabel("Loss"); plt.title("Loss"); plt.legend(); plt.show()
Link for the full code : https://ko-fi.com/s/a902042be9
5) Next Steps & Accuracy Boosters
- Balance classes or use
class_weightif imbalanced. - Try data augmentation (rotation, zoom).
- Swap the base to transfer learning (e.g., EfficientNetB0) for higher accuracy.
- Use EarlyStopping + ReduceLROnPlateau for stability.
FAQs
How many images per class do I need?
Start with ~200 per class; more data usually improves generalization.
Can I train on CPU?
Yes, but GPU is strongly recommended for speed.
How do I export the model?
Use model.save("dino_model.keras") and load with tf.keras.models.load_model().
Test The Model :
Let’s test it on theses 2 test images :
6) Load the model
This section loads a pre-trained model from a specified file path and prepares the dataset for prediction by listing and sorting the categories. It also sets the batch size for running predictions.
# Import necessary libraries
import tensorflow as tf
import os
from keras.utils import img_to_array, load_img
import numpy as np
import cv2
# Load the pre-trained model from a specified file path
model = tf.keras.models.load_model("e:/temp/dino.h5")
print(model.summary()) # Print the model architecture to see its structure
# Set the batch size for prediction
batchSize = 32
# Get the list of categories from the dataset directory
source_folder = "E:/Data-sets/Simple Dinosaur Dataset"
categories = os.listdir(source_folder)
categories.sort() # Sort the categories for consistent order
print(categories) # Display the list of categories
# Calculate the number of classes based on the number of categories
numOfClasses = len(categories)
print("Number of categories:")
print(numOfClasses)Link for the full code : https://ko-fi.com/s/a902042be9
7) Prepare the test images (function)
This function preprocesses an image by resizing it to the required input size, converting it to an array, adding a batch dimension, and normalizing the pixel values. This ensures that the image is properly formatted for model prediction.
# Define a function to prepare an image for the model
def prepareImage(pathForImage):
image = load_img(pathForImage, target_size=(224, 224)) # Load the image and resize to 224x224
imgResult = img_to_array(image) # Convert the image to a numpy array
imgResult = np.expand_dims(imgResult, axis=0) # Add an extra dimension for batch size
imgResult = imgResult / 255.0 # Normalize the pixel values to the range [0, 1]
return imgResultLink for the full code : https://ko-fi.com/s/a902042be9
8) Run inference
This section loads a test image, preprocesses it using the prepareImage function, and runs the prediction using the pre-trained model. It then determines the predicted class and displays the corresponding label.
# Specify the path for the test image to predict
testImagPath = "TensorFlowProjects/Dinosaurs-Classification/test_pterodacty.jpg"
# testImagPath = "TensorFlowProjects/Dinosaurs-Classification/test2_Triceratops.jpg"
# Prepare the image for prediction using the previously defined function
imageForModel = prepareImage(testImagPath)
# Run the prediction using the model
resultArray = model.predict(imageForModel, batch_size=batchSize, verbose=1)
# Get the index of the class with the highest prediction score
answers = np.argmax(resultArray, axis=1)
# Get the predicted category label
text = categories[answers[0]]
print("Predicted: " + text)Link for the full code : https://ko-fi.com/s/a902042be9
9) Display the results
This section reads the original image using OpenCV, adds the predicted class label as an overlay text, and displays the annotated image. It then saves the annotated image and waits for a user action to close the window.
# Read the original test image using OpenCV
img = cv2.imread(testImagPath)
font = cv2.FONT_HERSHEY_COMPLEX # Set the font for displaying text on the image
# Overlay the predicted text on the image
cv2.putText(img, text, (0, 20), font, 1, (209, 19, 77), 2)
# Display the image with the prediction
cv2.imshow('img', img)
# Save the annotated image to a specified path
cv2.imwrite("e:/temp/1.png", img)
# Wait indefinitely until a key is pressed
cv2.waitKey(0)
# Close all OpenCV windows
cv2.destroyAllWindows()Link for the full code : https://ko-fi.com/s/a902042be9
Connect :
☕ Buy me a coffee — https://ko-fi.com/eranfeit
🖥️ Email : feitgemel@gmail.com
🤝 Fiverr : https://www.fiverr.com/s/mB3Pbb
Planning a trip and want ideas you can copy fast?
Here are three detailed guides from our travels:
• 5-Day Ireland Itinerary: Cliffs, Castles, Pubs & Wild Atlantic Views
https://eranfeit.net/unforgettable-trip-to-ireland-full-itinerary/
• My Kraków Travel Guide: Best Places to Eat, Stay & Explore
https://eranfeit.net/my-krakow-travel-guide-best-places-to-eat-stay-explore/
• Northern Greece: Athens, Meteora, Tzoumerka, Ioannina & Nafpaktos (7 Days)
https://eranfeit.net/my-amazing-trip-to-greece/
Each guide includes maps, practical tips, and family-friendly stops—so you can plan in minutes, not hours.
Enjoy,
Eran