Computer Vision with Python: From Basics to Advanced Applications

Loading and Displaying Images

Before we can process images, we need to load them into our Python environment. Let's explore different ways to load and display images using popular libraries:

Using OpenCV

import cv2
import matplotlib.pyplot as plt
import numpy as np

# Load an image using OpenCV
image = cv2.imread('path/to/your/image.jpg')

# OpenCV loads images in BGR format, convert to RGB for display
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Display the image using matplotlib
plt.figure(figsize=(10, 8))
plt.imshow(image_rgb)
plt.title('Image loaded with OpenCV')
plt.axis('off')  # Hide axes
plt.show()

# Get basic image properties
height, width, channels = image.shape
print(f"Image dimensions: {width}x{height}")
print(f"Number of channels: {channels}")
print(f"Data type: {image.dtype}")

# Display using OpenCV (creates a window)
cv2.imshow('Image Window', image)
cv2.waitKey(0)  # Wait for any key press
cv2.destroyAllWindows()  # Close the window

Using PIL/Pillow

from PIL import Image
import numpy as np

# Load an image using PIL
pil_image = Image.open('path/to/your/image.jpg')

# Display the image
pil_image.show()

# Get image properties
width, height = pil_image.size
print(f"Image dimensions: {width}x{height}")
print(f"Mode: {pil_image.mode}")  # RGB, RGBA, L (grayscale), etc.

# Convert PIL image to numpy array for further processing
image_array = np.array(pil_image)
print(f"Shape as numpy array: {image_array.shape}")

# Convert back to PIL image
pil_image_from_array = Image.fromarray(image_array)

Loading and Displaying Multiple Images

import cv2
import matplotlib.pyplot as plt
import numpy as np
import glob

# Get a list of image paths
image_paths = glob.glob('path/to/your/images/*.jpg')

# Load and display multiple images in a grid
plt.figure(figsize=(15, 10))

for i, img_path in enumerate(image_paths[:6]):  # Display up to 6 images
    # Load image
    img = cv2.imread(img_path)
    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
    # Create subplot
    plt.subplot(2, 3, i+1)  # 2 rows, 3 columns
    plt.imshow(img_rgb)
    plt.title(f"Image {i+1}")
    plt.axis('off')

plt.tight_layout()
plt.show()

Basic Transformations

Image transformations are operations that modify the appearance or structure of an image. Let's explore some common transformations:

Color Space Conversions

import cv2
import matplotlib.pyplot as plt

# Load an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Convert to grayscale
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Convert to HSV (Hue, Saturation, Value)
hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

# Display the results
plt.figure(figsize=(15, 5))

plt.subplot(1, 3, 1)
plt.imshow(image_rgb)
plt.title('Original (RGB)')
plt.axis('off')

plt.subplot(1, 3, 2)
plt.imshow(gray_image, cmap='gray')
plt.title('Grayscale')
plt.axis('off')

plt.subplot(1, 3, 3)
plt.imshow(cv2.cvtColor(hsv_image, cv2.COLOR_HSV2RGB))
plt.title('HSV')
plt.axis('off')

plt.tight_layout()
plt.show()

# Split and merge color channels
b, g, r = cv2.split(image)

# Display individual channels
plt.figure(figsize=(15, 5))

plt.subplot(1, 3, 1)
plt.imshow(r, cmap='Reds')
plt.title('Red Channel')
plt.axis('off')

plt.subplot(1, 3, 2)
plt.imshow(g, cmap='Greens')
plt.title('Green Channel')
plt.axis('off')

plt.subplot(1, 3, 3)
plt.imshow(b, cmap='Blues')
plt.title('Blue Channel')
plt.axis('off')

plt.tight_layout()
plt.show()

# Merge channels back
merged_image = cv2.merge([b, g, r])

Geometric Transformations

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
height, width = image.shape[:2]

# Resize the image
# Method 1: Specify exact dimensions
resized_image = cv2.resize(image, (300, 200))  # width, height

# Method 2: Specify scaling factor
scaled_image = cv2.resize(image, None, fx=0.5, fy=0.5)  # Half the original size

# Rotate the image
# Method 1: Simple rotation by 90 degrees
rotated_90 = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)

# Method 2: Arbitrary rotation angle
rotation_matrix = cv2.getRotationMatrix2D((width/2, height/2), 45, 1)  # center, angle, scale
rotated_45 = cv2.warpAffine(image, rotation_matrix, (width, height))

# Flip the image
flipped_horizontal = cv2.flip(image, 1)  # 1 for horizontal flip
flipped_vertical = cv2.flip(image, 0)    # 0 for vertical flip
flipped_both = cv2.flip(image, -1)       # -1 for both horizontal and vertical flip

# Display the results
plt.figure(figsize=(15, 10))

plt.subplot(2, 3, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original')
plt.axis('off')

plt.subplot(2, 3, 2)
plt.imshow(cv2.cvtColor(resized_image, cv2.COLOR_BGR2RGB))
plt.title('Resized (300x200)')
plt.axis('off')

plt.subplot(2, 3, 3)
plt.imshow(cv2.cvtColor(rotated_45, cv2.COLOR_BGR2RGB))
plt.title('Rotated 45°')
plt.axis('off')

plt.subplot(2, 3, 4)
plt.imshow(cv2.cvtColor(flipped_horizontal, cv2.COLOR_BGR2RGB))
plt.title('Flipped Horizontal')
plt.axis('off')

plt.subplot(2, 3, 5)
plt.imshow(cv2.cvtColor(flipped_vertical, cv2.COLOR_BGR2RGB))
plt.title('Flipped Vertical')
plt.axis('off')

plt.subplot(2, 3, 6)
plt.imshow(cv2.cvtColor(rotated_90, cv2.COLOR_BGR2RGB))
plt.title('Rotated 90°')
plt.axis('off')

plt.tight_layout()
plt.show()

Cropping and Region of Interest (ROI)

import cv2
import matplotlib.pyplot as plt

# Load an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
height, width = image.shape[:2]

# Define region of interest (ROI) coordinates
# Format: [y_start:y_end, x_start:x_end]
roi = image[100:300, 200:400]  # Crop a 200x200 region

# Display the original image and ROI
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.imshow(image_rgb)
plt.title('Original Image')
# Draw a rectangle to show the ROI
plt.gca().add_patch(plt.Rectangle((200, 100), 200, 200, 
                                 edgecolor='red', facecolor='none', linewidth=2))
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(roi, cv2.COLOR_BGR2RGB))
plt.title('Cropped Region (ROI)')
plt.axis('off')

plt.tight_layout()
plt.show()

# Create a copy of the image and modify the ROI
image_copy = image.copy()
roi_to_modify = image_copy[100:300, 200:400]

# Apply an operation to the ROI (e.g., convert to grayscale and back to BGR)
gray_roi = cv2.cvtColor(roi_to_modify, cv2.COLOR_BGR2GRAY)
colored_gray_roi = cv2.cvtColor(gray_roi, cv2.COLOR_GRAY2BGR)
image_copy[100:300, 200:400] = colored_gray_roi

# Display the result
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(image_copy, cv2.COLOR_BGR2RGB))
plt.title('Image with Modified ROI')
plt.axis('off')

plt.tight_layout()
plt.show()

Filtering and Enhancement

Image filtering is the process of modifying or enhancing an image by applying various operations to its pixels. Let's explore some common filtering techniques:

Blurring and Smoothing

import cv2
import matplotlib.pyplot as plt
import numpy as np

# Load an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Apply different blurring techniques
# 1. Gaussian Blur
gaussian_blur = cv2.GaussianBlur(image, (5, 5), 0)  # (5, 5) is the kernel size

# 2. Median Blur (good for salt-and-pepper noise)
median_blur = cv2.medianBlur(image, 5)  # 5 is the kernel size

# 3. Average/Box Blur
box_blur = cv2.blur(image, (5, 5))  # (5, 5) is the kernel size

# 4. Bilateral Filter (edge-preserving smoothing)
bilateral_filter = cv2.bilateralFilter(image, 9, 75, 75)  # diameter, sigmaColor, sigmaSpace

# Display the results
plt.figure(figsize=(15, 10))

