Exploring Computer Vision with Convolutional Neural Networks

Introduction

# Welcome to "Exploring Computer Vision with Convolutional Neural Networks"

Imagine a world where computers can see and understand the environment around them as well as, or perhaps even better than, humans. From self-driving cars that navigate through busy streets, to systems that can diagnose medical conditions from images faster than the most trained eyes, the field of computer vision is not just fascinating—it's fundamentally transforming our approach to problems across various industries. At the heart of this revolution is a powerful type of deep-learning model known as the Convolutional Neural Network (CNN). This tutorial will guide you through the thrilling landscape of CNNs and their applications in image recognition tasks using TensorFlow and Keras.

### What Will You Learn?

This tutorial is designed to introduce you to the basic concepts of CNNs and how they are applied in the real world for image recognition. By the end of this guide, you will:
- Understand what CNNs are and why they are so effective for image-processing tasks.
- Learn how to implement these networks using TensorFlow and Keras, two of the most popular frameworks for deep learning.
- Apply your knowledge to build and train a CNN model that can recognize and classify images with high accuracy.
- Explore practical examples and case studies that illustrate how CNNs are used in various industries.

### Prerequisites

Before diving into this tutorial, it's helpful to have:
- Basic understanding of Python programming.
- Familiarity with fundamental concepts of machine learning and neural networks.
- An environment set up for Python development (instructions provided in the tutorial).

If you're new to Python or neural networks, don't worry! We'll include links to resources and brief refreshers throughout the tutorial to help you catch up.

### Tutorial Overview

Here’s a sneak peek at what we’ll cover:
1. Introduction to CNNs: We'll start with a brief history and the theoretical foundations of CNNs.
2. Setting Up Your Environment: Instructions on setting up Python, TensorFlow, and Keras on your machine.
3. Building Your First CNN: Step-by-step guide on constructing your first CNN using Keras.
4. Training and Testing: Learn how to train your model with real-world image data and evaluate its performance.
5. Advanced Techniques: Enhance your model's accuracy with tips and tricks specific to image recognition.
6. Real-World Applications: Discussion of interesting case studies where CNNs are making a significant impact.

Prepare to embark on an engaging journey into the world of computer vision with CNNs. Whether you're a hobbyist looking to understand modern image-recognition techniques or an aspiring data scientist eager to deepen your knowledge in deep-learning, this tutorial will equip you with the tools and insights needed to advance in this exciting field.

Understanding the Basics of CNNs

# Understanding the Basics of CNNs

In this section of our tutorial "Exploring Computer Vision with Convolutional Neural Networks (CNNs)," we will delve into the foundational concepts that make CNNs a powerful tool for image recognition and other deep learning applications. Designed for beginners, this content aims to demystify the components and processes that underpin CNNs, using practical examples and straightforward explanations.

## What are Convolutional Neural Networks?

Convolutional Neural Networks (CNNs) are a class of deep neural networks highly effective for processing data that has a grid-like topology, such as images. An image can be understood as a grid of pixels arranged in rows and columns. CNNs leverage the spatial hierarchy in images—they recognize patterns with variations of shapes and sizes, which makes them superior for image recognition tasks.

Unlike regular neural networks that fully connect each neuron to all activations in the previous layer, CNNs only connect small regions to individual neurons. This architecture not only reduces the number of parameters that need to be learned but also makes the network invariant to the scale and position of features in the input, thereby enhancing the efficiency and performance in image-related tasks.

## Key Components of CNNs

CNNs consist mainly of three types of layers: Convolutional Layer, Pooling Layer, and Fully Connected Layer. Each plays a crucial role in feature detection and classification.

### Convolutional Layer

This is the core building block of a CNN. The layer's parameters consist of a set of learnable filters (or kernels), which have a small receptive field but extend through the full depth of the input volume. As the filter slides (or convolves) across the image, it produces a 2D activation map that captures the responses of that filter at every spatial position. Intuitively, these filters can be thought of as feature detectors.

Here's a simple example using Python and TensorFlow to demonstrate how a convolutional layer can be implemented:

`python
import tensorflow as tf
from tensorflow.keras.layers import Conv2D

# Define a simple CNN layer
layer = Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')
`

### Pooling Layer

