Create app.py

app.py

@@ -0,0 +1,297 @@
+''' !pip install seaborn
+!pip install keras
+!pip install tensorflow
+
+!python3.10 -m pip install --upgrade pip
+
+!pip install scikit-learn scipy matplotlib'''
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.image as mpimg
+import seaborn as sns
+%matplotlib inline
+
+np.random.seed(2)
+
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import confusion_matrix
+import itertools
+
+from tensorflow.keras.utils import to_categorical
+from keras.models import Sequential
+from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
+from keras.optimizers import RMSprop
+
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+
+from keras.callbacks import ReduceLROnPlateau, EarlyStopping
+
+sns.set(style='white', context='notebook', palette='deep')
+
+
+from PIL import Image
+import os
+from pylab import *
+import re
+from PIL import Image, ImageChops, ImageEnhance
+
+def get_imlist(path):
+    return [os.path.join(path,f) for f in os.listdir(path) if f.endswith('.jpg') or f.endswith('.png')]
+
+def convert_to_ela_image(path, quality):
+    filename = path
+    resaved_filename = filename.split('.')[0] + '.resaved.jpg'
+    ELA_filename = filename.split('.')[0] + '.ela.png'
+
+    im = Image.open(filename).convert('RGB')
+    im.save(resaved_filename, 'JPEG', quality=quality)
+    resaved_im = Image.open(resaved_filename)
+
+    ela_im = ImageChops.difference(im, 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)
+
+    return ela_im
+
+
+
+Image.open('Deep Fake Dataset/real_images/6401_0.jpg')
+
+convert_to_ela_image('Deep Fake Dataset/real_images/6401_0.jpg',90)
+
+Image.open('Deep Fake Dataset/fake_images/1601_0.jpg')
+
+convert_to_ela_image('Deep Fake Dataset/fake_images/1601_0.jpg',90)
+
+import os
+import csv
+from PIL import Image  # Use PIL for image processing
+
+def create_image_dataset_csv(fake_folder, real_folder, output_csv):
+    # Initialize an empty list to store image information
+    image_data = []
+
+    # Process fake images
+    fake_files = os.listdir(fake_folder)
+    for filename in fake_files:
+        if filename.endswith('.jpg') or filename.endswith('.png'):  # Adjust based on your image formats
+            file_path = os.path.join(fake_folder, filename)
+            label = 0  # Assign label 0 for fake
+            image_data.append((file_path, label))
+
+    # Process real images
+    real_files = os.listdir(real_folder)
+    for filename in real_files:
+        if filename.endswith('.jpg') or filename.endswith('.png'):  # Adjust based on your image formats
+            file_path = os.path.join(real_folder, filename)
+            label = 1  # Assign label 1 for real
+            image_data.append((file_path, label))
+
+    # Write image data to CSV file
+    with open(output_csv, 'w', newline='') as csvfile:
+        csv_writer = csv.writer(csvfile)
+        csv_writer.writerow(['file_path', 'label'])  # Header row
+        csv_writer.writerows(image_data)
+
+    print(f"CSV file '{output_csv}' has been created successfully with {len(image_data)} entries.")
+
+# Example usage:
+fake_images_folder = 'Deep Fake Dataset/fake_images'
+real_images_folder = 'Deep Fake Dataset/real_images'
+output_csv_file = 'image_dataset.csv'
+
+create_image_dataset_csv(fake_images_folder, real_images_folder, output_csv_file)
+
+import pandas as pd
+
+
+# dataset = pd.read_csv('datasets/dataset.csv')
+dataset = pd.read_csv('image_dataset.csv')
+
+dataset.head()
+
+X = []
+Y = []
+
+X
+
+for index, row in dataset.iterrows():
+    X.append(array(convert_to_ela_image(row[0], 90).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=5)
+
+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(learning_rate=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='max')
+
+epochs = 10
+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])
+
+ # Plot the loss and accuracy curves for training and validation
+fig, ax = plt.subplots(2,1)
+ax[0].plot(history.history['loss'], color='b', label="Training loss")
+ax[0].plot(history.history['val_loss'], color='r', label="validation loss")
+legend = ax[0].legend(loc='best', shadow=True)
+
+ax[1].plot(history.history['accuracy'], color='b', label="Training accuracy")
+ax[1].plot(history.history['val_accuracy'], color='r',label="Validation accuracy")
+legend = ax[1].legend(loc='best', shadow=True)
+
+
+from sklearn.metrics import confusion_matrix
+
+def plot_confusion_matrix(cm, classes,
+                          normalize=False,
+                          title='Confusion matrix',
+                          cmap=plt.cm.Blues):
+    """
+    This function prints and plots the confusion matrix.
+    Normalization can be applied by setting `normalize=True`.
+    """
+    plt.imshow(cm, interpolation='nearest', cmap=cmap)
+    plt.title(title)
+    plt.colorbar()
+    tick_marks = np.arange(len(classes))
+    plt.xticks(tick_marks, classes, rotation=45)
+    plt.yticks(tick_marks, classes)
+
+    if normalize:
+        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
+
+    thresh = cm.max() / 2.
+    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
+        plt.text(j, i, cm[i, j],
+                 horizontalalignment="center",
+                 color="white" if cm[i, j] > thresh else "black")
+
+    plt.tight_layout()
+    plt.ylabel('True label')
+    plt.xlabel('Predicted label')
+
+
+# Predict the values from the validation dataset
+Y_pred = model.predict(X_val)
+# Convert predictions classes to one hot vectors
+Y_pred_classes = np.argmax(Y_pred,axis = 1)
+# Convert validation observations to one hot vectors
+Y_true = np.argmax(Y_val,axis = 1)
+
+# compute the confusion matrix
+confusion_mtx = confusion_matrix(Y_true, Y_pred_classes)
+plt.xlabel('Predicted')
+plt.ylabel('True')
+plt.title('Confusion Matrix')
+sns.heatmap(confusion_mtx/np.sum(confusion_mtx), annot=True,
+            fmt='.2%', cmap='Blues')
+
+from sklearn.metrics import classification_report
+
+print(classification_report(Y_true, Y_pred_classes))
+
+#saving the trained cnn model
+model.save("fake-image-detection.h5")
+
+
+#!pip install gradio
+
+import gradio as gr
+import numpy as np
+from PIL import Image, ImageChops, ImageEnhance
+from keras.models import load_model
+import tensorflow as tf
+
+# Load the trained model
+model = load_model("fake-image-detection.h5")
+
+# Function to convert an image to its ELA form
+def convert_to_ela_image(image, quality=90):
+    resaved_image = image.convert('RGB')
+    resaved_image.save("resaved_image.jpg", 'JPEG', quality=quality)
+    resaved_image = Image.open("resaved_image.jpg")
+
+    ela_image = ImageChops.difference(image, resaved_image)
+
+    extrema = ela_image.getextrema()
+    max_diff = max([ex[1] for ex in extrema])
+    if max_diff == 0:
+        max_diff = 1
+    scale = 255.0 / max_diff
+
+    ela_image = ImageEnhance.Brightness(ela_image).enhance(scale)
+    return ela_image
+
+# Prediction function
+def predict(image):
+    # Convert the input image to an ELA image
+    ela_image = convert_to_ela_image(image)
+    ela_image = ela_image.resize((128, 128))  # Resize to match the input size of the model
+    ela_array = np.array(ela_image).astype('float32') / 255.0
+    ela_array = ela_array.reshape(1, 128, 128, 3)  # Reshape for model input
+
+    # Make a prediction
+    prediction = model.predict(ela_array)
+    class_idx = np.argmax(prediction, axis=1)[0]
+
+    # Map the prediction to labels
+    labels = {0: "Fake", 1: "Real"}
+    return labels[class_idx]
+
+# Gradio interface
+interface = gr.Interface(
+    fn=predict,  # Prediction function
+    inputs=gr.Image(type="pil"),  # Image input (PIL format)
+    outputs="label",  # Output a label
+    title="Deep Fake Detector",
+    description="Upload an image to detect if it's a real or fake image using ELA and a trained CNN model."
+)
+
+# Launch the interface
+interface.launch()