plt.subplot(2, 3, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original')
plt.axis('off')

plt.subplot(2, 3, 2)
plt.imshow(cv2.cvtColor(gaussian_blur, cv2.COLOR_BGR2RGB))
plt.title('Gaussian Blur')
plt.axis('off')

plt.subplot(2, 3, 3)
plt.imshow(cv2.cvtColor(median_blur, cv2.COLOR_BGR2RGB))
plt.title('Median Blur')
plt.axis('off')

plt.subplot(2, 3, 4)
plt.imshow(cv2.cvtColor(box_blur, cv2.COLOR_BGR2RGB))
plt.title('Box Blur')
plt.axis('off')

plt.subplot(2, 3, 5)
plt.imshow(cv2.cvtColor(bilateral_filter, cv2.COLOR_BGR2RGB))
plt.title('Bilateral Filter')
plt.axis('off')

plt.tight_layout()
plt.show()

Edge Detection

import cv2
import matplotlib.pyplot as plt
import numpy as np

# Load an image and convert to grayscale
image = cv2.imread('path/to/your/image.jpg')
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Apply different edge detection techniques
# 1. Sobel Edge Detection
sobelx = cv2.Sobel(gray_image, cv2.CV_64F, 1, 0, ksize=3)  # x direction
sobely = cv2.Sobel(gray_image, cv2.CV_64F, 0, 1, ksize=3)  # y direction
sobelx = np.uint8(np.absolute(sobelx))
sobely = np.uint8(np.absolute(sobely))
sobel_combined = cv2.bitwise_or(sobelx, sobely)

# 2. Laplacian Edge Detection
laplacian = cv2.Laplacian(gray_image, cv2.CV_64F)
laplacian = np.uint8(np.absolute(laplacian))

# 3. Canny Edge Detection
canny = cv2.Canny(gray_image, 100, 200)  # lower and upper thresholds

# Display the results
plt.figure(figsize=(15, 10))

plt.subplot(2, 3, 1)
plt.imshow(gray_image, cmap='gray')
plt.title('Original (Grayscale)')
plt.axis('off')

plt.subplot(2, 3, 2)
plt.imshow(sobelx, cmap='gray')
plt.title('Sobel X')
plt.axis('off')

plt.subplot(2, 3, 3)
plt.imshow(sobely, cmap='gray')
plt.title('Sobel Y')
plt.axis('off')

plt.subplot(2, 3, 4)
plt.imshow(sobel_combined, cmap='gray')
plt.title('Sobel Combined')
plt.axis('off')

plt.subplot(2, 3, 5)
plt.imshow(laplacian, cmap='gray')
plt.title('Laplacian')
plt.axis('off')

plt.subplot(2, 3, 6)
plt.imshow(canny, cmap='gray')
plt.title('Canny')
plt.axis('off')

plt.tight_layout()
plt.show()

Thresholding

import cv2
import matplotlib.pyplot as plt
import numpy as np

# Load an image and convert to grayscale
image = cv2.imread('path/to/your/image.jpg')
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Apply different thresholding techniques
# 1. Simple Binary Thresholding
ret, binary_thresh = cv2.threshold(gray_image, 127, 255, cv2.THRESH_BINARY)

# 2. Binary Inverse Thresholding
ret, binary_inv_thresh = cv2.threshold(gray_image, 127, 255, cv2.THRESH_BINARY_INV)

# 3. Truncate Thresholding
ret, trunc_thresh = cv2.threshold(gray_image, 127, 255, cv2.THRESH_TRUNC)

# 4. Adaptive Thresholding
adaptive_thresh = cv2.adaptiveThreshold(gray_image, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                       cv2.THRESH_BINARY, 11, 2)

# 5. Otsu's Thresholding (automatically determines optimal threshold value)
ret, otsu_thresh = cv2.threshold(gray_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# Display the results
plt.figure(figsize=(15, 10))

plt.subplot(2, 3, 1)
plt.imshow(gray_image, cmap='gray')
plt.title('Original (Grayscale)')
plt.axis('off')

plt.subplot(2, 3, 2)
plt.imshow(binary_thresh, cmap='gray')
plt.title('Binary Threshold')
plt.axis('off')

plt.subplot(2, 3, 3)
plt.imshow(binary_inv_thresh, cmap='gray')
plt.title('Binary Inverse')
plt.axis('off')

plt.subplot(2, 3, 4)
plt.imshow(trunc_thresh, cmap='gray')
plt.title('Truncate Threshold')
plt.axis('off')

plt.subplot(2, 3, 5)
plt.imshow(adaptive_thresh, cmap='gray')
plt.title('Adaptive Threshold')
plt.axis('off')

plt.subplot(2, 3, 6)
plt.imshow(otsu_thresh, cmap='gray')
plt.title('Otsu Threshold')
plt.axis('off')

plt.tight_layout()
plt.show()

Morphological Operations

import cv2
import matplotlib.pyplot as plt
import numpy as np

# Load an image and convert to grayscale
image = cv2.imread('path/to/your/image.jpg')
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Apply thresholding to get a binary image
ret, binary = cv2.threshold(gray_image, 127, 255, cv2.THRESH_BINARY_INV)

# Define a kernel for morphological operations
kernel = np.ones((5, 5), np.uint8)

# Apply different morphological operations
# 1. Erosion - shrinks bright regions, expands dark regions
erosion = cv2.erode(binary, kernel, iterations=1)

# 2. Dilation - expands bright regions, shrinks dark regions
dilation = cv2.dilate(binary, kernel, iterations=1)

# 3. Opening - erosion followed by dilation (removes small bright spots)
opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)

# 4. Closing - dilation followed by erosion (removes small dark holes)
closing = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)

# 5. Morphological Gradient - difference between dilation and erosion (finds object boundaries)
gradient = cv2.morphologyEx(binary, cv2.MORPH_GRADIENT, kernel)

# Display the results
plt.figure(figsize=(15, 10))

plt.subplot(2, 3, 1)
plt.imshow(binary, cmap='gray')
plt.title('Binary Image')
plt.axis('off')

plt.subplot(2, 3, 2)
plt.imshow(erosion, cmap='gray')
plt.title('Erosion')
plt.axis('off')

plt.subplot(2, 3, 3)
plt.imshow(dilation, cmap='gray')
plt.title('Dilation')
plt.axis('off')

plt.subplot(2, 3, 4)
plt.imshow(opening, cmap='gray')
plt.title('Opening')
plt.axis('off')

plt.subplot(2, 3, 5)
plt.imshow(closing, cmap='gray')
plt.title('Closing')
plt.axis('off')

plt.subplot(2, 3, 6)
plt.imshow(gradient, cmap='gray')
plt.title('Morphological Gradient')
plt.axis('off')

plt.tight_layout()
plt.show()

import cv2
import matplotlib.pyplot as plt
import numpy as np

def enhance_image(image_path):
    """
    A simple image enhancement pipeline that:
    1. Loads an image
    2. Applies noise reduction
    3. Enhances contrast
    4. Sharpens the image
    """
    # Load the image
    image = cv2.imread(image_path)
    
    # Convert to RGB for display
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Step 1: Noise reduction with bilateral filter (preserves edges)
    denoised = cv2.bilateralFilter(image, 9, 75, 75)
    
    # Step 2: Enhance contrast using CLAHE (Contrast Limited Adaptive Histogram Equalization)
    # Convert to LAB color space (L: lightness, A: green-red, B: blue-yellow)
    lab = cv2.cvtColor(denoised, cv2.COLOR_BGR2LAB)
    l, a, b = cv2.split(lab)
    
    # Apply CLAHE to the L channel
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
    cl = clahe.apply(l)
    
    # Merge the CLAHE enhanced L channel back with the A and B channels
    enhanced_lab = cv2.merge((cl, a, b))
    
    # Convert back to BGR color space
    enhanced = cv2.cvtColor(enhanced_lab, cv2.COLOR_LAB2BGR)
    
    # Step 3: Sharpen the image using an unsharp mask
    # Create a blurred version of the image
    gaussian = cv2.GaussianBlur(enhanced, (0, 0), 3)
    
    # Subtract the blurred image from the enhanced image and add back to the enhanced image
    sharpened = cv2.addWeighted(enhanced, 1.5, gaussian, -0.5, 0)
    
    # Convert results to RGB for display
    denoised_rgb = cv2.cvtColor(denoised, cv2.COLOR_BGR2RGB)
    enhanced_rgb = cv2.cvtColor(enhanced, cv2.COLOR_BGR2RGB)
    sharpened_rgb = cv2.cvtColor(sharpened, cv2.COLOR_BGR2RGB)
    
    # Display the results
    plt.figure(figsize=(15, 10))
    
    plt.subplot(2, 2, 1)
    plt.imshow(image_rgb)
    plt.title('Original Image')
    plt.axis('off')
    
    plt.subplot(2, 2, 2)
    plt.imshow(denoised_rgb)
    plt.title('Step 1: Noise Reduction')
    plt.axis('off')
    
    plt.subplot(2, 2, 3)
    plt.imshow(enhanced_rgb)
    plt.title('Step 2: Contrast Enhancement')
    plt.axis('off')
    
    plt.subplot(2, 2, 4)
    plt.imshow(sharpened_rgb)
    plt.title('Step 3: Sharpening')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()
    
    return sharpened

# Test the enhancement pipeline
enhanced_image = enhance_image('path/to/your/image.jpg')

# Save the enhanced image
cv2.imwrite('enhanced_image.jpg', enhanced_image)

Understanding Classification

Image classification involves training a model to recognize patterns in images that correspond to different categories. The process typically includes:

1. Data Collection: Gathering a dataset of labeled images
2. Feature Extraction: Identifying relevant features in the images
3. Model Training: Teaching the model to associate features with labels
4. Evaluation: Testing the model's performance on new images
5. Deployment: Using the model to classify new, unseen images

Let's start with a simple example using traditional machine learning before moving on to deep learning approaches:

Traditional Machine Learning Approach

import cv2
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score
import matplotlib.pyplot as plt
import glob
import os

# Function to extract features from an image
def extract_features(image_path):
    # Load image
    img = cv2.imread(image_path)
    
    # Resize to a fixed size
    img = cv2.resize(img, (100, 100))
    
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Extract HOG (Histogram of Oriented Gradients) features
    # This is a simple feature extraction method for demonstration
    # In practice, you might use more sophisticated features
    win_size = (100, 100)
    block_size = (20, 20)
    block_stride = (10, 10)
    cell_size = (10, 10)
    nbins = 9
    hog = cv2.HOGDescriptor(win_size, block_size, block_stride, cell_size, nbins)
    features = hog.compute(gray)
    
    return features.flatten()  # Flatten to 1D array

# Example: Classify images of cats and dogs
# Assuming you have a dataset with the following structure:
# dataset/
#   cats/
#     cat1.jpg
#     cat2.jpg
#     ...
#   dogs/
#     dog1.jpg
#     dog2.jpg
#     ...