Following the convolutional layer, pooling (also known as subsampling or downsampling) reduces the dimensionality of each feature map but retains the most important information. Pooling can be of different types: MaxPooling is the most common, which extracts patches from the input feature maps and outputs the maximum value of each patch.

Example of implementing MaxPooling in TensorFlow:

`python
from tensorflow.keras.layers import MaxPooling2D

# Adding a MaxPooling layer
pool_layer = MaxPooling2D(pool_size=(2, 2))
`

### Fully Connected Layer

After several convolutional and pooling layers, the high-level reasoning in the neural network is done via fully connected layers. Neurons in a fully connected layer have full connections to all activations in the previous layer, as seen in regular Artificial Neural Networks. Their role is to classify the images into various categories based on the features extracted by convolutional and pooling layers.

`python
from tensorflow.keras.layers import Dense

# Fully connected layer
fc_layer = Dense(10, activation='softmax')
`

## Activation Functions: ReLU, Sigmoid, and Others

Activation functions introduce non-linear properties to the network—without these, the network would behave like a single linear perceptron. The most commonly used activation functions in CNNs include:

- ReLU (Rectified Linear Unit): Allows models to account for non-linearities and interactions in data. It's defined as f(x) = max(0, x).
- Sigmoid: Maps the input (a real-valued number) to the range (0, 1), making it suitable for binary classification.
- Others: Tanh, Softmax among others are also frequently used depending on the specific requirements of the network architecture.

## How CNNs Extract Features from Images

The real power of CNNs lies in their ability to automatically detect relevant features without any human supervision. In the initial layers, CNN might only be able to detect low-level features like edges and corners. As we go deeper into the network, it starts recognizing high-level features like shapes and objects.

For instance, while processing an image of a cat, the first layer might detect edges, the next layer might assemble these edges into parts of ears or eyes, and subsequent layers might recognize more complex features like faces or entire heads.

By stacking multiple layers, CNNs can understand increasingly abstract features in an image. This capability makes CNNs incredibly powerful for tasks like image recognition and classification.

## Conclusion

Through understanding these fundamental concepts—how convolutional layers work, what purpose pooling layers serve, how fully connected layers classify images based on learned features, and why activation functions are crucial—we can appreciate why CNNs are pivotal in modern AI applications. As we progress deeper into our tutorial series, we will build upon these basics to explore more advanced topics in computer vision using deep learning frameworks like TensorFlow and Keras.

What are Convolutional Neural Networks?

Key Components of CNNs: Convolutional Layer, Pooling Layer, Fully Connected Layer

Activation Functions: ReLU, Sigmoid, and Others

How CNNs Extract Features from Images

Setting Up Your Environment

## Setting Up Your Environment for Exploring Computer Vision with Convolutional Neural Networks (CNNs)

Creating a robust setup is crucial for learning and developing projects in computer vision using CNNs. This section will guide you through selecting the right Python libraries, installing them, and ensuring they work correctly, including leveraging GPU computing for enhanced performance.

### 1. Choosing the Right Python Libraries: TensorFlow, Keras, PyTorch

When diving into deep learning and image recognition, choosing the right framework is key. The most popular ones include TensorFlow, Keras, and PyTorch. Here's a brief overview:

- TensorFlow: Developed by Google, TensorFlow is widely used in the industry due to its powerful features and scalability across devices. It supports both high and low-level APIs and is particularly strong in production environments.

- Keras: Built on top of TensorFlow, Keras is a high-level API that is user-friendly for beginners. It simplifies many tasks and allows you to build and train models with fewer lines of code. It's a great choice if you are just starting with deep learning.

- PyTorch: Developed by Facebook, PyTorch offers dynamic computational graphing, allowing for flexibility in model architecture changes. It’s favored in the research community for its ease of use and intuitive handling of tensors.

For beginners, starting with Keras might be the easiest due to its simplicity. However, if you plan on diving deeper into custom or complex model architectures, TensorFlow or PyTorch could be more suitable.

### 2. Installing Necessary Libraries and Dependencies

