Comprehensive comparison for AI technology in Deep Learning applications

import caffe
import numpy as np
import os
import logging
from caffe.proto import caffe_pb2
from google.protobuf import text_format

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class ImageClassifier:
    """
    Production-ready image classifier using Caffe for deep learning inference.
    Handles model loading, preprocessing, and batch prediction with error handling.
    """
    
    def __init__(self, model_def, model_weights, mean_file=None, gpu_mode=False):
        """
        Initialize the classifier with model files and configuration.
        
        Args:
            model_def: Path to the network definition (.prototxt)
            model_weights: Path to the trained model weights (.caffemodel)
            mean_file: Path to the mean file for preprocessing
            gpu_mode: Whether to use GPU for inference
        """
        self.model_def = model_def
        self.model_weights = model_weights
        self.mean_file = mean_file
        self.net = None
        self.transformer = None
        
        try:
            self._validate_files()
            self._initialize_network(gpu_mode)
            self._setup_transformer()
            logger.info("ImageClassifier initialized successfully")
        except Exception as e:
            logger.error(f"Failed to initialize classifier: {str(e)}")
            raise
    
    def _validate_files(self):
        """Validate that all required files exist."""
        if not os.path.exists(self.model_def):
            raise FileNotFoundError(f"Model definition not found: {self.model_def}")
        if not os.path.exists(self.model_weights):
            raise FileNotFoundError(f"Model weights not found: {self.model_weights}")
        if self.mean_file and not os.path.exists(self.mean_file):
            raise FileNotFoundError(f"Mean file not found: {self.mean_file}")
    
    def _initialize_network(self, gpu_mode):
        """Initialize the Caffe network."""
        if gpu_mode:
            caffe.set_mode_gpu()
            caffe.set_device(0)
            logger.info("Using GPU mode")
        else:
            caffe.set_mode_cpu()
            logger.info("Using CPU mode")
        
        self.net = caffe.Net(self.model_def, self.model_weights, caffe.TEST)
    
    def _setup_transformer(self):
        """Setup image transformer for preprocessing."""
        input_shape = self.net.blobs['data'].data.shape
        self.transformer = caffe.io.Transformer({'data': input_shape})
        
        # Transpose to Caffe's (channel, height, width) format
        self.transformer.set_transpose('data', (2, 0, 1))
        
        # Load and set mean values
        if self.mean_file:
            mean_blob = caffe_pb2.BlobProto()
            with open(self.mean_file, 'rb') as f:
                mean_blob.ParseFromString(f.read())
            mean_array = np.array(caffe.io.blobproto_to_array(mean_blob))[0]
            self.transformer.set_mean('data', mean_array)
        else:
            # Use ImageNet mean values as default
            self.transformer.set_mean('data', np.array([104.0, 117.0, 123.0]))
        
        # Scale to [0, 255] range
        self.transformer.set_raw_scale('data', 255)
        
        # Swap RGB to BGR
        self.transformer.set_channel_swap('data', (2, 1, 0))
    
    def predict(self, image_path, top_k=5):
        """
        Predict class probabilities for a single image.
        
        Args:
            image_path: Path to the input image
            top_k: Number of top predictions to return
            
        Returns:
            List of tuples (class_index, probability)
        """
        try:
            if not os.path.exists(image_path):
                raise FileNotFoundError(f"Image not found: {image_path}")
            
            # Load and preprocess image
            image = caffe.io.load_image(image_path)
            transformed_image = self.transformer.preprocess('data', image)
            
            # Reshape network for single image
            self.net.blobs['data'].reshape(1, *transformed_image.shape)
            self.net.blobs['data'].data[...] = transformed_image
            
            # Forward pass
            output = self.net.forward()
            probabilities = output['prob'][0]
            
            # Get top-k predictions
            top_indices = probabilities.argsort()[-top_k:][::-1]
            predictions = [(idx, float(probabilities[idx])) for idx in top_indices]
            
            logger.info(f"Successfully predicted for image: {image_path}")
            return predictions
            
        except Exception as e:
            logger.error(f"Prediction failed for {image_path}: {str(e)}")
            raise
    
    def predict_batch(self, image_paths, batch_size=32):
        """
        Predict class probabilities for multiple images in batches.
        
        Args:
            image_paths: List of paths to input images
            batch_size: Number of images to process in each batch
            
        Returns:
            Dictionary mapping image paths to prediction lists
        """
        results = {}
        
        for i in range(0, len(image_paths), batch_size):
            batch_paths = image_paths[i:i + batch_size]
            batch_images = []
            
            for path in batch_paths:
                try:
                    if os.path.exists(path):
                        image = caffe.io.load_image(path)
                        transformed = self.transformer.preprocess('data', image)
                        batch_images.append(transformed)
                    else:
                        logger.warning(f"Skipping missing image: {path}")
                        results[path] = None
                except Exception as e:
                    logger.error(f"Error loading {path}: {str(e)}")
                    results[path] = None
            
            if batch_images:
                # Reshape and process batch
                batch_array = np.array(batch_images)
                self.net.blobs['data'].reshape(*batch_array.shape)
                self.net.blobs['data'].data[...] = batch_array
                
                output = self.net.forward()
                probabilities = output['prob']
                
                for j, path in enumerate(batch_paths):
                    if path not in results:
                        top_idx = probabilities[j].argsort()[-5:][::-1]
                        results[path] = [(idx, float(probabilities[j][idx])) for idx in top_idx]
        
        logger.info(f"Batch prediction completed for {len(image_paths)} images")
        return results