def load_dataset(dataset_path):
    features = []
    labels = []
    
    # Load cat images
    cat_images = glob.glob(os.path.join(dataset_path, 'cats', '*.jpg'))
    for img_path in cat_images:
        features.append(extract_features(img_path))
        labels.append('cat')
    
    # Load dog images
    dog_images = glob.glob(os.path.join(dataset_path, 'dogs', '*.jpg'))
    for img_path in dog_images:
        features.append(extract_features(img_path))
        labels.append('dog')
    
    return np.array(features), np.array(labels)

# Load the dataset
# features, labels = load_dataset('path/to/dataset')

# For demonstration, let's create some dummy data
np.random.seed(42)
num_samples = 100
feature_dim = 1764  # Typical HOG feature dimension for 100x100 image
features = np.random.rand(num_samples, feature_dim)
labels = np.random.choice(['cat', 'dog'], size=num_samples)

# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)

# Train a Random Forest classifier
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

# Make predictions on the test set
y_pred = clf.predict(X_test)

# Evaluate the model
accuracy = accuracy_score(y_test, y_pred)
report = classification_report(y_test, y_pred)

print(f"Accuracy: {accuracy:.2f}")
print("Classification Report:")
print(report)

# Function to classify a new image
def classify_image(image_path, model):
    # Extract features
    features = extract_features(image_path)
    
    # Make prediction
    prediction = model.predict([features])[0]
    
    # Get probability
    probability = np.max(model.predict_proba([features]))
    
    return prediction, probability

# Example usage
# prediction, probability = classify_image('path/to/new/image.jpg', clf)
# print(f"Prediction: {prediction}, Probability: {probability:.2f}")

While traditional machine learning approaches can work well for simple classification tasks, they often struggle with complex image data. This is where deep learning, particularly Convolutional Neural Networks (CNNs), excels.

Convolutional Neural Networks

Convolutional Neural Networks (CNNs) have revolutionized image classification by automatically learning hierarchical features from images. Let's explore how to implement a CNN for image classification using TensorFlow/Keras:

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import numpy as np

# Set random seed for reproducibility
tf.random.set_seed(42)
np.random.seed(42)

# Define a simple CNN architecture
def create_cnn_model(input_shape=(150, 150, 3), num_classes=2):
    model = models.Sequential([
        # First convolutional block
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),
        layers.MaxPooling2D((2, 2)),
        
        # Second convolutional block
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        
        # Third convolutional block
        layers.Conv2D(128, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        
        # Flatten and dense layers
        layers.Flatten(),
        layers.Dense(512, activation='relu'),
        layers.Dropout(0.5),  # Add dropout to prevent overfitting
        layers.Dense(num_classes, activation='softmax')  # softmax for multi-class classification
    ])
    
    # Compile the model
    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    
    return model

# Create the model
model = create_cnn_model()

# Print model summary
model.summary()

# Data augmentation for training
train_datagen = ImageDataGenerator(
    rescale=1./255,  # Normalize pixel values
    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'
)

# Only rescaling for validation
validation_datagen = ImageDataGenerator(rescale=1./255)

# Example: Load data from directories
# Assuming you have a dataset with the following structure:
# dataset/
#   train/
#     cats/
#       cat1.jpg
#       cat2.jpg
#       ...
#     dogs/
#       dog1.jpg
#       dog2.jpg
#       ...
#   validation/
#     cats/
#       cat1.jpg
#       cat2.jpg
#       ...
#     dogs/
#       dog1.jpg
#       dog2.jpg
#       ...

# Load training data
train_generator = train_datagen.flow_from_directory(
    'path/to/dataset/train',
    target_size=(150, 150),
    batch_size=32,
    class_mode='categorical'
)

# Load validation data
validation_generator = validation_datagen.flow_from_directory(
    'path/to/dataset/validation',
    target_size=(150, 150),
    batch_size=32,
    class_mode='categorical'
)

# Train the model
# history = model.fit(
#     train_generator,
#     steps_per_epoch=train_generator.samples // 32,
#     epochs=20,
#     validation_data=validation_generator,
#     validation_steps=validation_generator.samples // 32
# )

# For demonstration, let's create some dummy data
# In practice, you would use real data from the generators above
dummy_train_data = np.random.rand(100, 150, 150, 3)
dummy_train_labels = tf.keras.utils.to_categorical(np.random.randint(0, 2, 100), num_classes=2)
dummy_val_data = np.random.rand(20, 150, 150, 3)
dummy_val_labels = tf.keras.utils.to_categorical(np.random.randint(0, 2, 20), num_classes=2)

# Train on dummy data
history = model.fit(
    dummy_train_data, dummy_train_labels,
    epochs=5,
    validation_data=(dummy_val_data, dummy_val_labels)
)

# Plot training history
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

# Function to predict class for a new image
def predict_image(image_path, model):
    # Load and preprocess the image
    img = tf.keras.preprocessing.image.load_img(image_path, target_size=(150, 150))
    img_array = tf.keras.preprocessing.image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0) / 255.0  # Normalize
    
    # Make prediction
    predictions = model.predict(img_array)
    
    # Get class with highest probability
    predicted_class = np.argmax(predictions, axis=1)[0]
    probability = np.max(predictions)
    
    # Map class index to class name
    class_names = list(train_generator.class_indices.keys())
    predicted_class_name = class_names[predicted_class]
    
    return predicted_class_name, probability

# Example usage
# predicted_class, probability = predict_image('path/to/new/image.jpg', model)
# print(f"Predicted class: {predicted_class}, Probability: {probability:.2f}")

# Save the model
# model.save('cat_dog_classifier.h5')

Popular Pre-trained Models for Transfer Learning

Each model has its strengths and trade-offs in terms of accuracy, speed, and size. Choose the one that best fits your specific requirements.

import tensorflow as tf
from tensorflow.keras import layers, models
import matplotlib.pyplot as plt
import numpy as np

# Load the CIFAR-10 dataset
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.cifar10.load_data()

# Normalize pixel values to be between 0 and 1
train_images = train_images.astype('float32') / 255.0
test_images = test_images.astype('float32') / 255.0

# Convert labels to one-hot encoding
train_labels = tf.keras.utils.to_categorical(train_labels, 10)
test_labels = tf.keras.utils.to_categorical(test_labels, 10)

# Define the class names
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 
               'dog', 'frog', 'horse', 'ship', 'truck']

# Display some sample images
plt.figure(figsize=(10, 10))
for i in range(25):
    plt.subplot(5, 5, i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i])
    plt.xlabel(class_names[np.argmax(train_labels[i])])
plt.tight_layout()
plt.show()

# Create a CNN model
model = models.Sequential([
    # First convolutional block
    layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)),
    layers.BatchNormalization(),
    layers.Conv2D(32, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.2),
    
    # Second convolutional block
    layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.3),
    
    # Third convolutional block
    layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.4),
    
    # Dense layers
    layers.Flatten(),
    layers.Dense(128, activation='relu'),
    layers.BatchNormalization(),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')  # 10 classes
])

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

# Print model summary
model.summary()

# Use data augmentation to improve model generalization
datagen = tf.keras.preprocessing.image.ImageDataGenerator(
    rotation_range=15,
    width_shift_range=0.1,
    height_shift_range=0.1,
    horizontal_flip=True,
    zoom_range=0.1
)

datagen.fit(train_images)

# Train the model with data augmentation
history = model.fit(
    datagen.flow(train_images, train_labels, batch_size=64),
    steps_per_epoch=len(train_images) // 64,
    epochs=30,
    validation_data=(test_images, test_labels),
    callbacks=[
        tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
        tf.keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=3)
    ]
)

# Evaluate the model
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f"Test accuracy: {test_acc:.4f}")

# Plot training history
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

# Visualize predictions on test images
def visualize_predictions(model, images, labels, class_names, num_images=25):
    # Make predictions
    predictions = model.predict(images[:num_images])
    predicted_classes = np.argmax(predictions, axis=1)
    true_classes = np.argmax(labels[:num_images], axis=1)
    
    # Plot images with predictions
    plt.figure(figsize=(10, 10))
    for i in range(num_images):
        plt.subplot(5, 5, i+1)
        plt.xticks([])
        plt.yticks([])
        plt.grid(False)
        plt.imshow(images[i])
        
        color = 'green' if predicted_classes[i] == true_classes[i] else 'red'
        plt.xlabel(f"{class_names[predicted_classes[i]]}", color=color)
    
    plt.tight_layout()
    plt.show()

# Visualize predictions
visualize_predictions(model, test_images, test_labels, class_names)

# Save the model
model.save('cifar10_classifier.h5')

Detection Fundamentals

Object detection combines two tasks:

1. Object Localization: Determining the location of objects in an image, typically by drawing bounding boxes around them.
2. Object Classification: Identifying the class or category of each detected object.

There are several approaches to object detection:

Let's start with a simple example using a traditional method before moving on to more advanced deep learning approaches.

Traditional Object Detection with Haar Cascades

Haar cascades are a machine learning-based approach where a cascade function is trained from positive and negative images. It's particularly effective for face detection and was one of the first real-time object detection frameworks.

import cv2
import matplotlib.pyplot as plt
import numpy as np

# Load an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Convert to grayscale (required for Haar cascades)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Load the pre-trained Haar cascade for face detection
# OpenCV comes with several pre-trained cascades for faces, eyes, etc.
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

# Detect faces
faces = face_cascade.detectMultiScale(
    gray,
    scaleFactor=1.1,  # Parameter specifying how much the image size is reduced at each image scale
    minNeighbors=5,   # Parameter specifying how many neighbors each candidate rectangle should have
    minSize=(30, 30)  # Minimum possible object size
)