To get started, you will need Python installed on your computer (preferably Python 3.6 or newer). You can download it from [python.org](https://python.org).

Installing TensorFlow and Keras:
`bash
pip install tensorflow
`
This command installs both TensorFlow and Keras, as Keras comes bundled with TensorFlow as tensorflow.keras.

Installing PyTorch:
Visit the [PyTorch official site](https://pytorch.org/get-started/locally/) and choose the right command based on your operating system, package manager, Python version, and whether you have CUDA installed for GPU support.

For example:
`bash
pip install torch torchvision torchaudio
`

### 3. Verifying Installation with a Simple Script

After installation, it's good practice to verify that everything is set up correctly. You can do this by running a simple script to check library versions.

`python
import tensorflow as tf
import torch

print("TensorFlow version:", tf.__version__)
print("PyTorch version:", torch.__version__)

# Test if TensorFlow can access GPU
print("TensorFlow can access GPU:", tf.test.is_gpu_available())
`

This script displays the versions of TensorFlow and PyTorch installed on your system and checks if TensorFlow can access the GPU.

### 4. Introduction to GPU Computing for Faster Processing

Deep learning models require a significant amount of computational power, especially for tasks like training on large datasets in image recognition. Utilizing the Graphics Processing Unit (GPU) can drastically reduce the training time.

#### Why Use a GPU?
A GPU can perform many more simultaneous operations compared to a CPU, making it ideal for the matrix operations typically found in deep learning computations.

#### Setting up GPU Support:
- TensorFlow: If you have installed TensorFlow as shown above, and you have a compatible NVIDIA GPU with the necessary drivers and CUDA installed, TensorFlow should automatically use the GPU.

- PyTorch: Similar to TensorFlow, ensure that you install the version of PyTorch that supports CUDA if you have an NVIDIA GPU.

#### Verifying GPU Usage:
For TensorFlow:
`python
print("TensorFlow using GPU:", tf.test.is_gpu_available())
`

For PyTorch:
`python
print("PyTorch using GPU:", torch.cuda.is_available())
`

These commands help verify that your deep learning environment is utilizing the GPU, ensuring faster processing capabilities.

### Conclusion

Setting up your environment correctly is foundational to successfully learning and applying CNNs in computer vision. By choosing the right library that fits your needs and ensuring your setup utilizes GPU capabilities, you can enhance your learning experience and prepare for more advanced studies and projects in deep learning.

Choosing the Right Python Libraries: TensorFlow, Keras, PyTorch

Installing Necessary Libraries and Dependencies

Verifying Installation with a Simple Script

Introduction to GPU Computing for Faster Processing

Building Your First CNN Model

### Building Your First CNN Model

In this section of our tutorial, "Exploring Computer Vision with Convolutional Neural Networks (CNNs)," we'll guide you through the process of building your first CNN model for image classification. We'll start by defining the problem, preparing your dataset, designing the CNN architecture, and finally, training the model. This tutorial is designed for beginners and includes practical examples to help you understand each step clearly.

#### 1. Defining the Problem: Image Classification

Image classification involves assigning a label to an image from a predefined set of categories. This is a fundamental task in computer vision and serves as a great starting point for learning about CNNs. For example, a model might need to determine whether a photograph contains a cat or a dog.

#### 2. Preparing Your Dataset: Loading and Pre-processing Data

To train a CNN, you first need a labeled dataset where each image is tagged with a category. TensorFlow and Keras offer utilities to load and preprocess data efficiently. Let's use the CIFAR-10 dataset, which includes 60,000 32x32 color images in 10 classes, with 6,000 images per class.

`python
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical

# Load the dataset
(train_images, train_labels), (test_images, test_labels) = cifar10.load_data()

# Normalize pixel values to be between 0 and 1
train_images, test_images = train_images / 255.0, test_images / 255.0

# Convert class vectors to binary class matrices (one-hot encoding)
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)
`

Pre-processing steps typically include resizing images, normalizing pixel values, and one-hot encoding labels. These steps are crucial as they make the model training more efficient and converge faster.

#### 3. Designing the CNN Architecture: A Step-by-Step Guide

A basic CNN architecture consists of convolutional layers followed by pooling layers, fully connected layers, and finally a softmax activation function for classification. Here's a simple example using Keras:

`python
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

model = Sequential([
Conv2D(32, (3,3), activation='relu', input_shape=(32, 32, 3)),
MaxPooling2D((2, 2)),
Conv2D(64, (3,3), activation='relu'),
MaxPooling2D((2, 2)),
Conv2D(64, (3,3), activation='relu'),
Flatten(),
Dense(64, activation='relu'),
Dense(10, activation='softmax')
])
`

In this architecture:
- Conv2D layers are used for the convolutional operations,
- MaxPooling2D layers reduce the spatial dimensions (height and width),
- Flatten layer flattens the input to a vector,
- Dense layers are fully connected layers,
- ReLU activation function introduces non-linearity, helping the network learn complex patterns,
- Softmax in the last layer ensures the output values are in the range [0,1], acting like probabilities.

#### 4. Training the Model: Setting Parameters and Using Callbacks

To train the model, we need to compile it with an appropriate optimizer and loss function. Then we can fit the model to our training data using the model.fit() method.

`python
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping

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

callbacks = [EarlyStopping(monitor='val_loss', patience=3)]

history = model.fit(train_images, train_labels, epochs=20,
validation_data=(test_images, test_labels),
callbacks=callbacks)
`

Here:
- The Adam optimizer adjusts the learning rate during training.
- categorical_crossentropy is used as the loss function for multi-class classification.
- EarlyStopping callback stops training when no improvement is seen for three consecutive epochs on validation loss.

By setting up your training process with these configurations and callbacks, your model becomes robust to overfitting and improves in learning efficiency.

Congratulations! You've just completed a comprehensive guide on building your first CNN model for image classification using TensorFlow and Keras. Experiment with different architectures and parameters to see how they affect performance and help you deepen your understanding of CNNs in computer vision.

Defining the Problem: Image Classification

Preparing Your Dataset: Loading and Pre-processing Data

Designing the CNN Architecture: A Step-by-Step Guide

Training the Model: Setting Parameters and Using Callbacks

Practical Examples and Applications

### Practical Examples and Applications of Convolutional Neural Networks (CNNs)

Convolutional Neural Networks (CNNs) have revolutionized the field of computer vision by providing high accuracy in tasks like image recognition and classification. This section will explore practical examples and applications, demonstrating how CNNs are applied in various domains.

#### Case Study 1: Handwritten Digit Recognition (MNIST Dataset)

One of the classic problems in computer vision that CNNs excel at is recognizing handwritten digits. The MNIST dataset, which contains tens of thousands of labeled images of handwritten digits (0-9), serves as an excellent starting point for understanding CNNs.

Practical Example:
Using TensorFlow and Keras, we can build a simple CNN to classify these digits. Here's a basic example:

`python
from tensorflow.keras import layers, models

# Build the CNN model
model = models.Sequential([
layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(64, (3, 3), activation='relu'),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(64, (3, 3), activation='relu'),
layers.Flatten(),
layers.Dense(64, activation='relu'),
layers.Dense(10, activation='softmax')
])

# Compile and train the model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
`

In this example, the CNN learns to identify features in the images that distinguish one digit from another, leading to effective classification.

#### Case Study 2: Facial Recognition for Security Systems

Facial recognition technology has become a cornerstone in security systems, allowing for the identification and verification of individuals in various settings. CNNs are particularly suited for this task due to their ability to pick out intricate patterns in facial features.

Practical Example:
Facial recognition systems typically involve several stages, including face detection, feature extraction, and face verification. A CNN can be trained to perform these tasks by learning from a dataset of face images.

Here's a simplified workflow using deep learning libraries like TensorFlow:

1. Detect faces in an image.
2. Extract key features from each face using a CNN.
3. Compare features to those in a database to verify identity.

`python
# Assume 'faces' is a batch of face images
model = models.Sequential([
layers.Conv2D(100, (10, 10), activation='relu', input_shape=(200, 200, 3)),
layers.MaxPooling2D((5, 5)),
layers.Conv2D(50, (5, 5), activation='relu'),
layers.Flatten(),
layers.Dense(256, activation='relu'),
layers.Dense(number_of_classes, activation='softmax')
])
`

This model could be trained on a labeled dataset where each class represents a different person.

#### Case Study 3: Object Detection in Autonomous Vehicles

Autonomous vehicles use CNNs for object detection—identifying and categorizing objects (like cars, pedestrians, and road signs) within their visual field. This capability is crucial for safe navigation.

Practical Example:
You might use a pre-trained model like YOLO (You Only Look Once) which is effective for real-time object detection. This model divides the image into regions and predicts bounding boxes and probabilities for each region. These boxes are then filtered based on their probability scores.

`python
# Pseudo code for using YOLO with TensorFlow
model = load_model('yolo.h5') # Load pre-trained YOLO model
output = model.predict(image_input) # Predict objects in the image
`

#### Expanding Applications: From Medical Imaging to Surveillance

The versatility of CNNs is not limited to the above cases; they're also extensively used in medical imaging to detect anomalies like tumors in MRI scans or to monitor areas for surveillance purposes.

Medical Imaging Example:
In medical diagnosis, CNNs can analyze X-ray images to detect abnormalities such as fractures or tumors. Training a CNN on a dataset of X-ray images can help it learn to identify these features accurately.

Surveillance Example:
In surveillance, CNNs can process video footage in real-time to detect suspicious activities or track individuals across cameras. The ability of CNNs to handle temporal data makes them suitable for this application.

### Conclusion

Through these practical examples—from simple digit recognition to complex real-time object detection in autonomous vehicles—it's evident that CNNs are incredibly powerful tools for image recognition and classification across various fields. As we continue to innovate and improve these networks, their scope and efficacy in real-world applications will only expand.

Case Study 1: Handwritten Digit Recognition (MNIST Dataset)

Case Study 2: Facial Recognition for Security Systems

Case Study 3: Object Detection in Autonomous Vehicles

Expanding Applications: From Medical Imaging to Surveillance

Best Practices, Tips, and Common Pitfalls

# Best Practices, Tips, and Common Pitfalls in Exploring Computer Vision with Convolutional Neural Networks (CNNs)

Exploring the realm of image recognition using CNNs in deep learning frameworks like TensorFlow and Keras can be both exhilarating and challenging. Below, we delve into some essential strategies and common issues you may encounter in your projects, providing practical advice for beginners to enhance their understanding and skills in computer vision.

## Optimizing CNN Architectures: How to Choose Filters and Layers

Choosing the right number and size of filters, as well as deciding how many layers to include in your CNN, can significantly impact the performance of your image-recognition tasks. Here are a few tips:

- Start Small: For beginners, starting with a small network (fewer layers and filters) is beneficial. This approach helps in understanding how each component influences outcomes. Gradually increase complexity as needed.
- Filter Sizes: Common filter sizes are 3x3 or 5x5. Smaller filters capture fine details, while larger filters help in capturing broader features of the image. A combination of different sizes through the layers can be effective.
- Depth of Network: Adding more layers helps the network learn more complex patterns. However, too many layers can lead to overfitting (which we'll address later). A practical approach is to increase depth until you see diminishing returns on validation accuracy.

Here's a simple example using Keras to define a basic CNN architecture:

`python
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

model = Sequential([
Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
MaxPooling2D(2, 2),
Conv2D(64, (3, 3), activation='relu'),
MaxPooling2D(2, 2),
Flatten(),
Dense(128, activation='relu'),
Dense(10, activation='softmax')
])
`

## Data Augmentation Techniques to Improve Model Performance

Data augmentation is a powerful technique to increase the diversity of your training set by applying random but realistic transformations to the training images. This method helps improve the generalization of the model. Here are some common augmentation techniques:

- Rotation, translation, and flip: These transformations help the model to not rely on specific image orientations.
- Rescaling and normalization: Adjusting the scale and range of pixel values.
- Color adjustment: Variations in color and brightness can make the model more robust to different lighting conditions.

You can easily implement these using Keras' ImageDataGenerator:

`python
from keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest'
)
`

## Avoiding Overfitting: Regularization Techniques

Overfitting occurs when your model performs well on training data but poorly on unseen data (validation/test data). Here's how to mitigate it:

- Dropout: Randomly sets a fraction of input units to 0 at each update during training time, which helps to prevent overfitting.
- L1/L2 Regularization: Adds a penalty on layer parameters or layer activity during optimization.

Here's how to add dropout in a Keras model:

`python
from keras.layers import Dropout

model.add(Dropout(0.5))
`

## Debugging Common Issues in CNN Projects

Debugging is an integral part of any deep-learning project. Common issues include:

- Model not converging: This might be due to an inappropriate learning rate or poor choice of optimizer. Try adjusting the learning rate or switching optimizers (e.g., from SGD to Adam).
- Poor generalization: Besides overfitting, this could be due to inadequate model architecture or insufficient training data. Consider revising your model architecture or employing techniques like data augmentation.
- Vanishing/exploding gradients: These issues can often be mitigated by using batch normalization or adjusting initialization schemes.

Remember that debugging involves patience and systematic experimentation to identify what works best for your specific scenario.

By following these guidelines and understanding common pitfalls, you're better equipped to tackle projects in computer vision using CNNs effectively. Keep experimenting with different architectures, techniques, and parameters—the best way to learn is by doing!

Optimizing CNN Architectures: How to Choose Filters and Layers

Data Augmentation Techniques to Improve Model Performance

Avoiding Overfitting: Regularization Techniques

Debugging Common Issues in CNN Projects

Conclusion

## Conclusion

Congratulations on completing our beginner-level tutorial on "Exploring Computer Vision with Convolutional Neural Networks"! By now, you should have a solid foundation in understanding and applying CNNs to image recognition tasks. Let's briefly recap the essential concepts and skills you've acquired:

- Understanding the Basics of CNNs: You've learned how CNNs function, the significance of convolutional layers, and how these models excel in extracting hierarchical features from images.
- Setting Up Your Environment: We walked through setting up a coding environment that supports deep learning, ensuring you have the necessary tools like TensorFlow or PyTorch.
- Building Your First CNN Model: You've successfully built your first CNN model, a significant step towards becoming proficient in computer vision.
- Practical Examples and Applications: Applying what you've learned through real-world examples has helped bridge the gap between theory and practical implementation.
- Best Practices, Tips, and Common Pitfalls: This knowledge will steer you away from common errors and enhance your modeling techniques.

### Main Takeaways
The journey through the layers of a CNN and its application in real-world scenarios has equipped you with both the skills and confidence to tackle image recognition problems. Remember, the key to mastery in AI and machine learning is consistent practice and continuous learning.

### Next Steps
To further hone your skills, consider:
- Diving deeper into advanced architectures like ResNet and Inception networks.
- Participating in online challenges and competitions on platforms like Kaggle.
- Exploring other areas of machine learning to see how different concepts interconnect.

### Keep Learning and Experimenting
Your path doesn't end here. Try to apply your newfound knowledge to different datasets or perhaps start a small project that interests you. Experimentation is key to discovering novel solutions and enhancing your understanding.

Use forums, online courses, and recent research papers to stay updated with the latest advancements in the field. Remember, every model you build adds to your experience and brings new insights.

We hope this tutorial has sparked your interest in computer vision and that you feel encouraged to explore this fascinating field further. Keep learning, keep building, and most importantly, have fun while doing it!

Code Examples

# Import necessary libraries
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Path to your dataset directory
dataset_path = 'path/to/your/dataset'

# Initialize the ImageDataGenerator class and configure it for image augmentation
train_datagen = ImageDataGenerator(rescale=1.0/255, rotation_range=40, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True)

# Load images from directory
train_generator = train_datagen.flow_from_directory(dataset_path, target_size=(150, 150), batch_size=32, class_mode='binary')

# Import necessary libraries
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Build the CNN structure
model = Sequential([
    Conv2D(32, (3,3), activation='relu', input_shape=(150, 150, 3)),
    MaxPooling2D(2, 2),
    Conv2D(64, (3,3), activation='relu'),
    MaxPooling2D(2,2),
    Conv2D(128, (3,3), activation='relu'),
    MaxPooling2D(2,2),
    Flatten(),
    Dense(512, activation='relu'),
    Dense(1, activation='sigmoid')
])

# Compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Import necessary libraries
import tensorflow as tf
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping

# Assuming 'model' is your compiled CNN from the previous example and 'train_generator' is your training dataset generator

# Set up callback functions for saving the model and early stopping
checkpoint = ModelCheckpoint('best_model.h5', save_best_only=True)
early_stopping = EarlyStopping(monitor='val_loss', patience=10)

# Train the model with callbacks
history = model.fit(train_generator, epochs=50, validation_data=val_generator, callbacks=[checkpoint, early_stopping])