push main.ipynb utils.py and model.py

models.py

@@ -0,0 +1,40 @@
+from tensorflow.keras.models import Sequential
+import tensorflow.keras.layers as tfl
+
+def cat_dog_model(image_size, image_channel):
+    model = Sequential([
+        # Block 1
+        tfl.Conv2D(32, (3, 3), activation='relu', input_shape=(image_size, image_size, image_channel)),
+        tfl.BatchNormalization(),
+        tfl.MaxPooling2D(pool_size=(2, 2)),
+        tfl.Dropout(0.2),
+
+        # Block 2
+        tfl.Conv2D(64, (3, 3), activation='relu'),
+        tfl.BatchNormalization(),
+        tfl.MaxPooling2D(pool_size=(2, 2)),
+        tfl.Dropout(0.2),
+
+        # Block 3
+        tfl.Conv2D(128, (3, 3), activation='relu'),
+        tfl.BatchNormalization(),
+        tfl.MaxPooling2D(pool_size=(2, 2)),
+        tfl.Dropout(0.2),
+
+        # Block 4
+        tfl.Conv2D(256, (3, 3), activation='relu'),
+        tfl.BatchNormalization(),
+        tfl.MaxPooling2D(pool_size=(2, 2)),
+        tfl.Dropout(0.2),
+
+        # Fully Connected Layers
+        tfl.Flatten(),
+        tfl.Dense(512, activation='relu'),
+        tfl.BatchNormalization(),
+        tfl.Dropout(0.2),
+
+        # Output Layer (Softmax for multi-class classification)
+        tfl.Dense(1, activation='sigmoid')
+    ])
+    
+    return model

utils.py

@@ -0,0 +1,109 @@
+from PIL import Image
+import matplotlib.pyplot as plt
+import seaborn as sns
+import pandas as pd
+import numpy as np
+
+# for image processing
+from tensorflow.keras.preprocessing.image import load_img, img_to_array
+from sklearn.metrics import confusion_matrix
+
+
+def validate_image(file_path):
+    """Validate image integrity
+        Some images are corrupted and cannot be opened by PIL
+    Args:
+        file_path (str): Image file path
+    Returns:
+        bool: True if image is valid, False otherwise"""
+    
+    try:
+        with Image.open(file_path) as img:
+            # Verify image integrity
+            img.verify()
+        return True
+    except Exception as e:
+        print(f"Corrupted image: {file_path} - Error: {e}")
+        return False
+    
+
+def visualize_image(train_path, class_name="cat"):
+    """Display image
+    Args:
+        file_path (str): Image file path
+        class_name (str): Image class name
+    Returns:
+        10 images of the specified class"""
+    
+    plt.figure(figsize=(20,20))
+    plt.subplots_adjust(hspace=0.4)
+
+    for i in range(10):
+        plt.subplot(1,10,i+1)
+        filename = train_path +'\\'+ f'{class_name}.' + str(i) + '.jpg'
+        image = Image.open(filename)
+        plt.imshow(image)
+        plt.title(f'{class_name}',fontsize=12)
+        plt.axis('off')
+
+    plt.show()
+
+def visulaize_ouput(history):
+    """Visualize model training output
+    Args:
+        history (tensorflow.python.keras.callbacks.History): Model training history
+    Returns:
+        plot of Loss and Accuracy"""
+    
+    result_df = pd.DataFrame(history.history)
+
+    plt.figure(figsize=(18,5),dpi=200)
+    sns.set_style('darkgrid')
+
+    plt.subplot(121)
+    plt.title('Cross Entropy Loss',fontsize=15)
+    plt.xlabel('Epochs',fontsize=12)
+    plt.ylabel('Loss',fontsize=12)
+    plt.plot(result_df['loss'])
+    plt.plot(result_df['val_loss'])
+
+    plt.subplot(122)
+    plt.title('Classification Accuracy',fontsize=15)
+    plt.xlabel('Epochs',fontsize=12)
+    plt.ylabel('Accuracy',fontsize=12)
+    plt.plot(result_df['accuracy'])
+    plt.plot(result_df['val_accuracy'])
+
+    plt.show()
+
+
+def predictor(model, image_path, classes, img_size=(128, 128)):
+    """Predict image class
+    Args:
+        model (tensorflow.python.keras.engine.sequential.Sequential): Model
+        image_path (str): Image file path
+        classes (list): List of class names
+        img_size (tuple): Image size
+    Returns:
+        Image class prediction with plots"""
+    
+    img = load_img(image_path, target_size=img_size)  
+    img_array = img_to_array(img) / 255.0 
+    img_array = np.expand_dims(img_array, axis=0)
+
+    predictions = model.predict(img_array)
+    predicted_class = np.argmax(predictions, axis=1)[0] 
+    print(predictions)
+    print(predicted_class)
+    confidence = predictions[0][predicted_class]
+    print(confidence)
+    if confidence > 0.5:
+        predicted_class = 1
+    else:
+        predicted_class = 0
+    
+    plt.imshow(img)
+    plt.axis('off')
+    plt.title(f"Prediction: {classes[predicted_class]}")
+    plt.show()
+