print(f"Found {len(faces)} faces!")

# Draw rectangles around the faces
image_with_faces = image_rgb.copy()
for (x, y, w, h) in faces:
    cv2.rectangle(image_with_faces, (x, y), (x+w, y+h), (0, 255, 0), 2)

# Display the results
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(image_with_faces)
plt.title(f'Detected Faces: {len(faces)}')
plt.axis('off')

plt.tight_layout()
plt.show()

# You can also detect other objects like eyes within the detected faces
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')

image_with_faces_eyes = image_rgb.copy()
for (x, y, w, h) in faces:
    # Draw rectangle around the face
    cv2.rectangle(image_with_faces_eyes, (x, y), (x+w, y+h), (0, 255, 0), 2)
    
    # Extract the region of interest (ROI) for the face
    roi_gray = gray[y:y+h, x:x+w]
    roi_color = image_with_faces_eyes[y:y+h, x:x+w]
    
    # Detect eyes within the face ROI
    eyes = eye_cascade.detectMultiScale(roi_gray)
    for (ex, ey, ew, eh) in eyes:
        cv2.rectangle(roi_color, (ex, ey), (ex+ew, ey+eh), (255, 0, 0), 2)

# Display the results
plt.figure(figsize=(10, 8))
plt.imshow(image_with_faces_eyes)
plt.title('Detected Faces and Eyes')
plt.axis('off')
plt.show()

YOLO Implementation

YOLO (You Only Look Once) is a state-of-the-art, real-time object detection system. Unlike traditional methods, YOLO applies a single neural network to the full image, dividing it into regions and predicting bounding boxes and probabilities for each region. This approach is significantly faster and more accurate than traditional methods.

We'll use YOLOv8, the latest version of the YOLO family, which offers improved accuracy and speed. YOLOv8 is implemented in the Ultralytics library, which provides a user-friendly API for object detection tasks.

Installing and Setting Up YOLOv8

# Install the ultralytics package
pip install ultralytics

Basic Object Detection with YOLOv8

from ultralytics import YOLO
import cv2
import matplotlib.pyplot as plt
import numpy as np

# Load a pretrained YOLOv8 model
model = YOLO('yolov8n.pt')  # 'n' for nano, other options: 's' (small), 'm' (medium), 'l' (large), 'x' (xlarge)

# Load an image
image_path = 'path/to/your/image.jpg'
image = cv2.imread(image_path)
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Perform object detection
results = model(image_rgb)

# Display the results
plt.figure(figsize=(12, 10))
plt.imshow(results[0].plot())  # The plot() method draws bounding boxes and labels on the image
plt.axis('off')
plt.title('YOLOv8 Object Detection')
plt.show()

# Process the detection results
for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    
    print(f"Detected {len(boxes)} objects:")
    
    for box in boxes:
        # Get box coordinates (in xyxy format)
        x1, y1, x2, y2 = box.xyxy[0]  # xyxy format (x1, y1, x2, y2)
        x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
        
        # Get confidence score
        conf = float(box.conf[0])
        
        # Get class name
        cls = int(box.cls[0])
        class_name = model.names[cls]
        
        print(f"  {class_name}: {conf:.2f} at position [{x1}, {y1}, {x2}, {y2}]")
        
        # Draw bounding box and label on a copy of the image
        image_with_box = image_rgb.copy()
        cv2.rectangle(image_with_box, (x1, y1), (x2, y2), (0, 255, 0), 2)
        cv2.putText(image_with_box, f"{class_name} {conf:.2f}", (x1, y1 - 10), 
                    cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)

Object Detection in Videos

YOLO is particularly useful for real-time object detection in videos. Here's how to apply it to video streams:

from ultralytics import YOLO
import cv2
import numpy as np
import time

# Load a pretrained YOLOv8 model
model = YOLO('yolov8n.pt')

# Open a video file or webcam
video_path = 'path/to/your/video.mp4'  # or 0 for webcam
cap = cv2.VideoCapture(video_path)

# Get video properties
frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = cap.get(cv2.CAP_PROP_FPS)

# Create a VideoWriter object to save the output video (optional)
output_path = 'output_video.mp4'
fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # Codec for mp4 format
out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))

# Process the video frame by frame
while cap.isOpened():
    # Read a frame
    success, frame = cap.read()
    
    if not success:
        break  # End of video or error
    
    # Start time for FPS calculation
    start_time = time.time()
    
    # Perform object detection
    results = model.track(frame, persist=True)  # persist=True maintains tracking between frames
    
    # Calculate FPS
    fps_current = 1 / (time.time() - start_time)
    
    # Draw the results on the frame
    result_frame = results[0].plot()
    
    # Add FPS text
    cv2.putText(result_frame, f"FPS: {fps_current:.1f}", (20, 40), 
                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
    
    # Write the frame to the output video
    out.write(result_frame)
    
    # Display the frame
    cv2.imshow('YOLOv8 Object Detection', result_frame)
    
    # Break the loop if 'q' is pressed
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Release resources
cap.release()
out.release()
cv2.destroyAllWindows()

Tracking Objects Across Frames

For applications like surveillance or sports analysis, you might want to track objects across video frames. YOLOv8 supports object tracking with the ByteTrack algorithm:

from ultralytics import YOLO
import cv2
import numpy as np

# Load a pretrained YOLOv8 model
model = YOLO('yolov8n.pt')

# Open a video file or webcam
video_path = 'path/to/your/video.mp4'  # or 0 for webcam
cap = cv2.VideoCapture(video_path)

# Get video properties
frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = cap.get(cv2.CAP_PROP_FPS)

# Create a VideoWriter object to save the output video (optional)
output_path = 'output_tracking.mp4'
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))

# Store track colors for visualization
track_colors = {}

