first upload

ELA_CNN_ART_V2.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9b681289e0f151aeb2f52c56dda38c8e1ea89a22ff11e1066c63ad2b3e68fd2
+size 236205528

cnn_ela_test.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri May 24 14:31:20 2024
+
+@author: beni
+"""
+
+###test on art 30 epoches
+###Test Loss: 0.7387489676475525
+#Test Accuracy: 0.8525179624557495  ELA_CNN_ART.h5
+####
+
+
+
+#####test on objects 
+###ELA_CNN_OBJ.h5
+#Test Loss: 1.260271430015564
+#Test Accuracy: 0.5509259104728699
+
+
+from keras.models import Sequential
+from keras.layers import Conv2D, MaxPool2D, Dropout, Flatten, Dense
+from project_cnn_ela import convert_to_ela_image, shuffle_and_split_data, labeling
+import pandas as pd
+import numpy as np
+from PIL import Image
+import os
+from pylab import *
+import re
+from PIL import Image, ImageChops, ImageEnhance
+import tensorflow as tf
+import itertools
+from tensorflow.keras.utils import to_categorical 
+from tensorflow.keras.optimizers.legacy import RMSprop
+from sklearn.metrics import confusion_matrix
+import seaborn as sns
+import matplotlib.pyplot as plt
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix
+from copy import deepcopy
+
+model = Sequential()
+
+model.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'valid', 
+                     activation ='relu', input_shape = (128,128,3)))
+print("Input: ", model.input_shape)
+print("Output: ", model.output_shape)
+
+model.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'valid', 
+                     activation ='relu'))
+print("Input: ", model.input_shape)
+print("Output: ", model.output_shape)
+
+model.add(MaxPool2D(pool_size=(2,2)))
+
+model.add(Dropout(0.25))
+print("Input: ", model.input_shape)
+print("Output: ", model.output_shape)
+
+model.add(Flatten())
+model.add(Dense(256, activation = "relu"))
+model.add(Dropout(0.5))
+model.add(Dense(2, activation = "softmax"))
+
+model.summary()
+
+
+# Load saved weights
+model.load_weights("ELA_CNN_ART_V2.h5")
+
+optimizer = RMSprop(lr=0.0005, rho=0.9, epsilon=1e-08, decay=0.0)
+model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"])
+
+
+
+
+test_real_folder = 'datasets/test_set/real/'
+test_fake_folder = 'datasets/test_set/fake/'
+
+
+
+test_real_ela_folder = 'datasets/test_set/ela_real/'
+test_fake_ela_folder = 'datasets/test_set/ela_fake/'
+
+
+
+test_set = labeling(test_real_folder, test_fake_folder)
+X_test = []
+Y_test = []
+
+
+
+# Preprocess test set
+for index, row in test_set.iterrows():
+    X_test.append(array(convert_to_ela_image(row[0], 90, test_real_ela_folder).resize((128, 128))).flatten() / 255.0)
+    Y_test.append(row[1])
+
+# Convert to numpy arrays
+X_test = np.array(X_test)
+Y_test = to_categorical(Y_test, 2)
+
+# Reshape images
+X_test = X_test.reshape(-1, 128, 128, 3)
+
+# Evaluate the model on test set
+test_loss, test_accuracy = model.evaluate(X_test, Y_test)
+print()
+print("~~~~~art Dataset~~~~")
+print()
+print("Test Loss:", test_loss)
+print("Test Accuracy:", test_accuracy)
+
+#######################################################
+
+def calculate_acc(y_true, y_pred):
+    
+
+    # Calculate precision
+    precision = precision_score(y_true, y_pred)
+
+    # Calculate recall
+    recall = recall_score(y_true, y_pred)
+
+    # Calculate F1 score
+    f1 = f1_score(y_true, y_pred)
+    
+    # Calculate confusion matrix
+    conf_matrix = confusion_matrix(y_true, y_pred)
+
+
+    print("Precision:", precision)
+    print("Recall:", recall)
+    print("F1 Score:", f1)
+    print("Confusion Matrix:")
+
+    # Plot confusion matrix
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False)
+    plt.xlabel('Predicted Label')
+    plt.ylabel('True Label')
+    plt.title('Confusion Matrix')
+    plt.show()
+    
+
+
+# Get predicted probabilities
+Y_pred_prob = model.predict(X_test)
+
+# Convert predicted probabilities to class labels
+Y_pred = np.argmax(Y_pred_prob, axis=1)
+
+Y_true = np.argmax(Y_test, axis=1)
+
+# Calculate accuracies
+calculate_acc(Y_true, Y_pred)
+
+model.summary()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

project_cnn_ela.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Apr 29 17:46:18 2024
+
+@author: beni
+"""
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.image as mpimg
+from PIL import Image
+import os
+from pylab import *
+import re
+from PIL import Image, ImageChops, ImageEnhance
+import tensorflow as tf
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import confusion_matrix
+import itertools
+from tensorflow.keras.utils import to_categorical # convert to one-hot-encoding
+from keras.models import Sequential
+from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
+from tensorflow.keras.optimizers.legacy import RMSprop
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import ReduceLROnPlateau, EarlyStopping
+from scipy.ndimage import gaussian_filter
+
+
+
+
+
+def convert_to_ela_image(path, quality, output_dir, resize=(256, 256)):
+    filename = path
+    resaved_filename = os.path.join(output_dir, os.path.splitext(os.path.basename(filename))[0] + '.resaved.jpg')
+    ELA_filename = os.path.join(output_dir, os.path.splitext(os.path.basename(filename))[0] + '.ela.png')
+    
+    # Open and resize the image
+    im = Image.open(filename).convert('RGB')
+    im_resized = im.resize(resize)
+    
+    # Save the resized image
+    im_resized.save(resaved_filename, 'JPEG', quality=quality)
+    resaved_im = Image.open(resaved_filename)
+    
+    ela_im = ImageChops.difference(im_resized, resaved_im)
+    
+    extrema = ela_im.getextrema()
+    max_diff = max([ex[1] for ex in extrema])
+    if max_diff == 0:
+        max_diff = 1
+    scale = 255.0 / max_diff
+    
+    ela_im = ImageEnhance.Brightness(ela_im).enhance(scale)
+    
+    ela_im.save(ELA_filename)
+    
+    return ela_im
+
+def shuffle_and_split_data(dataframe, test_size=0.2, random_state=59):
+    # Shuffle the DataFrame
+    shuffled_df = dataframe.sample(frac=1, random_state=random_state).reset_index(drop=True)
+    
+    # Split the DataFrame into train and validation sets
+    train_df, val_df = train_test_split(shuffled_df, test_size=test_size, random_state=random_state)
+    
+    return train_df, val_df
+
+def labeling(path_real, path_fake):
+    image_paths = []
+    labels = []
+
+    for filename in os.listdir(path_real):
+        image_paths.append(os.path.join(path_real, filename))
+        labels.append(0)
+
+    for filename in os.listdir(path_fake):
+        image_paths.append(os.path.join(path_fake, filename))
+        labels.append(1)
+
+    dataset = pd.DataFrame({'image_path': image_paths, 'label': labels})
+
+    return dataset
+
+
+if __name__ == "__main__":
+    
+   
+
+     
+    np.random.seed(22)
+    tf.random.set_seed(9)
+
+    traning_fake_folder = 'datasets/training_set/fake/'
+    traning_real_folder = 'datasets/training_set/real/'
+
+
+
+    test_real_folder = 'datasets/test_set/real/'
+    test_fake_folder = 'datasets/test_set/fake/'
+
+
+    traning_fake_ela_folder = 'datasets/training_set/ela_fake/'
+    traning_real_ela_folder = 'datasets/training_set/ela_real/'
+
+    test_real_ela_folder = 'datasets/test_set/ela_real/'
+    test_fake_ela_folder = 'datasets/test_set/ela_fake/'
+
+
+
+    traning_set = labeling(traning_real_folder, traning_fake_folder)
+        
+
+    X = []
+    Y = []
+        
+    for index, row in traning_set.iterrows():
+       X.append(array(convert_to_ela_image(row[0], 90,traning_real_ela_folder).resize((128, 128))).flatten() / 255.0)
+       Y.append(row[1])
+
+
+    X = np.array(X)
+    Y = to_categorical(Y, 2)
+
+    X = X.reshape(-1, 128, 128, 3)
+
+    X_train, X_val, Y_train, Y_val = train_test_split(X, Y, test_size = 0.2, random_state=1,shuffle=True)
+
+    model = Sequential()
+
+    model.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'valid', 
+                     activation ='relu', input_shape = (128,128,3)))
+    print("Input: ", model.input_shape)
+    print("Output: ", model.output_shape)
+
+    model.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'valid', 
+                     activation ='relu'))
+    print("Input: ", model.input_shape)
+    print("Output: ", model.output_shape)
+
+    model.add(MaxPool2D(pool_size=(2,2)))
+
+    model.add(Dropout(0.25))
+    print("Input: ", model.input_shape)
+    print("Output: ", model.output_shape)
+
+    model.add(Flatten())
+    model.add(Dense(256, activation = "relu"))
+    model.add(Dropout(0.5))
+    model.add(Dense(2, activation = "softmax"))
+
+    model.summary()
+
+    optimizer = RMSprop(lr=0.0005, rho=0.9, epsilon=1e-08, decay=0.0)
+    model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"])
+
+    early_stopping = EarlyStopping(monitor='val_acc',
+                                  min_delta=0,
+                                  patience=2,
+        verbose=0, mode='auto')
+    
+    
+    epochs = 22
+    batch_size = 100
+    
+    
+    history = model.fit(X_train, Y_train, batch_size = batch_size, epochs = epochs, 
+              validation_data = (X_val, Y_val), verbose = 2, callbacks=[early_stopping])
+    
+    plt.plot(history.history['accuracy'])
+    plt.plot(history.history['val_accuracy'])
+    plt.title('Model accuracy')
+    plt.xlabel('Epoch')
+    plt.ylabel('Accuracy')
+    plt.legend(['Train', 'Validation'], loc='upper left')
+    plt.show()
+
+    # Plot training & validation loss values
+    plt.plot(history.history['loss'])
+    plt.plot(history.history['val_loss'])
+    plt.title('Model loss')
+    plt.xlabel('Epoch')
+    plt.ylabel('Loss')
+    plt.legend(['Train', 'Validation'], loc='upper left')
+    plt.show()
+
+# every training can give different results , we got the best training score so no need to run again
+#    model.save('ELA_CNN_ART_V2.h5')
+    
+    
+
+
+
+
+
+
+
+
+