Update cnn_SaveInPainting.py

cnn_SaveInPainting.py

@@ -1,281 +1,255 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Sat May 18 16:15:32 2024
-@author: litav
-"""
-
-# -*- coding: utf-8 -*-
-"""
-Created on Sat May 18 16:15:32 2024
-@author: litav
-"""
-
-
-#dropout 0.5
-# Set parameters for cross-validation
-#kf = KFold(n_splits=4, shuffle=True, random_state=42)
-#batch_size = 64
-#epochs = 15
-#Average accuracy across all folds: 78.56%
-#Test Loss: 0.49228477478027344, Test Accuracy: 0.7706093192100525
-#Classification Summary:
-#Real images correctly classified: 107
-#Real images incorrectly classified: 32
-#Fake images correctly classified: 108
-#Fake images incorrectly classified: 32
-#Classification Report:
-#              precision    recall  f1-score   support
-#
-#        Real       0.77      0.77      0.77       139
-#        Fake       0.77      0.77      0.77       140
-
-
-
-import numpy as np
-import tensorflow as tf
-import random
-import os
-import pandas as pd
-import cv2
-import matplotlib.pyplot as plt
-from sklearn.model_selection import KFold
-from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten
-from tensorflow.keras.optimizers import Adam
-from tensorflow.keras.models import Sequential
-from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay
-from tensorflow.keras.layers import Dropout
-from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
-from sklearn.metrics import precision_score, recall_score, f1_score, classification_report
-
-
-# Suppress iCCP warning
-import warnings
-warnings.filterwarnings("ignore", category=UserWarning, message=".*iCCP:.*")
-
-# Define data paths
-train_real_folder = 'datasets/training_set/real/'
-train_fake_folder = 'datasets/training_set/fake/'
-test_real_folder = 'datasets/test_set/real/'
-test_fake_folder = 'datasets/test_set/fake/'
-
-# Load train image paths and labels
-train_image_paths = []
-train_labels = []
-
-# Load train_real image paths and labels
-for filename in os.listdir(train_real_folder):
-    image_path = os.path.join(train_real_folder, filename)
-    label = 0  # Real images have label 0
-    train_image_paths.append(image_path)
-    train_labels.append(label)
-
-# Load train_fake image paths and labels
-for filename in os.listdir(train_fake_folder):
-    image_path = os.path.join(train_fake_folder, filename)
-    label = 1  # Fake images have label 1
-    train_image_paths.append(image_path)
-    train_labels.append(label)
-
-# Load test image paths and labels
-test_image_paths = []
-test_labels = []
-
-# Load test_real image paths and labels
-for filename in os.listdir(test_real_folder):
-    image_path = os.path.join(test_real_folder, filename)
-    label = 0  # Assuming test real images are all real (label 0)
-    test_image_paths.append(image_path)
-    test_labels.append(label)
-
-# Load test_fake image paths and labels
-for filename in os.listdir(test_fake_folder):
-    image_path = os.path.join(test_fake_folder, filename)
-    label = 1  # Assuming test fake images are all fake (label 1)
-    test_image_paths.append(image_path)
-    test_labels.append(label)
-
-# Create DataFrames
-train_dataset = pd.DataFrame({'image_path': train_image_paths, 'label': train_labels})
-test_dataset = pd.DataFrame({'image_path': test_image_paths, 'label': test_labels})
-
-# Function to preprocess images
-def preprocess_image(image_path):
-    """Loads, resizes, and normalizes an image."""
-    image = cv2.imread(image_path)
-    resized_image = cv2.resize(image, (128, 128))  # Target size defined here
-    normalized_image = resized_image.astype(np.float32) / 255.0
-    return normalized_image
-
-# Preprocess all images and convert labels to numpy arrays
-X = np.array([preprocess_image(path) for path in train_image_paths])
-Y = np.array(train_labels)
-
-# Define discriminator network
-def build_discriminator(input_shape, dropout_rate=0.5):
-    model = Sequential()
-    model.add(Conv2D(32, (3, 3), activation='relu', input_shape=input_shape))
-    model.add(MaxPooling2D((2, 2)))
-    model.add(Conv2D(64, (3, 3), activation='relu'))
-    model.add(MaxPooling2D((2, 2)))
-    model.add(Conv2D(64, (3, 3), activation='relu'))
-    model.add(Flatten())
-    model.add(Dense(64, activation='relu'))
-    model.add(Dropout(dropout_rate))  # Adding dropout layer
-    model.add(Dense(1, activation='sigmoid'))
-    return model
-
-# Function to check if previous weights exist
-def load_previous_weights(model, fold_number):
-    weights_file = f'model_weights/model_fold_{fold_number}.weights.h5'
-    if os.path.exists(weights_file):
-        model.load_weights(weights_file)
-        print(f"Loaded weights from {weights_file}")
-    else:
-        print("No previous weights found.")
-
-# Function to save weights if current accuracy is higher
-def save_updated_weights(model, fold_number, val_accuracy, best_accuracy):
-    weights_file = f'model_weights/model_fold_{fold_number}.weights.h5'
-    if val_accuracy > best_accuracy:
-        model.save_weights(weights_file)
-        print(f"Saved updated weights to {weights_file} with val_accuracy: {val_accuracy:.4f}")
-        return val_accuracy
-    else:
-        print(f"Did not save weights for fold {fold_number} as val_accuracy {val_accuracy:.4f} is not better than {best_accuracy:.4f}")
-        return best_accuracy
-
-# Set parameters for cross-validation
-kf = KFold(n_splits=4, shuffle=True, random_state=42)
-batch_size = 32
-epochs = 15
-
-# Lists to store accuracy and loss for each fold
-accuracy_per_fold = []
-loss_per_fold = []
-# Store the best accuracies for each fold
-best_accuracies = [0] * kf.get_n_splits()
-
-
-# Perform K-Fold Cross-Validation
-for fold_number, (train_index, val_index) in enumerate(kf.split(X), 1):
-    X_train, X_val = X[train_index], X[val_index]
-    Y_train, Y_val = Y[train_index], Y[val_index]
-    
-    # Create and compile model
-    input_dim = X_train.shape[1:]  # Dimensionality of the input images
-    model = build_discriminator(input_dim)
-    model.compile(loss='binary_crossentropy', optimizer=Adam(0.0002, 0.5), metrics=['accuracy'])
-    
-     # Load previous weights if they exist
-    load_previous_weights(model, fold_number)
-    
-    # Define Early Stopping callback
-    early_stopping = EarlyStopping(monitor='val_accuracy', patience=5, restore_best_weights=True)
-    
-    # Define ModelCheckpoint callback to save the best weights
-    checkpoint = ModelCheckpoint(filepath=f'best_model_weights/model_fold_{fold_number}.best.weights.h5.keras', monitor='val_accuracy', save_best_only=True, mode='max')
-    
-    # Train the model with the callbacks
-    history = model.fit(X_train, Y_train, epochs=epochs, batch_size=batch_size, verbose=2, 
-                        validation_data=(X_val, Y_val), callbacks=[early_stopping, checkpoint])
-    
-    # Store the accuracy and loss for this folds
-    average_val_accuracy = np.mean(history.history['val_accuracy'])
-    accuracy_per_fold.append(average_val_accuracy)
-    average_val_loss = np.mean(history.history['val_loss'])
-    loss_per_fold.append(average_val_loss)
-  
-    # Save updated weights if accuracy is high
-    best_accuracies[fold_number - 1] = save_updated_weights(model, fold_number, average_val_accuracy, best_accuracies[fold_number - 1])
- 
-    
-    # Print fold accuracy
-    print(f'Fold {fold_number} average accuracy: {average_val_accuracy*100:.2f}%')
-
-# Print average accuracy across all folds
-print(f'Average accuracy across all folds: {np.mean(accuracy_per_fold)*100:.2f}%')
-
-# Load the model weights of the best model
-best_model_index = np.argmax(accuracy_per_fold)
-best_model_path = f'best_model_weights/model_fold_{best_model_index + 1}.best.weights.h5.keras'
-model.load_weights(best_model_path)
-
-# Evaluate the preprocessed test images using the best model
-test_loss, test_accuracy = model.evaluate(np.array([preprocess_image(path) for path in test_image_paths]), np.array(test_labels))
-print(f"\nTest Loss: {test_loss}, Test Accuracy: {test_accuracy}")
-
-# Predict labels for the test set using the best model
-predictions = model.predict(np.array([preprocess_image(path) for path in test_image_paths]))
-predicted_labels = (predictions > 0.5).astype(int).flatten()
-
-# Summarize the classification results
-true_real_correct = np.sum((np.array(test_labels) == 0) & (predicted_labels == 0))
-true_real_incorrect = np.sum((np.array(test_labels) == 0) & (predicted_labels == 1))
-true_fake_correct = np.sum((np.array(test_labels) == 1) & (predicted_labels == 1))
-true_fake_incorrect = np.sum((np.array(test_labels) == 1) & (predicted_labels == 0))
-
-print("\nClassification Summary:")
-print(f"Real images correctly classified: {true_real_correct}")
-print(f"Real images incorrectly classified: {true_real_incorrect}")
-print(f"Fake images correctly classified: {true_fake_correct}")
-print(f"Fake images incorrectly classified: {true_fake_incorrect}")
-
-
-# Print detailed classification report
-print("\nClassification Report:")
-print(classification_report(test_labels, predicted_labels, target_names=['Real', 'Fake']))
-
-print(model.summary())
-
-
-# Plot confusion matrix
-cm = confusion_matrix(test_labels, predicted_labels)
-disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Real', 'Fake'])
-disp.plot(cmap=plt.cm.Blues)
-plt.title("Confusion Matrix")
-plt.show()
-
-# Plot training & validation accuracy values
-plt.figure(figsize=(12, 4))
-plt.subplot(1, 2, 1)
-plt.plot(history.history['accuracy'])
-plt.plot(history.history['val_accuracy'])
-plt.title('Model accuracy')
-plt.ylabel('Accuracy')
-plt.xlabel('Epoch')
-plt.legend(['Train', 'Validation'], loc='upper left')
-plt.xticks(np.arange(0, len(history.history['accuracy']), step=1), np.arange(1, len(history.history['accuracy']) + 1, step=1))
-
-
-# Plot training & validation loss values
-plt.subplot(1, 2, 2)
-plt.plot(history.history['loss'])
-plt.plot(history.history['val_loss'])
-plt.title('Model loss')
-plt.ylabel('Loss')
-plt.xlabel('Epoch')
-plt.legend(['Train', 'Validation'], loc='upper left')
-plt.xticks(np.arange(0, len(history.history['loss']), step=1), np.arange(1, len(history.history['loss']) + 1, step=1))
-
-
-plt.tight_layout()
-plt.show()
-
-# Plot validation accuracy and loss per fold
-plt.figure(figsize=(12, 4))
-plt.subplot(1, 2, 1)
-plt.plot(range(1, kf.get_n_splits() + 1), accuracy_per_fold, marker='o')
-plt.title('Validation Accuracy per Fold')
-plt.xlabel('Fold')
-plt.ylabel('Accuracy')
-
-plt.subplot(1, 2, 2)
-plt.plot(range(1, kf.get_n_splits() + 1), loss_per_fold, marker='o')
-plt.title('Validation Loss per Fold')
-plt.xlabel('Fold')
-plt.ylabel('Loss')
-
-plt.tight_layout()
-plt
-
-
+# -*- coding: utf-8 -*-
+"""
+Created on Sat May 18 16:15:32 2024
+@author: litav
+"""
+
+
+import numpy as np
+import tensorflow as tf
+import random
+import os
+import pandas as pd
+import cv2
+import matplotlib.pyplot as plt
+from sklearn.model_selection import KFold
+from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.models import Sequential
+from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay
+from tensorflow.keras.layers import Dropout
+from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
+from sklearn.metrics import precision_score, recall_score, f1_score, classification_report
+
+
+# Suppress iCCP warning
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning, message=".*iCCP:.*")
+
+# Define data paths
+train_real_folder = 'datasets/training_set/real/'
+train_fake_folder = 'datasets/training_set/fake/'
+test_real_folder = 'datasets/test_set/real/'
+test_fake_folder = 'datasets/test_set/fake/'
+
+# Load train image paths and labels
+train_image_paths = []
+train_labels = []
+
+# Load train_real image paths and labels
+for filename in os.listdir(train_real_folder):
+    image_path = os.path.join(train_real_folder, filename)
+    label = 0  # Real images have label 0
+    train_image_paths.append(image_path)
+    train_labels.append(label)
+
+# Load train_fake image paths and labels
+for filename in os.listdir(train_fake_folder):
+    image_path = os.path.join(train_fake_folder, filename)
+    label = 1  # Fake images have label 1
+    train_image_paths.append(image_path)
+    train_labels.append(label)
+
+# Load test image paths and labels
+test_image_paths = []
+test_labels = []
+
+# Load test_real image paths and labels
+for filename in os.listdir(test_real_folder):
+    image_path = os.path.join(test_real_folder, filename)
+    label = 0  # Assuming test real images are all real (label 0)
+    test_image_paths.append(image_path)
+    test_labels.append(label)
+
+# Load test_fake image paths and labels
+for filename in os.listdir(test_fake_folder):
+    image_path = os.path.join(test_fake_folder, filename)
+    label = 1  # Assuming test fake images are all fake (label 1)
+    test_image_paths.append(image_path)
+    test_labels.append(label)
+
+# Create DataFrames
+train_dataset = pd.DataFrame({'image_path': train_image_paths, 'label': train_labels})
+test_dataset = pd.DataFrame({'image_path': test_image_paths, 'label': test_labels})
+
+# Function to preprocess images
+def preprocess_image(image_path):
+    """Loads, resizes, and normalizes an image."""
+    image = cv2.imread(image_path)
+    resized_image = cv2.resize(image, (128, 128))  # Target size defined here
+    normalized_image = resized_image.astype(np.float32) / 255.0
+    return normalized_image
+
+# Preprocess all images and convert labels to numpy arrays
+X = np.array([preprocess_image(path) for path in train_image_paths])
+Y = np.array(train_labels)
+
+# Define discriminator network
+def build_discriminator(input_shape, dropout_rate=0.5):
+    model = Sequential()
+    model.add(Conv2D(32, (3, 3), activation='relu', input_shape=input_shape))
+    model.add(MaxPooling2D((2, 2)))
+    model.add(Conv2D(64, (3, 3), activation='relu'))
+    model.add(MaxPooling2D((2, 2)))
+    model.add(Conv2D(64, (3, 3), activation='relu'))
+    model.add(Flatten())
+    model.add(Dense(64, activation='relu'))
+    model.add(Dropout(dropout_rate))  # Adding dropout layer
+    model.add(Dense(1, activation='sigmoid'))
+    return model
+
+# Function to check if previous weights exist
+def load_previous_weights(model, fold_number):
+    weights_file = f'model_weights/model_fold_{fold_number}.weights.h5'
+    if os.path.exists(weights_file):
+        model.load_weights(weights_file)
+        print(f"Loaded weights from {weights_file}")
+    else:
+        print("No previous weights found.")
+
+# Function to save weights if current accuracy is higher
+def save_updated_weights(model, fold_number, val_accuracy, best_accuracy):
+    weights_file = f'model_weights/model_fold_{fold_number}.weights.h5'
+    if val_accuracy > best_accuracy:
+        model.save_weights(weights_file)
+        print(f"Saved updated weights to {weights_file} with val_accuracy: {val_accuracy:.4f}")
+        return val_accuracy
+    else:
+        print(f"Did not save weights for fold {fold_number} as val_accuracy {val_accuracy:.4f} is not better than {best_accuracy:.4f}")
+        return best_accuracy
+
+# Set parameters for cross-validation
+kf = KFold(n_splits=4, shuffle=True, random_state=42)
+batch_size = 32
+epochs = 15
+
+# Lists to store accuracy and loss for each fold
+accuracy_per_fold = []
+loss_per_fold = []
+# Store the best accuracies for each fold
+best_accuracies = [0] * kf.get_n_splits()
+
+
+# Perform K-Fold Cross-Validation
+for fold_number, (train_index, val_index) in enumerate(kf.split(X), 1):
+    X_train, X_val = X[train_index], X[val_index]
+    Y_train, Y_val = Y[train_index], Y[val_index]
+    
+    # Create and compile model
+    input_dim = X_train.shape[1:]  # Dimensionality of the input images
+    model = build_discriminator(input_dim)
+    model.compile(loss='binary_crossentropy', optimizer=Adam(0.0002, 0.5), metrics=['accuracy'])
+    
+     # Load previous weights if they exist
+    load_previous_weights(model, fold_number)
+    
+    # Define Early Stopping callback
+    early_stopping = EarlyStopping(monitor='val_accuracy', patience=5, restore_best_weights=True)
+    
+    # Define ModelCheckpoint callback to save the best weights
+    checkpoint = ModelCheckpoint(filepath=f'best_model_weights/model_fold_{fold_number}.best.weights.h5.keras', monitor='val_accuracy', save_best_only=True, mode='max')
+    
+    # Train the model with the callbacks
+    history = model.fit(X_train, Y_train, epochs=epochs, batch_size=batch_size, verbose=2, 
+                        validation_data=(X_val, Y_val), callbacks=[early_stopping, checkpoint])
+    
+    # Store the accuracy and loss for this folds
+    average_val_accuracy = np.mean(history.history['val_accuracy'])
+    accuracy_per_fold.append(average_val_accuracy)
+    average_val_loss = np.mean(history.history['val_loss'])
+    loss_per_fold.append(average_val_loss)
+  
+    # Save updated weights if accuracy is high
+    best_accuracies[fold_number - 1] = save_updated_weights(model, fold_number, average_val_accuracy, best_accuracies[fold_number - 1])
+ 
+    
+    # Print fold accuracy
+    print(f'Fold {fold_number} average accuracy: {average_val_accuracy*100:.2f}%')
+
+# Print average accuracy across all folds
+print(f'Average accuracy across all folds: {np.mean(accuracy_per_fold)*100:.2f}%')
+
+# Load the model weights of the best model
+best_model_index = np.argmax(accuracy_per_fold)
+best_model_path = f'best_model_weights/model_fold_{best_model_index + 1}.best.weights.h5.keras'
+model.load_weights(best_model_path)
+
+# Evaluate the preprocessed test images using the best model
+test_loss, test_accuracy = model.evaluate(np.array([preprocess_image(path) for path in test_image_paths]), np.array(test_labels))
+print(f"\nTest Loss: {test_loss}, Test Accuracy: {test_accuracy}")
+
+# Predict labels for the test set using the best model
+predictions = model.predict(np.array([preprocess_image(path) for path in test_image_paths]))
+predicted_labels = (predictions > 0.5).astype(int).flatten()
+
+# Summarize the classification results
+true_real_correct = np.sum((np.array(test_labels) == 0) & (predicted_labels == 0))
+true_real_incorrect = np.sum((np.array(test_labels) == 0) & (predicted_labels == 1))
+true_fake_correct = np.sum((np.array(test_labels) == 1) & (predicted_labels == 1))
+true_fake_incorrect = np.sum((np.array(test_labels) == 1) & (predicted_labels == 0))
+
+print("\nClassification Summary:")
+print(f"Real images correctly classified: {true_real_correct}")
+print(f"Real images incorrectly classified: {true_real_incorrect}")
+print(f"Fake images correctly classified: {true_fake_correct}")
+print(f"Fake images incorrectly classified: {true_fake_incorrect}")
+
+
+# Print detailed classification report
+print("\nClassification Report:")
+print(classification_report(test_labels, predicted_labels, target_names=['Real', 'Fake']))
+
+print(model.summary())
+
+
+# Plot confusion matrix
+cm = confusion_matrix(test_labels, predicted_labels)
+disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Real', 'Fake'])
+disp.plot(cmap=plt.cm.Blues)
+plt.title("Confusion Matrix")
+plt.show()
+
+# Plot training & validation accuracy values
+plt.figure(figsize=(12, 4))
+plt.subplot(1, 2, 1)
+plt.plot(history.history['accuracy'])
+plt.plot(history.history['val_accuracy'])
+plt.title('Model accuracy')
+plt.ylabel('Accuracy')
+plt.xlabel('Epoch')
+plt.legend(['Train', 'Validation'], loc='upper left')
+plt.xticks(np.arange(0, len(history.history['accuracy']), step=1), np.arange(1, len(history.history['accuracy']) + 1, step=1))
+
+
+# Plot training & validation loss values
+plt.subplot(1, 2, 2)
+plt.plot(history.history['loss'])
+plt.plot(history.history['val_loss'])
+plt.title('Model loss')
+plt.ylabel('Loss')
+plt.xlabel('Epoch')
+plt.legend(['Train', 'Validation'], loc='upper left')
+plt.xticks(np.arange(0, len(history.history['loss']), step=1), np.arange(1, len(history.history['loss']) + 1, step=1))
+
+
+plt.tight_layout()
+plt.show()
+
+# Plot validation accuracy and loss per fold
+plt.figure(figsize=(12, 4))
+plt.subplot(1, 2, 1)
+plt.plot(range(1, kf.get_n_splits() + 1), accuracy_per_fold, marker='o')
+plt.title('Validation Accuracy per Fold')
+plt.xlabel('Fold')
+plt.ylabel('Accuracy')
+
+plt.subplot(1, 2, 2)
+plt.plot(range(1, kf.get_n_splits() + 1), loss_per_fold, marker='o')
+plt.title('Validation Loss per Fold')
+plt.xlabel('Fold')
+plt.ylabel('Loss')
+
+plt.tight_layout()
+plt
+
+