# Process the video frame by frame
while cap.isOpened():
    # Read a frame
    success, frame = cap.read()
    
    if not success:
        break  # End of video or error
    
    # Perform object tracking (note the 'track' argument)
    results = model.track(frame, persist=True)  # persist=True maintains tracking between frames
    
    # Create a copy of the frame for drawing
    annotated_frame = frame.copy()
    
    if results[0].boxes is not None and hasattr(results[0].boxes, 'id'):
        boxes = results[0].boxes.xyxy.cpu().numpy().astype(int)
        track_ids = results[0].boxes.id.cpu().numpy().astype(int)
        classes = results[0].boxes.cls.cpu().numpy().astype(int)
        
        # Draw bounding boxes and track IDs
        for box, track_id, cls in zip(boxes, track_ids, classes):
            x1, y1, x2, y2 = box
            
            # Assign a consistent color to each track ID
            if track_id not in track_colors:
                # Generate a random color for this track ID
                track_colors[track_id] = (
                    np.random.randint(0, 255),
                    np.random.randint(0, 255),
                    np.random.randint(0, 255)
                )
            
            color = track_colors[track_id]
            class_name = model.names[cls]
            
            # Draw bounding box
            cv2.rectangle(annotated_frame, (x1, y1), (x2, y2), color, 2)
            
            # Draw track ID and class name
            label = f"ID: {track_id}, {class_name}"
            cv2.putText(annotated_frame, label, (x1, y1 - 10), 
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
    
    # Write the frame to the output video
    out.write(annotated_frame)
    
    # Display the frame
    cv2.imshow('YOLOv8 Object Tracking', annotated_frame)
    
    # Break the loop if 'q' is pressed
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Release resources
cap.release()
out.release()
cv2.destroyAllWindows()

Custom Object Detection

While pre-trained models are powerful, you might need to detect objects specific to your application that aren't included in the standard COCO dataset (e.g., specific products, logos, or custom items). In this section, we'll explore how to train a custom YOLOv8 model on your own dataset.

Preparing Your Dataset

To train a custom object detection model, you need a labeled dataset. The dataset should be organized in the YOLO format:

dataset/
├── train/
│   ├── images/
│   │   ├── image1.jpg
│   │   ├── image2.jpg
│   │   └── ...
│   └── labels/
│       ├── image1.txt
│       ├── image2.txt
│       └── ...
├── val/
│   ├── images/
│   │   ├── image1.jpg
│   │   ├── image2.jpg
│   │   └── ...
│   └── labels/
│       ├── image1.txt
│       ├── image2.txt
│       └── ...
└── data.yaml

Each label file (e.g., image1.txt) contains one line per object in the corresponding image, with the format:

class_id x_center y_center width height

Where:

• class_id: Integer representing the class (starting from 0)
• x_center, y_center: Normalized center coordinates of the bounding box (from 0 to 1)
• width, height: Normalized width and height of the bounding box (from 0 to 1)

The data.yaml file defines your dataset configuration:

path: /path/to/dataset  # Path to the dataset root
train: train/images     # Path to train images (relative to 'path')
val: val/images         # Path to validation images (relative to 'path')

# Class names
names:
  0: class1
  1: class2
  ...

Training a Custom YOLOv8 Model

Once your dataset is prepared, you can train a custom YOLOv8 model:

from ultralytics import YOLO

# Load a pre-trained YOLOv8 model to start with (transfer learning)
model = YOLO('yolov8n.pt')  # or 'yolov8s.pt', 'yolov8m.pt', etc.

# Train the model on your custom dataset
results = model.train(
    data='path/to/your/data.yaml',  # Path to your data.yaml file
    epochs=100,                     # Number of training epochs
    imgsz=640,                      # Image size
    batch=16,                       # Batch size
    patience=20,                    # Early stopping patience
    device='0'                      # GPU device (use '0' for first GPU, 'cpu' for CPU)
)

# Validate the model
val_results = model.val()

# Export the model to ONNX format (for deployment)
model.export(format='onnx')

You can monitor the training progress using Tensorboard:

%load_ext tensorboard
%tensorboard --logdir runs/detect/train

Using Your Custom Model for Inference

After training, you can use your custom model for inference just like a pre-trained model:

from ultralytics import YOLO
import cv2
import matplotlib.pyplot as plt

# Load your trained model
model = YOLO('runs/detect/train/weights/best.pt')  # Path to your best weights

# Load an image
image = cv2.imread('path/to/test/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Perform object detection
results = model(image_rgb)

# Display the results
plt.figure(figsize=(12, 10))
plt.imshow(results[0].plot())
plt.axis('off')
plt.title('Custom Object Detection')
plt.show()

Improving Model Performance

Here are some tips to improve your custom object detection model:

from ultralytics import YOLO
import cv2
import os
import numpy as np
import argparse
import time

def process_image(model, image_path, output_dir, conf_threshold=0.25):
    """Process a single image with object detection."""
    # Load the image
    image = cv2.imread(image_path)
    if image is None:
        print(f"Error: Could not load image {image_path}")
        return
    
    # Perform object detection
    results = model(image, conf=conf_threshold)
    
    # Draw results on the image
    result_image = results[0].plot()
    
    # Create output directory if it doesn't exist
    os.makedirs(output_dir, exist_ok=True)
    
    # Save the result image
    output_path = os.path.join(output_dir, os.path.basename(image_path))
    cv2.imwrite(output_path, result_image)
    
    print(f"Processed {image_path} -> {output_path}")
    
    # Return detection information
    return results[0].boxes

def process_video(model, video_path, output_dir, conf_threshold=0.25):
    """Process a video with object detection."""
    # Open the video
    cap = cv2.VideoCapture(video_path)
    if not cap.isOpened():
        print(f"Error: Could not open video {video_path}")
        return
    
    # Get video properties
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fps = cap.get(cv2.CAP_PROP_FPS)
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    
    # Create output directory if it doesn't exist
    os.makedirs(output_dir, exist_ok=True)
    
    # Create output video writer
    output_path = os.path.join(output_dir, os.path.basename(video_path))
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
    
    # Process the video frame by frame
    frame_count = 0
    start_time = time.time()
    
    while cap.isOpened():
        # Read a frame
        success, frame = cap.read()
        if not success:
            break
        
        # Perform object detection
        results = model(frame, conf=conf_threshold)
        
        # Draw results on the frame
        result_frame = results[0].plot()
        
        # Write the frame to the output video
        out.write(result_frame)
        
        # Update progress
        frame_count += 1
        if frame_count % 10 == 0:
            elapsed_time = time.time() - start_time
            frames_per_second = frame_count / elapsed_time
            remaining_frames = total_frames - frame_count
            estimated_time = remaining_frames / frames_per_second if frames_per_second > 0 else 0
            
            print(f"Processing: {frame_count}/{total_frames} frames "
                  f"({frame_count/total_frames*100:.1f}%) - "
                  f"ETA: {estimated_time:.1f}s")
    
    # Release resources
    cap.release()
    out.release()
    
    print(f"Processed {video_path} -> {output_path}")
    print(f"Total frames: {frame_count}, Time: {time.time() - start_time:.1f}s")

def main():
    # Parse command line arguments
    parser = argparse.ArgumentParser(description='Object Detection with YOLOv8')
    parser.add_argument('--model', type=str, default='yolov8n.pt', help='Path to YOLOv8 model')
    parser.add_argument('--source', type=str, required=True, help='Path to image or video file')
    parser.add_argument('--output', type=str, default='output', help='Output directory')
    parser.add_argument('--conf', type=float, default=0.25, help='Confidence threshold')
    args = parser.parse_args()
    
    # Load the model
    model = YOLO(args.model)
    
    # Check if the source is an image or video
    if os.path.isfile(args.source):
        # Get file extension
        _, ext = os.path.splitext(args.source)
        ext = ext.lower()
        
        # Process based on file type
        if ext in ['.jpg', '.jpeg', '.png', '.bmp', '.webp']:
            process_image(model, args.source, args.output, args.conf)
        elif ext in ['.mp4', '.avi', '.mov', '.mkv']:
            process_video(model, args.source, args.output, args.conf)
        else:
            print(f"Unsupported file format: {ext}")
    elif os.path.isdir(args.source):
        # Process all images in the directory
        image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.webp']
        for filename in os.listdir(args.source):
            _, ext = os.path.splitext(filename)
            if ext.lower() in image_extensions:
                image_path = os.path.join(args.source, filename)
                process_image(model, image_path, args.output, args.conf)
    else:
        print(f"Error: Source {args.source} not found")

if __name__ == "__main__":
    main()

# Process an image
python object_detection.py --model yolov8n.pt --source path/to/image.jpg --output results

# Process a video
python object_detection.py --model yolov8n.pt --source path/to/video.mp4 --output results

# Process all images in a directory
python object_detection.py --model yolov8n.pt --source path/to/images_dir --output results

# Use a custom model with a lower confidence threshold
python object_detection.py --model path/to/custom_model.pt --source path/to/image.jpg --output results --conf 0.4

Segmentation Approaches

There are several approaches to image segmentation, each with its own strengths and applications:

Let's start with some traditional segmentation methods before moving on to deep learning approaches.

Thresholding-based Segmentation

Thresholding is one of the simplest segmentation techniques. It separates pixels into different classes based on their intensity values.

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load an image and convert to grayscale
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Apply global thresholding
ret, thresh1 = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# Apply Otsu's thresholding (automatically determines optimal threshold value)
ret, thresh2 = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# Apply adaptive thresholding
adaptive_thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                       cv2.THRESH_BINARY, 11, 2)

# Display the results
plt.figure(figsize=(15, 10))

plt.subplot(2, 2, 1)
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')

plt.subplot(2, 2, 2)
plt.imshow(thresh1, cmap='gray')
plt.title('Global Thresholding')
plt.axis('off')

plt.subplot(2, 2, 3)
plt.imshow(thresh2, cmap='gray')
plt.title('Otsu Thresholding')
plt.axis('off')

plt.subplot(2, 2, 4)
plt.imshow(adaptive_thresh, cmap='gray')
plt.title('Adaptive Thresholding')
plt.axis('off')

plt.tight_layout()
plt.show()

# Create a color mask for visualization
# Apply the threshold to create a binary mask
mask = thresh2 > 0

# Create a colored mask for visualization
colored_mask = np.zeros_like(image)
colored_mask[mask] = [0, 255, 0]  # Green color for the segmented region

# Blend the original image with the colored mask
alpha = 0.5  # Transparency factor
segmented_image = cv2.addWeighted(image, 1 - alpha, colored_mask, alpha, 0)

# Display the segmented image
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(segmented_image, cv2.COLOR_BGR2RGB))
plt.title('Segmented Image (Thresholding)')
plt.axis('off')

plt.tight_layout()
plt.show()

Watershed Segmentation

The watershed algorithm treats the image as a topographic surface, where high intensity denotes hills and low intensity denotes valleys. It segments the image by "flooding" the valleys.

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Convert to grayscale and apply thresholding
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)

# Noise removal with morphological operations
kernel = np.ones((3, 3), np.uint8)
opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)

# Sure background area
sure_bg = cv2.dilate(opening, kernel, iterations=3)

# Finding sure foreground area
dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
ret, sure_fg = cv2.threshold(dist_transform, 0.7 * dist_transform.max(), 255, 0)

# Finding unknown region
sure_fg = np.uint8(sure_fg)
unknown = cv2.subtract(sure_bg, sure_fg)

# Marker labelling
ret, markers = cv2.connectedComponents(sure_fg)

# Add one to all labels so that background is not 0, but 1
markers = markers + 1

# Mark the unknown region with 0
markers[unknown == 255] = 0

# Apply watershed algorithm
markers = cv2.watershed(image, markers)

# Create a color map for visualization
colors = np.random.randint(0, 255, size=(np.max(markers) + 1, 3), dtype=np.uint8)
colors[0] = [0, 0, 0]  # Background color (black)

# Create a colored segmentation map
segmentation_map = colors[markers]

# Create a boundary image (where markers == -1)
image_with_boundaries = image_rgb.copy()
image_with_boundaries[markers == -1] = [255, 0, 0]  # Red color for boundaries

# Display the results
plt.figure(figsize=(15, 10))

plt.subplot(2, 2, 1)
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')

plt.subplot(2, 2, 2)
plt.imshow(thresh, cmap='gray')
plt.title('Thresholded Image')
plt.axis('off')

plt.subplot(2, 2, 3)
plt.imshow(segmentation_map)
plt.title('Watershed Segmentation (Regions)')
plt.axis('off')

plt.subplot(2, 2, 4)
plt.imshow(image_with_boundaries)
plt.title('Watershed Segmentation (Boundaries)')
plt.axis('off')

plt.tight_layout()
plt.show()

K-means Clustering for Segmentation

K-means clustering is an unsupervised learning algorithm that can be used to segment an image by grouping similar pixels together.

import cv2
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

# Load an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Reshape the image to a 2D array of pixels
pixel_values = image_rgb.reshape((-1, 3))
pixel_values = np.float32(pixel_values)

# Define criteria and apply K-means
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.2)
k = 5  # Number of clusters
_, labels, centers = cv2.kmeans(pixel_values, k, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)

# Convert back to 8-bit values
centers = np.uint8(centers)

