Comprehensive comparison for AI technology in Deep Learning applications

import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models, callbacks
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from sklearn.model_selection import train_test_split
import logging
import os

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

class ImageClassificationPipeline:
    def __init__(self, input_shape=(224, 224, 3), num_classes=10, model_path='models/'):
        self.input_shape = input_shape
        self.num_classes = num_classes
        self.model_path = model_path
        self.model = None
        os.makedirs(model_path, exist_ok=True)
    
    def build_model(self):
        try:
            model = models.Sequential([
                layers.Conv2D(32, (3, 3), activation='relu', input_shape=self.input_shape),
                layers.BatchNormalization(),
                layers.MaxPooling2D((2, 2)),
                layers.Dropout(0.25),
                
                layers.Conv2D(64, (3, 3), activation='relu'),
                layers.BatchNormalization(),
                layers.MaxPooling2D((2, 2)),
                layers.Dropout(0.25),
                
                layers.Conv2D(128, (3, 3), activation='relu'),
                layers.BatchNormalization(),
                layers.MaxPooling2D((2, 2)),
                layers.Dropout(0.25),
                
                layers.Flatten(),
                layers.Dense(256, activation='relu'),
                layers.BatchNormalization(),
                layers.Dropout(0.5),
                layers.Dense(self.num_classes, activation='softmax')
            ])
            
            model.compile(
                optimizer=keras.optimizers.Adam(learning_rate=0.001),
                loss='categorical_crossentropy',
                metrics=['accuracy', keras.metrics.TopKCategoricalAccuracy(k=3)]
            )
            
            self.model = model
            logger.info("Model built successfully")
            return model
        except Exception as e:
            logger.error(f"Error building model: {str(e)}")
            raise
    
    def train(self, X_train, y_train, X_val, y_val, epochs=50, batch_size=32):
        if self.model is None:
            raise ValueError("Model not built. Call build_model() first.")
        
        try:
            datagen = ImageDataGenerator(
                rotation_range=20,
                width_shift_range=0.2,
                height_shift_range=0.2,
                horizontal_flip=True,
                zoom_range=0.15,
                fill_mode='nearest'
            )
            
            callback_list = [
                callbacks.ModelCheckpoint(
                    filepath=os.path.join(self.model_path, 'best_model.h5'),
                    monitor='val_accuracy',
                    save_best_only=True,
                    verbose=1
                ),
                callbacks.EarlyStopping(
                    monitor='val_loss',
                    patience=10,
                    restore_best_weights=True,
                    verbose=1
                ),
                callbacks.ReduceLROnPlateau(
                    monitor='val_loss',
                    factor=0.5,
                    patience=5,
                    min_lr=1e-7,
                    verbose=1
                ),
                callbacks.TensorBoard(
                    log_dir=os.path.join(self.model_path, 'logs'),
                    histogram_freq=1
                )
            ]
            
            history = self.model.fit(
                datagen.flow(X_train, y_train, batch_size=batch_size),
                validation_data=(X_val, y_val),
                epochs=epochs,
                callbacks=callback_list,
                verbose=1
            )
            
            logger.info("Training completed successfully")
            return history
        except Exception as e:
            logger.error(f"Error during training: {str(e)}")
            raise
    
    def predict(self, X_test):
        if self.model is None:
            raise ValueError("Model not available. Train or load a model first.")
        
        try:
            predictions = self.model.predict(X_test, verbose=0)
            return predictions
        except Exception as e:
            logger.error(f"Error during prediction: {str(e)}")
            raise
    
    def save_model(self, filename='final_model.h5'):
        if self.model is None:
            raise ValueError("No model to save")
        
        filepath = os.path.join(self.model_path, filename)
        self.model.save(filepath)
        logger.info(f"Model saved to {filepath}")
    
    def load_model(self, filename='final_model.h5'):
        filepath = os.path.join(self.model_path, filename)
        if not os.path.exists(filepath):
            raise FileNotFoundError(f"Model file not found: {filepath}")
        
        self.model = keras.models.load_model(filepath)
        logger.info(f"Model loaded from {filepath}")
        return self.model