# Map the labels to the centers
segmented_image = centers[labels.flatten()]

# Reshape back to the original image shape
segmented_image = segmented_image.reshape(image_rgb.shape)

# Display the results
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(segmented_image)
plt.title(f'K-means Segmentation (k={k})')
plt.axis('off')

plt.tight_layout()
plt.show()

# Create individual masks for each segment
masks = []
for i in range(k):
    mask = np.zeros(labels.shape, dtype=np.uint8)
    mask[labels == i] = 255
    mask = mask.reshape(image.shape[:2])
    masks.append(mask)

# Display each segment separately
plt.figure(figsize=(15, 8))

for i in range(k):
    plt.subplot(2, 3, i+1)
    
    # Create a colored mask for this segment
    colored_mask = np.zeros_like(image)
    colored_mask[masks[i] == 255] = [0, 255, 0]  # Green color
    
    # Blend with original image
    alpha = 0.5
    blended = cv2.addWeighted(image, 1 - alpha, colored_mask, alpha, 0)
    
    plt.imshow(cv2.cvtColor(blended, cv2.COLOR_BGR2RGB))
    plt.title(f'Segment {i+1}')
    plt.axis('off')

plt.tight_layout()
plt.show()

Face Detection

Face detection is the process of locating faces within an image. It's a prerequisite for face recognition tasks. We'll use OpenCV's Haar cascades for face detection.

import cv2
import matplotlib.pyplot as plt
import numpy as np

# Load an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Convert to grayscale (required for Haar cascades)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Load the pre-trained Haar cascade for face detection
# OpenCV comes with several pre-trained cascades for faces, eyes, etc.
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

# Detect faces
faces = face_cascade.detectMultiScale(
    gray,
    scaleFactor=1.1,  # Parameter specifying how much the image size is reduced at each image scale
    minNeighbors=5,   # Parameter specifying how many neighbors each candidate rectangle should have
    minSize=(30, 30)  # Minimum possible object size
)

print(f"Found {len(faces)} faces!")

# Draw rectangles around the faces
image_with_faces = image_rgb.copy()
for (x, y, w, h) in faces:
    cv2.rectangle(image_with_faces, (x, y), (x+w, y+h), (0, 255, 0), 2)

# Display the results
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(image_with_faces)
plt.title(f'Detected Faces: {len(faces)}')
plt.axis('off')

plt.tight_layout()
plt.show()

# You can also detect other objects like eyes within the detected faces
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')

image_with_faces_eyes = image_rgb.copy()
for (x, y, w, h) in faces:
    # Draw rectangle around the face
    cv2.rectangle(image_with_faces_eyes, (x, y), (x+w, y+h), (0, 255, 0), 2)
    
    # Extract the region of interest (ROI) for the face
    roi_gray = gray[y:y+h, x:x+w]
    roi_color = image_with_faces_eyes[y:y+h, x:x+w]
    
    # Detect eyes within the face ROI
    eyes = eye_cascade.detectMultiScale(roi_gray)
    for (ex, ey, ew, eh) in eyes:
        cv2.rectangle(roi_color, (ex, ey), (ex+ew, ey+eh), (255, 0, 0), 2)

# Display the results
plt.figure(figsize=(10, 8))
plt.imshow(image_with_faces_eyes)
plt.title('Detected Faces and Eyes')
plt.axis('off')
plt.show()

Facial Landmarks

Facial landmarks are points on the face that are used to describe its shape. They can be used for various applications, such as face alignment, expression analysis, and 3D face reconstruction.

import cv2
import matplotlib.pyplot as plt
import numpy as np

# Load an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Convert to grayscale (required for facial landmark detection)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Load the pre-trained facial landmark detector
# OpenCV comes with several pre-trained models for facial landmark detection
landmark_detector = cv2.face.createFacemarkLBF()
landmark_detector.loadModel('path/to/lbfmodel.yaml')

# Detect facial landmarks
_, landmarks = landmark_detector.fit(gray, cv2.cvtColor(image, cv2.COLOR_BGR2RGB))

# Draw landmarks on the image
image_with_landmarks = image_rgb.copy()
for landmark in landmarks[0]:
    cv2.circle(image_with_landmarks, tuple(landmark[0]), 2, (0, 255, 0), -1)

# Display the results
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(image_with_landmarks)
plt.title('Facial Landmarks')
plt.axis('off')

plt.tight_layout()
plt.show()

Face Identification

Face identification is the process of recognizing a person's identity based on their face. It's a challenging problem due to variations in facial expressions, lighting, and pose. We'll use OpenCV's face recognition module for face identification.

import cv2
import matplotlib.pyplot as plt
import numpy as np

# Load an image
image = cv2.imread('path/to/your/image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Convert to grayscale (required for face recognition)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Load the pre-trained face recognition model
# OpenCV comes with several pre-trained models for face recognition
face_recognizer = cv2.face.LBPHFaceRecognizer_create()
face_recognizer.read('path/to/trained_model.xml')

# Detect faces
faces = face_cascade.detectMultiScale(gray)

# Recognize faces
for (x, y, w, h) in faces:
    face_roi = gray[y:y+h, x:x+w]
    label, confidence = face_recognizer.predict(face_roi)
    print(f"Label: {label}, Confidence: {confidence}")
    
    # Draw a rectangle around the face
    cv2.rectangle(image_rgb, (x, y), (x+w, y+h), (0, 255, 0), 2)
    cv2.putText(image_rgb, f"{label} ({confidence:.2f})", (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)

# Display the results
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(image_rgb, cv2.COLOR_BGR2RGB))
plt.title('Face Identification')
plt.axis('off')

plt.tight_layout()
plt.show()

Generative Adversarial Networks (GANs)

Generative Adversarial Networks (GANs) are a type of deep learning model that can generate new images that are similar to images in a training dataset. Let's explore how to implement a GAN for image generation using TensorFlow/Keras:

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import numpy as np

# Set random seed for reproducibility
tf.random.set_seed(42)
np.random.seed(42)

# Define a simple GAN architecture
def create_gan(generator, discriminator):
    model = models.Sequential([
        # Generator
        generator,
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(512, kernel_size=4, strides=1, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(256, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(128, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(64, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(1, kernel_size=4, strides=1, padding="same"),
        layers.Activation('tanh')
    ])
    
    return model

# Define the generator and discriminator
generator = create_gan(generator, discriminator)
discriminator = create_gan(generator, discriminator)

# Compile the models
generator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')
discriminator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')

# Create a dataset
(train_images, _), (_, _) = tf.keras.datasets.mnist.load_data()
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
train_images = (train_images - 127.5) / 127.5  # Normalize to [-1, 1]

# Create a dataset for the discriminator
dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(60000).batch(256)

# Train the GAN
for epoch in range(100):
    for image_batch in dataset:
        # Train the discriminator
        with tf.GradientTape() as disc_tape:
            real_output = discriminator(image_batch, training=True)
            fake_output = discriminator(generator(tf.random.normal([256, 100])), training=True)
            disc_loss = discriminator_loss(real_output, fake_output)
        
        disc_gradients = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
        discriminator.optimizer.apply_gradients(zip(disc_gradients, discriminator.trainable_variables))
        
        # Train the generator
        with tf.GradientTape() as gen_tape:
            fake_output = discriminator(generator(tf.random.normal([256, 100])), training=True)
            gen_loss = generator_loss(fake_output)
        
        gen_gradients = gen_tape.gradient(gen_loss, generator.trainable_variables)
        generator.optimizer.apply_gradients(zip(gen_gradients, generator.trainable_variables))
        
        print(f"Epoch {epoch+1} - Discriminator loss: {disc_loss:.4f}, Generator loss: {gen_loss:.4f}")
        
        # Generate and save images
        generate_and_save_images(generator, epoch, tf.random.normal([16, 100]))

# Function to generate and save images
def generate_and_save_images(model, epoch, test_input):
    # Note: The training=True is intentional here since
    # we want the batch statistics for normal distribution
    predictions = model(test_input, training=True)
    fig = plt.figure(figsize=(4, 4))
    
    for i in range(predictions.shape[0]):
        plt.subplot(4, 4, i+1)
        plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
        plt.axis('off')
    
    plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
    plt.show()

Conditional GANs

Conditional GANs are a type of GAN that can generate images based on specific conditions. Let's explore how to implement a conditional GAN for image generation using TensorFlow/Keras:

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import numpy as np

# Set random seed for reproducibility
tf.random.set_seed(42)
np.random.seed(42)

# Define a simple GAN architecture
def create_gan(generator, discriminator):
    model = models.Sequential([
        # Generator
        generator,
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(512, kernel_size=4, strides=1, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(256, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(128, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(64, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(1, kernel_size=4, strides=1, padding="same"),
        layers.Activation('tanh')
    ])
    
    return model

# Define the generator and discriminator
generator = create_gan(generator, discriminator)
discriminator = create_gan(generator, discriminator)

# Compile the models
generator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')
discriminator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')

# Create a dataset
(train_images, _), (_, _) = tf.keras.datasets.mnist.load_data()
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
train_images = (train_images - 127.5) / 127.5  # Normalize to [-1, 1]

# Create a dataset for the discriminator
dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(60000).batch(256)

# Train the GAN
for epoch in range(100):
    for image_batch in dataset:
        # Train the discriminator
        with tf.GradientTape() as disc_tape:
            real_output = discriminator(image_batch, training=True)
            fake_output = discriminator(generator(tf.random.normal([256, 100])), training=True)
            disc_loss = discriminator_loss(real_output, fake_output)
        
        disc_gradients = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
        discriminator.optimizer.apply_gradients(zip(disc_gradients, discriminator.trainable_variables))
        
        # Train the generator
        with tf.GradientTape() as gen_tape:
            fake_output = discriminator(generator(tf.random.normal([256, 100])), training=True)
            gen_loss = generator_loss(fake_output)
        
        gen_gradients = gen_tape.gradient(gen_loss, generator.trainable_variables)
        generator.optimizer.apply_gradients(zip(gen_gradients, generator.trainable_variables))
        
        print(f"Epoch {epoch+1} - Discriminator loss: {disc_loss:.4f}, Generator loss: {gen_loss:.4f}")
        
        # Generate and save images
        generate_and_save_images(generator, epoch, tf.random.normal([16, 100]))

# Function to generate and save images
def generate_and_save_images(model, epoch, test_input):
    # Note: The training=True is intentional here since
    # we want the batch statistics for normal distribution
    predictions = model(test_input, training=True)
    fig = plt.figure(figsize=(4, 4))
    
    for i in range(predictions.shape[0]):
        plt.subplot(4, 4, i+1)
        plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
        plt.axis('off')
    
    plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
    plt.show()

Style Transfer

Style transfer is the process of transferring the style of one image to another image. Let's explore how to implement style transfer using TensorFlow/Keras:

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import numpy as np

# Set random seed for reproducibility
tf.random.set_seed(42)
np.random.seed(42)

# Define a simple GAN architecture
def create_gan(generator, discriminator):
    model = models.Sequential([
        # Generator
        generator,
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(512, kernel_size=4, strides=1, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(256, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(128, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(64, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(1, kernel_size=4, strides=1, padding="same"),
        layers.Activation('tanh')
    ])
    
    return model

# Define the generator and discriminator
generator = create_gan(generator, discriminator)
discriminator = create_gan(generator, discriminator)

# Compile the models
generator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')
discriminator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')

# Create a dataset
(train_images, _), (_, _) = tf.keras.datasets.mnist.load_data()
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
train_images = (train_images - 127.5) / 127.5  # Normalize to [-1, 1]

# Create a dataset for the discriminator
dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(60000).batch(256)

# Train the GAN
for epoch in range(100):
    for image_batch in dataset:
        # Train the discriminator
        with tf.GradientTape() as disc_tape:
            real_output = discriminator(image_batch, training=True)
            fake_output = discriminator(generator(tf.random.normal([256, 100])), training=True)
            disc_loss = discriminator_loss(real_output, fake_output)
        
        disc_gradients = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
        discriminator.optimizer.apply_gradients(zip(disc_gradients, discriminator.trainable_variables))
        
        # Train the generator
        with tf.GradientTape() as gen_tape:
            fake_output = discriminator(generator(tf.random.normal([256, 100])), training=True)
            gen_loss = generator_loss(fake_output)
        
        gen_gradients = gen_tape.gradient(gen_loss, generator.trainable_variables)
        generator.optimizer.apply_gradients(zip(gen_gradients, generator.trainable_variables))
        
        print(f"Epoch {epoch+1} - Discriminator loss: {disc_loss:.4f}, Generator loss: {gen_loss:.4f}")
        
        # Generate and save images
        generate_and_save_images(generator, epoch, tf.random.normal([16, 100]))

# Function to generate and save images
def generate_and_save_images(model, epoch, test_input):
    # Note: The training=True is intentional here since
    # we want the batch statistics for normal distribution
    predictions = model(test_input, training=True)
    fig = plt.figure(figsize=(4, 4))
    
    for i in range(predictions.shape[0]):
        plt.subplot(4, 4, i+1)
        plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
        plt.axis('off')
    
    plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
    plt.show()

Diffusion Models

Diffusion models are a type of deep learning model that can generate new images by gradually denoising a noisy image. Let's explore how to implement a diffusion model for image generation using TensorFlow/Keras:

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import numpy as np

# Set random seed for reproducibility
tf.random.set_seed(42)
np.random.seed(42)

# Define a simple GAN architecture
def create_gan(generator, discriminator):
    model = models.Sequential([
        # Generator
        generator,
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(512, kernel_size=4, strides=1, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(256, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(128, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(64, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(1, kernel_size=4, strides=1, padding="same"),
        layers.Activation('tanh')
    ])
    
    return model

# Define the generator and discriminator
generator = create_gan(generator, discriminator)
discriminator = create_gan(generator, discriminator)

# Compile the models
generator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')
discriminator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')

# Create a dataset
(train_images, _), (_, _) = tf.keras.datasets.mnist.load_data()
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
train_images = (train_images - 127.5) / 127.5  # Normalize to [-1, 1]

# Create a dataset for the discriminator
dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(60000).batch(256)

# Train the GAN
for epoch in range(100):
    for image_batch in dataset:
        # Train the discriminator
        with tf.GradientTape() as disc_tape:
            real_output = discriminator(image_batch, training=True)
            fake_output = discriminator(generator(tf.random.normal([256, 100])), training=True)
            disc_loss = discriminator_loss(real_output, fake_output)
        
        disc_gradients = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
        discriminator.optimizer.apply_gradients(zip(disc_gradients, discriminator.trainable_variables))
        
        # Train the generator
        with tf.GradientTape() as gen_tape:
            fake_output = discriminator(generator(tf.random.normal([256, 100])), training=True)
            gen_loss = generator_loss(fake_output)
        
        gen_gradients = gen_tape.gradient(gen_loss, generator.trainable_variables)
        generator.optimizer.apply_gradients(zip(gen_gradients, generator.trainable_variables))
        
        print(f"Epoch {epoch+1} - Discriminator loss: {disc_loss:.4f}, Generator loss: {gen_loss:.4f}")
        
        # Generate and save images
        generate_and_save_images(generator, epoch, tf.random.normal([16, 100]))

# Function to generate and save images
def generate_and_save_images(model, epoch, test_input):
    # Note: The training=True is intentional here since
    # we want the batch statistics for normal distribution
    predictions = model(test_input, training=True)
    fig = plt.figure(figsize=(4, 4))
    
    for i in range(predictions.shape[0]):
        plt.subplot(4, 4, i+1)
        plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
        plt.axis('off')
    
    plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
    plt.show()

Neural Style Transfer

Neural Style Transfer is the process of applying the style of one image to another image. Let's explore how to implement neural style transfer using TensorFlow/Keras:

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import numpy as np

# Set random seed for reproducibility
tf.random.set_seed(42)
np.random.seed(42)

# Define a simple GAN architecture
def create_gan(generator, discriminator):
    model = models.Sequential([
        # Generator
        generator,
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(512, kernel_size=4, strides=1, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(256, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(128, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(64, kernel_size=4, strides=2, padding="same"),
        layers.BatchNormalization(momentum=0.8),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(1, kernel_size=4, strides=1, padding="same"),
        layers.Activation('tanh')
    ])
    
    return model

# Define the generator and discriminator
generator = create_gan(generator, discriminator)
discriminator = create_gan(generator, discriminator)

# Compile the models
generator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')
discriminator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')

# Create a dataset
(train_images, _), (_, _) = tf.keras.datasets.mnist.load_data()
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
train_images = (train_images - 127.5) / 127.5  # Normalize to [-1, 1]

# Create a dataset for the discriminator
dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(60000).batch(256)

# Train the GAN
for epoch in range(100):
    for image_batch in dataset:
        # Train the discriminator
        with tf.GradientTape() as disc_tape:
            real_output = discriminator(image_batch, training=True)
            fake_output = discriminator(generator(tf.random.normal([256, 100])), training=True)
            disc_loss = discriminator_loss(real_output, fake_output)
        
        disc_gradients = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
        discriminator.optimizer.apply_gradients(zip(disc_gradients, discriminator.trainable_variables))
        
        # Train the generator
        with tf.GradientTape() as gen_tape:
            fake_output = discriminator(generator(tf.random.normal([256, 100])), training=True)
            gen_loss = generator_loss(fake_output)
        
        gen_gradients = gen_tape.gradient(gen_loss, generator.trainable_variables)
        generator.optimizer.apply_gradients(zip(gen_gradients, generator.trainable_variables))
        
        print(f"Epoch {epoch+1} - Discriminator loss: {disc_loss:.4f}, Generator loss: {gen_loss:.4f}")
        
        # Generate and save images
        generate_and_save_images(generator, epoch, tf.random.normal([16, 100]))

# Function to generate and save images
def generate_and_save_images(model, epoch, test_input):
    # Note: The training=True is intentional here since
    # we want the batch statistics for normal distribution
    predictions = model(test_input, training=True)
    fig = plt.figure(figsize=(4, 4))
    
    for i in range(predictions.shape[0]):
        plt.subplot(4, 4, i+1)
        plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
        plt.axis('off')
    
    plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
    plt.show()

Model Optimization

Model optimization is the process of reducing the size of a model while maintaining its accuracy. This is important for deploying models on devices with limited resources. We'll explore different techniques for model optimization, including quantization and pruning.

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import numpy as np

# Set random seed for reproducibility
tf.random.set_seed(42)
np.random.seed(42)

# Define a simple CNN architecture
def create_cnn_model(input_shape=(150, 150, 3), num_classes=2):
    model = models.Sequential([
        # First convolutional block
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),
        layers.MaxPooling2D((2, 2)),
        
        # Second convolutional block
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        
        # Third convolutional block
        layers.Conv2D(128, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        
        # Flatten and dense layers
        layers.Flatten(),
        layers.Dense(512, activation='relu'),
        layers.Dropout(0.5),  # Add dropout to prevent overfitting
        layers.Dense(num_classes, activation='softmax')  # softmax for multi-class classification
    ])
    
    # Compile the model
    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    
    return model

# Create the model
model = create_cnn_model()

# Print model summary
model.summary()

# Data augmentation for training
train_datagen = ImageDataGenerator(
    rescale=1./255,  # Normalize pixel values
    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'
)

# Only rescaling for validation
validation_datagen = ImageDataGenerator(rescale=1./255)

# Example: Load data from directories
# Assuming you have a dataset with the following structure:
# dataset/
#   train/
#     cats/
#       cat1.jpg
#       cat2.jpg
#       ...
#     dogs/
#       dog1.jpg
#       dog2.jpg
#       ...
#   validation/
#     cats/
#       cat1.jpg
#       cat2.jpg
#       ...
#     dogs/
#       dog1.jpg
#       dog2.jpg
#       ...

# Load training data
train_generator = train_datagen.flow_from_directory(
    'path/to/dataset/train',
    target_size=(150, 150),
    batch_size=32,
    class_mode='categorical'
)

# Load validation data
validation_generator = validation_datagen.flow_from_directory(
    'path/to/dataset/validation',
    target_size=(150, 150),
    batch_size=32,
    class_mode='categorical'
)

# Train the model
# history = model.fit(
#     train_generator,
#     steps_per_epoch=train_generator.samples // 32,
#     epochs=20,
#     validation_data=validation_generator,
#     validation_steps=validation_generator.samples // 32
# )

# For demonstration, let's create some dummy data
# In practice, you would use real data from the generators above
dummy_train_data = np.random.rand(100, 150, 150, 3)
dummy_train_labels = tf.keras.utils.to_categorical(np.random.randint(0, 2, 100), num_classes=2)
dummy_val_data = np.random.rand(20, 150, 150, 3)
dummy_val_labels = tf.keras.utils.to_categorical(np.random.randint(0, 2, 20), num_classes=2)

# Train on dummy data
history = model.fit(
    dummy_train_data, dummy_train_labels,
    epochs=5,
    validation_data=(dummy_val_data, dummy_val_labels)
)

# Plot training history
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

# Function to predict class for a new image
def predict_image(image_path, model):
    # Load and preprocess the image
    img = tf.keras.preprocessing.image.load_img(image_path, target_size=(150, 150))
    img_array = tf.keras.preprocessing.image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0) / 255.0  # Normalize
    
    # Make prediction
    predictions = model.predict(img_array)
    
    # Get class with highest probability
    predicted_class = np.argmax(predictions, axis=1)[0]
    probability = np.max(predictions)
    
    # Map class index to class name
    class_names = list(train_generator.class_indices.keys())
    predicted_class_name = class_names[predicted_class]
    
    return predicted_class_name, probability

# Example usage
# predicted_class, probability = predict_image('path/to/new/image.jpg', model)
# print(f"Predicted class: {predicted_class}, Probability: {probability:.2f}")

# Save the model
# model.save('cat_dog_classifier.h5')

Popular Pre-trained Models for Transfer Learning

Each model has its strengths and trade-offs in terms of accuracy, speed, and size. Choose the one that best fits your specific requirements.

import tensorflow as tf
from tensorflow.keras import layers, models
import matplotlib.pyplot as plt
import numpy as np

# Load the CIFAR-10 dataset
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.cifar10.load_data()

# Normalize pixel values to be between 0 and 1
train_images = train_images.astype('float32') / 255.0
test_images = test_images.astype('float32') / 255.0

# Convert labels to one-hot encoding
train_labels = tf.keras.utils.to_categorical(train_labels, 10)
test_labels = tf.keras.utils.to_categorical(test_labels, 10)

# Define the class names
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 
               'dog', 'frog', 'horse', 'ship', 'truck']

# Display some sample images
plt.figure(figsize=(10, 10))
for i in range(25):
    plt.subplot(5, 5, i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i])
    plt.xlabel(class_names[np.argmax(train_labels[i])])
plt.tight_layout()
plt.show()

# Create a CNN model
model = models.Sequential([
    # First convolutional block
    layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)),
    layers.BatchNormalization(),
    layers.Conv2D(32, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.2),
    
    # Second convolutional block
    layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.3),
    
    # Third convolutional block
    layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.4),
    
    # Dense layers
    layers.Flatten(),
    layers.Dense(128, activation='relu'),
    layers.BatchNormalization(),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')  # 10 classes
])

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

# Print model summary
model.summary()

# Use data augmentation to improve model generalization
datagen = tf.keras.preprocessing.image.ImageDataGenerator(
    rotation_range=15,
    width_shift_range=0.1,
    height_shift_range=0.1,
    horizontal_flip=True,
    zoom_range=0.1
)

datagen.fit(train_images)

# Train the model with data augmentation
history = model.fit(
    datagen.flow(train_images, train_labels, batch_size=64),
    steps_per_epoch=len(train_images) // 64,
    epochs=30,
    validation_data=(test_images, test_labels),
    callbacks=[
        tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
        tf.keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=3)
    ]
)

# Evaluate the model
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f"Test accuracy: {test_acc:.4f}")

# Plot training history
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

# Visualize predictions on test images
def visualize_predictions(model, images, labels, class_names, num_images=25):
    # Make predictions
    predictions = model.predict(images[:num_images])
    predicted_classes = np.argmax(predictions, axis=1)
    true_classes = np.argmax(labels[:num_images], axis=1)
    
    # Plot images with predictions
    plt.figure(figsize=(10, 10))
    for i in range(num_images):
        plt.subplot(5, 5, i+1)
        plt.xticks([])
        plt.yticks([])
        plt.grid(False)
        plt.imshow(images[i])
        
        color = 'green' if predicted_classes[i] == true_classes[i] else 'red'
        plt.xlabel(f"{class_names[predicted_classes[i]]}", color=color)
    
    plt.tight_layout()
    plt.show()

# Visualize predictions
visualize_predictions(model, test_images, test_labels, class_names)

# Save the model
model.save('cifar10_classifier.h5')

Web Deployment

Deploying a computer vision model on a web application can be done using various frameworks and libraries. We'll cover how to deploy a model using Flask and TensorFlow Serving.

from flask import Flask, request, render_template
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import numpy as np

# Load the model
model = tf.keras.models.load_model('path/to/your/model.h5')

app = Flask(__name__)

@app.route('/', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        if 'file' not in request.files:
            return render_template('error.html')
        
        file = request.files['file']
        if not file.filename:
            return render_template('error.html')
        
        # Read the image file
        image = file.read()
        image = tf.io.decode_image(image, channels=3)
        image = tf.image.resize(image, [150, 150])
        image = tf.expand_dims(image, 0)
        image = image / 255.0
        
        # Make prediction
        predictions = model.predict(image)
        predicted_class = np.argmax(predictions[0])
        probability = np.max(predictions[0])
        
        return render_template('result.html', predicted_class=predicted_class, probability=probability)
    
    return render_template('index.html')

if __name__ == '__main__':
    app.run(debug=True)

Edge Deployment

Deploying a computer vision model on an edge device can be done using various frameworks and libraries. We'll cover how to deploy a model using TensorFlow Lite and OpenCV.

import cv2
import numpy as np
import tensorflow as tf
from tensorflow.lite.python import interpreter_wrapper

# Load the model
interpreter = interpreter_wrapper.Interpreter(model_path='path/to/your/model.tflite')
interpreter.allocate_tensors()

# Get input and output tensors
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

def predict(image):
    # Preprocess the image
    image = cv2.resize(image, input_details[0]['shape'][1:3])
    image = np.expand_dims(image, axis=0)
    image = image / 255.0
    
    # Set the input tensor
    interpreter.set_tensor(input_details[0]['index'], image)
    
    # Run inference
    interpreter.invoke()
    
    # Get the output tensor
    output_data = interpreter.get_tensor(output_details[0]['index'])
    predicted_class = np.argmax(output_data[0])
    probability = np.max(output_data[0])
    
    return predicted_class, probability

# Example usage
image = cv2.imread('path/to/your/image.jpg')
predicted_class, probability = predict(image)
print(f"Predicted class: {predicted_class}, Probability: {probability:.2f}")

Further Learning

Here are some resources to help you continue learning computer vision:

• Machine Learning with OpenCV: A course on Coursera that covers computer vision and machine learning techniques
• OpenCV with Python for Beginners: A course on Udemy that covers computer vision and image processing with OpenCV
• Deep Learning: A book on deep learning that covers a wide range of topics in computer vision
• TensorFlow Tutorials: TensorFlow's official tutorials that cover a wide range of topics in computer vision
• PyImageSearch: A blog that covers computer vision and deep learning techniques

Project Ideas

Here are some project ideas to help you apply your skills:

• Build a real-time object detection system for a specific application (e.g., traffic monitoring, security, agriculture)
• Create a face recognition system for a specific application (e.g., attendance system, security system)
• Develop a semantic segmentation system for a specific application (e.g., medical imaging, autonomous vehicles)
• Implement a style transfer system for artistic purposes
• Build a diffusion model for image generation

Recommended Resources

Here are some recommended resources to help you get started with computer vision:

• TensorFlow Tutorials: TensorFlow's official tutorials that cover a wide range of topics in computer vision
• PyImageSearch: A blog that covers computer vision and deep learning techniques
• Machine Learning with OpenCV: A course on Coursera that covers computer vision and machine learning techniques
• OpenCV with Python for Beginners: A course on Udemy that covers computer vision and image processing with OpenCV
• Deep Learning: A book on deep learning that covers a wide range of topics in computer vision