files added

.gitignore

@@ -0,0 +1,2 @@
+CNN_model_weight
+EfficientNet_Models

Models/Final_EfficientNet_Code.ipynb

@@ -0,0 +1 @@
+{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":9715840,"sourceType":"datasetVersion","datasetId":5943727},{"sourceId":9739406,"sourceType":"datasetVersion","datasetId":5915042}],"dockerImageVersionId":30786,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import numpy as np\nimport os\nimport hashlib\nimport tensorflow as tf\nfrom PIL import Image\nfrom tensorflow.keras import layers, models\nfrom tensorflow.keras.preprocessing.image import load_img, img_to_array  # Correct import\nfrom tensorflow.keras.preprocessing import image\nimport numpy as np\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.applications import EfficientNetB0\nfrom tensorflow.keras.layers import Dropout, Dense, GlobalAveragePooling2D\nfrom tensorflow.keras.models import Model\nfrom sklearn.metrics import confusion_matrix, classification_report\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom sklearn.metrics import f1_score, precision_score, recall_score, accuracy_score\nfrom os import listdir","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Check for TPU\ntry:\n    resolver = tf.distribute.cluster_resolver.TPUClusterResolver()\n    tf.config.experimental_connect_to_cluster(resolver)\n    tf.tpu.experimental.initialize_tpu_system(resolver)\n    strategy = tf.distribute.TPUStrategy(resolver)\nexcept ValueError:\n    strategy = tf.distribute.get_strategy()  # Default to CPU/GPU strategy if TPU is not found\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\ndef augment_image(image, label):\n    image = tf.image.random_flip_left_right(image)  # Randomly flip images\n    image = tf.image.random_brightness(image, max_delta=0.1)  # Random brightness\n    return image, label\n\ntrain_data = tf.keras.utils.image_dataset_from_directory(\n    '/kaggle/input/ai-vs-real-dataset/_DATASET/dataset/train',\n    image_size=(224, 224),\n    batch_size=128,  # Adjust based on your TPU memory\n    shuffle=True\n)\n    \ntrain_data = train_data.map(augment_image, num_parallel_calls=tf.data.AUTOTUNE)\n    # Prefetch to improve performance\ntrain_data = train_data.prefetch(tf.data.AUTOTUNE)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\nwith strategy.scope():\n    base_model = tf.keras.applications.EfficientNetB0(weights='/kaggle/input/efficientnetb0-weights/efficientnetb0_notop.h5', include_top=False, input_shape=(224, 224, 3))\n    \n    # Add custom classification layers\n    x = base_model.output\n    x = tf.keras.layers.GlobalAveragePooling2D()(x)\n    x = tf.keras.layers.Dense(128, activation='relu')(x)\n    x = tf.keras.layers.Dropout(0.5)(x)\n    x = tf.keras.layers.Dense(1, activation='sigmoid')(x)\n\n    # Create the final model\n    model = tf.keras.Model(inputs=base_model.input, outputs=x)\n\n    # Compile the model\n    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n\n# Summary of the model\nmodel.summary()\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"with strategy.scope():\n    model.fit(train_data, epochs=20)\n    model.save('/kaggle/working/EfficientNet_pre_model.h5')","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# # Test images here\n\n# Load the test dataset\ntest_data = tf.keras.utils.image_dataset_from_directory(\n    '/kaggle/input/ai-vs-real-dataset/_DATASET/dataset/test',  # Your test directory\n    image_size=(224, 224),\n    batch_size=64,\n    shuffle=True  # Important to keep the order for predictions\n)\n\n\n# Extract true labels from the dataset\ny_true = np.concatenate([y.numpy() for x, y in test_data], axis=0)\nclass_names = ['FAKE', 'REAL']\n\n# Make predictions\nwith strategy.scope():\n    predictions = model.predict(test_data)\n\n# Convert predictions to binary labels\ny_pred = (predictions > 0.5).astype(\"int32\").flatten()  # Flatten to match shape of y_true\n\n# Create confusion matrix\ncm = confusion_matrix(y_true, y_pred)\n\nprint(\"Confusion Matrix:\")\nprint(cm)\n\nprint(\"Classification Report:\")\nprint(classification_report(y_true, y_pred, target_names=class_names))\n\n# Calculate metrics\naccuracy = accuracy_score(y_true, y_pred)\nprecision = precision_score(y_true, y_pred)\nrecall = recall_score(y_true, y_pred)\nf1 = f1_score(y_true, y_pred)\n\nprint(f\"Accuracy: {accuracy}\")\nprint(f\"Precision: {precision}\")\nprint(f\"Recall: {recall}\")\nprint(f\"F1 Score: {f1}\")\n\n# Plot confusion matrix for better visualization\nplt.figure(figsize=(6, 6))\nsns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=class_names, yticklabels=class_names)\nplt.title('Confusion Matrix')\nplt.ylabel('True Label')\nplt.xlabel('Predicted Label')\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Unfreeze top layers for fine-tuning\nwith strategy.scope():\n    base_model.trainable = True\n\n# Fine-tune from this layer onwards (adjust as needed)\n    for layer in base_model.layers[:150]:\n        layer.trainable = False\n\n# Re-compile the model with a lower learning rate\n    model.compile(optimizer=tf.keras.optimizers.Adam(1e-5), \n                  loss='binary_crossentropy', \n                  metrics=['accuracy'])\n\n# Train again\n\n    history_fine = model.fit(\n        train_data,\n        epochs=10  # Fine-tuning for a few additional epochs\n    )\n    model.save('/kaggle/working/EfficientNet_fine_tune_model.h5')\n\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\ntest_data = tf.keras.utils.image_dataset_from_directory(\n    '/kaggle/input/ai-vs-real-dataset/_DATASET/dataset/test', \n    image_size=(224, 224),\n    batch_size=64,\n    shuffle=True  \n)\n\n# Extract true labels from the dataset\ny_true = np.concatenate([y.numpy() for x, y in test_data], axis=0)\nclass_names = ['FAKE', 'REAL']\n\n# Make predictions\nwith strategy.scope():\n    predictions = model.predict(test_data)\n\n# Convert predictions to binary labels\ny_pred = (predictions > 0.5).astype(\"int32\").flatten()  # Flatten to match shape of y_true\n\n# Create confusion matrix\ncm = confusion_matrix(y_true, y_pred)\n\nprint(\"Confusion Matrix:\")\nprint(cm)\n\nprint(\"Classification Report:\")\nprint(classification_report(y_true, y_pred, target_names=class_names))\n\n# Calculate metrics\naccuracy = accuracy_score(y_true, y_pred)\nprecision = precision_score(y_true, y_pred)\nrecall = recall_score(y_true, y_pred)\nf1 = f1_score(y_true, y_pred)\n\nprint(f\"Accuracy: {accuracy}\")\nprint(f\"Precision: {precision}\")\nprint(f\"Recall: {recall}\")\nprint(f\"F1 Score: {f1}\")\n\n# Plot confusion matrix for better visualization\nplt.figure(figsize=(6, 6))\nsns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=class_names, yticklabels=class_names)\nplt.title('Confusion Matrix')\nplt.ylabel('True Label')\nplt.xlabel('Predicted Label')\nplt.show()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"model = tf.keras.models.load_model('/kaggle/working/EfficientNet_fine_tune_model.h5')\naccuracy = model.evaluate(test_data)\nprint(f\"Test Accuracy: {accuracy[1]}\")\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"#for deployment\ndef predictPicture(imagePath):\n    # model=tf.keras.models.load_model('//kaggle/input/efficientnetmodel-5/EfficientNet_model_5/saved_model.pb')\n    if imagePath.endswith((\".png\", \".jpg\", \".jpeg\")):\n        # Load and preprocess the image\n        img = load_img(imagePath, target_size=(224, 224))  # Resize image to model input size\n        img_arr = img_to_array(img)  # Convert to array\n        img_arr = np.expand_dims(img_arr, axis=0) # Add batch dimension\n    \n        with strategy.scope():\n            prediction = model.predict(img_arr)\n        \n        # Output the predicted probability\n        print(prediction[0])\n        \n        # Output the label based on probability\n        if prediction[0] > 0.5:\n            print(\"Prediction: Real\")\n        else:\n            print(\"Prediction: Fake\")\n    else:\n        print(\"Please provide a valid image file (PNG or JPG format).\")\n# get the path or directory\nfake_test = \"/kaggle/input/ai-vs-real-dataset/_DATASET/dataset/test/FAKE\"\ni=0\nfor images in os.listdir(fake_test):\n    file_path=fake_test+\"/\"+images\n    if i%200==0:\n        predictPicture(file_path)\n    i+=1\ni=0\nprint(\"CHANGE\")\nreal_test = \"/kaggle/input/ai-vs-real-dataset/_DATASET/dataset/test/REAL\"\nfor images in os.listdir(real_test):\n    file_path=real_test+\"/\"+images\n    if i%200==0:\n        predictPicture(file_path)    \n    i+=1","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}

app.py

@@ -0,0 +1,175 @@
+# imports
+import streamlit as st
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Conv2D, BatchNormalization, MaxPooling2D, Flatten, Dense, Dropout
+from tensorflow.keras.preprocessing.image import load_img, img_to_array
+import numpy as np
+
+
+
+
+
+# load css
+def load_local_css(file_name):
+    with open(file_name) as f:
+        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+load_local_css("./styles/style.css")
+
+
+# bootstrap
+st.markdown(
+    """<link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">""",
+    unsafe_allow_html=True
+)
+
+
+eff_net_model = tf.keras.models.load_model('EfficientNet_Models/efficientnetb3_binary_classifier_8.h5')
+eff_net_art_model = tf.keras.models.load_model('EfficientNet_Models/EfficientNet_fine_tune_art_model.h5')
+cnn_model = 'CNN_model_weight/model_weights.weights.h5'
+
+# CNN model
+def run_cnn(img_arr):
+    my_model = Sequential()
+    my_model.add(Conv2D(
+            filters=16, 
+            kernel_size=(3, 3), 
+            strides=(1, 1),
+            activation='relu',
+            input_shape=(256, 256, 3) 
+    ))
+    my_model.add(BatchNormalization())
+    my_model.add(MaxPooling2D())
+    
+    my_model.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu')) 
+    my_model.add(BatchNormalization())
+    my_model.add(MaxPooling2D()) 
+
+    my_model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu')) 
+    my_model.add(BatchNormalization())
+    my_model.add(MaxPooling2D())
+    
+    my_model.add(Flatten())
+    my_model.add(Dense(512, activation='relu')) 
+    my_model.add(Dropout(0.09)) 
+    my_model.add(Dense(1, activation='sigmoid'))
+    my_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+
+
+    # Load the pre-trained weights
+    my_model.load_weights(cnn_model)
+
+    prediction = my_model.predict(img_arr)
+    return prediction
+
+def run_effNet(img_arr):
+    try:
+        resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
+        tf.config.experimental_connect_to_cluster(resolver)
+        tf.tpu.experimental.initialize_tpu_system(resolver)
+        strategy = tf.distribute.TPUStrategy(resolver)
+    except ValueError:
+        strategy = tf.distribute.get_strategy()  
+    with strategy.scope():
+            prediction = eff_net_model.predict(img_arr)
+    return prediction
+ 
+   
+def run_effNet_Art(img_arr):
+    try:
+        resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
+        tf.config.experimental_connect_to_cluster(resolver)
+        tf.tpu.experimental.initialize_tpu_system(resolver)
+        strategy = tf.distribute.TPUStrategy(resolver)
+    except ValueError:
+        strategy = tf.distribute.get_strategy()  
+    with strategy.scope():
+            prediction = eff_net_art_model.predict(img_arr)
+    return prediction
+
+def pre_process_img_effNet(image):
+    img = load_img(image, target_size=(300, 300))  # Resize image to model input size
+    img_arr = img_to_array(img)  # Convert to array
+    img_arr = np.expand_dims(img_arr, axis=0) # Add batch dimension
+    result = run_effNet(img_arr)
+    return result
+
+def pre_process_img_effNetArt(image):
+    img = load_img(image, target_size=(224, 224))  # Resize image to model input size
+    img_arr = img_to_array(img)  # Convert to array
+    img_arr = np.expand_dims(img_arr, axis=0) # Add batch dimension
+    result = run_effNet_Art(img_arr)
+    return result
+
+# preprocess image for cnn
+def pre_process_img(image):
+        # Load and preprocess the image
+        input_picture = load_img(image, target_size=(256, 256))
+        img_arr = img_to_array(input_picture) / 255.0  # Normalize the image
+        img_arr = img_arr.reshape((1, 256, 256, 3))  # Add batch dimension
+        result = run_cnn(img_arr)
+        return result
+# title
+st.markdown(
+    """<p class = "title"> AI vs REAL Image Detection </p>""",
+    unsafe_allow_html= True
+)
+
+# upload image
+st.markdown(
+     """<p class = "upload_line"> Please upload the image </p>""",
+    unsafe_allow_html= True
+)
+user_image = st.file_uploader("png, jpg, or jpeg image", ['png', 'jpg', 'jpeg'], label_visibility='hidden')
+model_name = st.selectbox('Choose a model', ['CNN', 'Efficiencynet', 'Efficiencynet Art'], index=None, placeholder='choose an option')
+result_placeholder = st.empty()
+
+# design animation elements
+with open("styles/detectiveMag.svg", "r") as file:
+    svg_content_detective_Mag = file.read()
+
+# First magnifying glass starts at bottom-right
+st.markdown(
+    f"<div class='detectiveMag1' style='bottom: 0%; right: 0%;'>{svg_content_detective_Mag}</div>",
+    unsafe_allow_html=True
+)
+
+# Second magnifying glass starts slightly higher up the diagonal
+st.markdown(
+    f"<div class='detectiveMag2' style='bottom: 10%; right: 10%;'>{svg_content_detective_Mag}</div>",
+    unsafe_allow_html=True
+)
+
+# Third magnifying glass starts further up the diagonal
+st.markdown(
+    f"<div class='detectiveMag3' style='bottom: 20%; right: 20%;'>{svg_content_detective_Mag}</div>",
+    unsafe_allow_html=True
+)
+
+if user_image is not None and model_name is not None:
+    predictions = []
+    if model_name == 'CNN':
+        print('CNN is running')
+        predictions = pre_process_img(user_image)
+    elif model_name == 'Efficiencynet':
+        print('Effnet is running')
+        predictions = pre_process_img_effNet(user_image)
+    elif model_name == 'Efficiencynet Art':
+        print('Effnet Art is running')
+        predictions = pre_process_img_effNetArt(user_image)
+
+    if predictions[0] < 0.5:
+         result_word = "FAKE"
+    else:
+         result_word = "REAL"
+
+    if user_image is not None:
+        if len(predictions) > 0: 
+            result_placeholder.markdown(f"<div class='result'> It is a <span class = resultword> {result_word} </span> image </div>", unsafe_allow_html=True)
+
+    print(model_name)
+    print(predictions[0])
+
+
+

data_cleaning/data_cleaning.ipynb

@@ -0,0 +1,288 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "68e2dccb-3f52-4ea3-bf1d-8732641daefa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import hashlib\n",
+    "from PIL import Image\n",
+    "import cv2\n",
+    "import pandas\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "import shutil\n",
+    "import random\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5f7e8cb-1c1e-423a-b7c5-68a41c3eeec3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#REMOVE DUPLICATE IMAGES\n",
+    "def calculate_hash(image_path):\n",
+    "\n",
+    "    #Calculate the hash of an image.\n",
+    "    with Image.open(image_path) as img:\n",
+    "        img = img.convert(\"RGB\")  # Ensure the image is in RGB format\n",
+    "        img = img.resize((8, 8))  # Resize to reduce size and create hash\n",
+    "        hash_value = hashlib.md5(img.tobytes()).hexdigest()  # Create hash\n",
+    "    return hash_value\n",
+    "\n",
+    "def find_and_remove_duplicates(folder_path):\n",
+    "\n",
+    "    #Find and remove duplicate images in a given folder.\n",
+    "\n",
+    "    #If cannot find path/ folder, Print that it does not exist\n",
+    "    if not os.path.exists(folder_path):\n",
+    "\n",
+    "        print(f\"The folder '{folder_path}' may not exist.\")\n",
+    "        return\n",
+    "\n",
+    "    print(f\"Scanning folder: {folder_path}\")\n",
+    "\n",
+    "    hashes = {}\n",
+    "    duplicates = []\n",
+    "\n",
+    "    for filename in os.listdir(folder_path):# for each file in the folder\n",
+    "\n",
+    "        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp')):# if file is an image\n",
+    "\n",
+    "            file_path = os.path.join(folder_path, filename) #generate a path to the specific image\n",
+    "\n",
+    "            img_hash = calculate_hash(file_path)\n",
+    "\n",
+    "            if img_hash in hashes:\n",
+    "                duplicates.append(file_path)  # Found a duplicate\n",
+    "                print(f\"Duplicate found: {file_path} (duplicate of {hashes[img_hash]})\")\n",
+    "            else:\n",
+    "                hashes[img_hash] = file_path\n",
+    "\n",
+    "    # Remove duplicates\n",
+    "    for duplicate in duplicates:\n",
+    "\n",
+    "        os.remove(duplicate)\n",
+    "        print(f\"Removed duplicate: {duplicate}\")\n",
+    "\n",
+    "    if not duplicates:\n",
+    "        print(\"No duplicates found.\")\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    folder = input(\"Enter the path to the folder containing photos: \")\n",
+    "    find_and_remove_duplicates(folder)\n",
+    "    \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "73265e47-6308-4802-be5c-8eb953148d63",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#convert all images to jpg format\n",
+    "def convert_images(folder):\n",
+    "    # Loop through the image folder directory\n",
+    "    for filename in os.listdir(folder):\n",
+    "        # Check if the file is not in JPG format\n",
+    "        if not filename.lower().endswith('.jpg') and filename.lower().endswith(('.png', '.gif', '.bmp', '.jpeg')):\n",
+    "            input_path = os.path.join(folder, filename)\n",
+    "            output_path = os.path.join(folder, f\"{os.path.splitext(filename)[0]}.jpg\") #jpg converted path\n",
+    "\n",
+    "            try:\n",
+    "                # Open the image file\n",
+    "                with Image.open(input_path) as img:\n",
+    "                    # Convert the image to RGB\n",
+    "                    rgb_img = img.convert('RGB')\n",
+    "                    # Save image as JPG\n",
+    "                    rgb_img.save(output_path, 'JPEG')\n",
+    "                    print(f\"Converted {filename} to {output_path}\")\n",
+    "                    # Remove the old image file\n",
+    "                    os.remove(input_path)\n",
+    "                    print(f\"Removed old file: {input_path}\")\n",
+    "            except Exception as e:\n",
+    "                print(f\"Error processing {filename}: {e}\")\n",
+    "\n",
+    "    print(\"Image conversion to .jpg completed.\")  # Print once after processing all images\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    input_folder = input(\"Enter the path to the input folder containing images: \")\n",
+    "    convert_images(input_folder)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "9d4cea00-fc10-4ca4-a139-0dcd259b2767",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# check for corruption\n",
+    "def is_corrupt(image_path):\n",
+    "    try:\n",
+    "        img = Image.open(image_path)\n",
+    "        img.verify()  # Verify the image file\n",
+    "        return False  # Image is not corrupted\n",
+    "    except (IOError, SyntaxError) as e:\n",
+    "        return True  # Image is corrupted\n",
+    "\n",
+    "def read_files_in_folder(folder_path):\n",
+    "    count=0\n",
+    "    for filename in os.listdir(folder_path):\n",
+    "         file_path = os.path.join(folder_path, filename)\n",
+    "         if is_corrupt(file_path):\n",
+    "            count+=1\n",
+    "            print(\"Image is corrupted:\", file_path)\n",
+    "    return count\n",
+    "if __name__ == '__main__':\n",
+    "    input_folder = input(\"Enter the path to the input folder containing images: \")\n",
+    "    is_corrupt(input_folder)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ce74fa7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# CREATE TEST DATA\n",
+    "source_directory = input(\"Enter source directory: \")\n",
+    "destination_directory = input(\"Enter destinaton directory: \")\n",
+    "\n",
+    "#get the total number of files in the directory\n",
+    "count = 0\n",
+    "for file in os.listdir(source_directory):\n",
+    "    all_files = file\n",
+    "    count += 1\n",
+    "\n",
+    "#get the list of files\n",
+    "all_files = os.listdir(source_directory)\n",
+    "\n",
+    "#get percentage of files to move and sample\n",
+    "twenty_percent = count//5\n",
+    "\n",
+    "files_to_move = random.sample(all_files, twenty_percent)\n",
+    "\n",
+    "\n",
+    "for each_file in files_to_move:\n",
+    "    source_file = os.path.join(source_directory, each_file)\n",
+    "    destination_file = os.path.join(destination_directory, each_file)\n",
+    "    \n",
+    "    # move the file\n",
+    "    shutil.move(source_file, destination_file)  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7668aa65-2fb1-4770-9e6a-50e378f7150e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# assess the contrast quality of each image (overall distribution of pixel intensities in the image.)\n",
+    "def check_histogram_quality(gray):\n",
+    "    hist = cv2.calcHist([gray], [0], None, [256], [0, 256])\n",
+    "    hist_sum = hist.sum()\n",
+    "    hist_normalized = hist / hist_sum\n",
+    "    hist_std = hist_normalized.std()\n",
+    "    return hist_std\n",
+    "\n",
+    "# checks the sharpness level of each image by applying Laplacian algorithm\n",
+    "def check_sharpness(gray):\n",
+    "    return cv2.Laplacian(gray, cv2.CV_64F).var()\n",
+    "\n",
+    "# checks the mean variance of each image\n",
+    "def check_mean_variance(gray):\n",
+    "    mean_intensity = np.mean(gray)\n",
+    "    variance_intensity = np.var(gray)\n",
+    "    return mean_intensity, variance_intensity\n",
+    "\n",
+    "# Returns result based on the quality of each image\n",
+    "def check_image_quality(folder):\n",
+    "    results = []  # Collect results for all images\n",
+    "    for filename in os.listdir(folder):\n",
+    "        if filename.lower().endswith('.jpg'):\n",
+    "            image_path = os.path.join(folder, filename)\n",
+    "            print(f\"Processing: {filename}\") \n",
+    "            image = cv2.imread(image_path)\n",
+    "            if image is None:\n",
+    "                results.append(f\"{filename}: Error: Image not found.\")\n",
+    "                continue  # Skip to the next image\n",
+    "\n",
+    "            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
+    "\n",
+    "            # Quality assessments\n",
+    "            hist_std = check_histogram_quality(gray)\n",
+    "            sharpness = check_sharpness(gray)\n",
+    "            mean_intensity, variance_intensity = check_mean_variance(gray)\n",
+    "\n",
+    "            quality_issues = []\n",
+    "\n",
+    "            print(f\"hist_std for {image_path}: {hist_std}\")\n",
+    "\n",
+    "            #Histogram quality check\n",
+    "            if hist_std <= 0.1:\n",
+    "                quality_issues.append(\"Histogram variance is low; consider improving contrast.\")\n",
+    "            \n",
+    "            # Sharpness check\n",
+    "            if sharpness < 100:  # Adjust as necessary\n",
+    "                quality_issues.append(\"Image is blurry; consider sharpening.\")\n",
+    "\n",
+    "            # Mean intensity check\n",
+    "            if mean_intensity <= 50:\n",
+    "                quality_issues.append(\"Image may be underexposed; consider brightening.\")\n",
+    "            elif mean_intensity >= 200:\n",
+    "                quality_issues.append(\"Image may be overexposed; consider reducing brightness.\")\n",
+    "            \n",
+    "            # Variance check\n",
+    "            if variance_intensity < 1000:  # Adjust threshold as necessary\n",
+    "                quality_issues.append(\"Image has low intensity variance; check for flat areas.\")\n",
+    "\n",
+    "            # Report results for this image\n",
+    "            if quality_issues:\n",
+    "                results.append(f\"{filename}: Image quality is not satisfactory. Issues found:\\n- \" + \"\\n- \".join(quality_issues))\n",
+    "            else:\n",
+    "                results.append(f\"{filename}: Image quality is good.\")\n",
+    "\n",
+    "    return \"\\n\".join(results)  # Return results for all images\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    input_folder = input(\"Enter the path to the input folder containing images: \")\n",
+    "    result = check_image_quality(input_folder)\n",
+    "    print(result)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

datasets/README.md

@@ -0,0 +1,8 @@
+```plaintext
+dataset/
+├── test/
+│   ├── FAKE/
+│   └── REAL/
+└── train/
+    ├── FAKE/
+    └── REAL/

requirements.txt

@@ -0,0 +1,3 @@
+numpy==2.1.3
+streamlit==1.40.0
+tensorflow==2.18.0

styles/style.css

@@ -0,0 +1,179 @@
+/* Reset and global styles */
+* {
+  margin: 0;
+  box-sizing: border-box;
+  background-color: #001220 !important;
+}
+
+html,
+body {
+  height: 100vh !important;
+  width: 100%;
+  overflow-x: hidden;
+  padding: 0 !important;
+}
+
+/* Title Styling */
+.title {
+  font-family: "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
+  font-size: 2em; /* Scalable font size */
+  text-align: center;
+  background: linear-gradient(to right, #16f0da 0%, #ff93ed 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  margin: 0 !important;
+}
+
+/* Upload Line */
+.upload_line {
+  font-family: "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
+  font-size: 1rem;
+  text-align: center;
+  color: white;
+  margin: 1em 0;
+}
+@keyframes blink {
+  25% {
+    opacity: 0.5;
+  }
+  50% {
+    opacity: 0;
+  }
+  75% {
+    opacity: 0.5;
+  }
+}
+/* Base styles for magnifying glasses */
+.detectiveMag1,
+.detectiveMag2,
+.detectiveMag3 {
+  position: fixed;
+  width: 10vw;
+  max-width: 100px;
+  max-height: 100px;
+  animation: blink 6s infinite linear;
+}
+
+.detectiveMag2 {
+  animation-delay: 2s;
+}
+
+.detectiveMag3 {
+  animation-delay: 4s;
+}
+
+/* Result Styling */
+.result {
+  color: rgb(179, 217, 253);
+  font-size: 1.5rem;
+  z-index: 1;
+  text-align: center;
+  margin-top: 1.5em;
+  font-family: "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
+}
+
+.resultword {
+  text-transform: uppercase;
+  background-image: linear-gradient(
+    -225deg,
+    #aae2e5 0%,
+    #edaee8 29%,
+    #421f7e 67%,
+    #ff0099 100%
+  );
+  background-size: auto auto;
+  background-clip: border-box;
+  background-size: 200% auto;
+  color: #fff;
+  background-clip: text;
+  text-fill-color: transparent;
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  animation: textclip 2s linear;
+  display: inline-block;
+  font-size: 32px;
+}
+
+@keyframes textclip {
+  to {
+    background-position: 200% center;
+  }
+}
+
+/* Media Queries for Responsive Design */
+@media (max-width: 1024px) {
+  .title {
+    font-size: 1.8em;
+  }
+
+  .upload_line {
+    font-size: 0.9rem;
+  }
+
+  .detectiveMag1,
+  .detectiveMag2,
+  .detectiveMag3 {
+    width: 12vw; /* Slightly larger magnifying glasses */
+  }
+
+  .result {
+    font-size: 1.2rem;
+  }
+}
+
+@media (max-width: 924px) {
+  .detectiveMag1,
+  .detectiveMag2,
+  .detectiveMag3 {
+    width: 10vw; /* Larger magnifying glasses */
+    background-color: transparent !important;
+  }
+}
+
+@media (max-width: 768px) {
+  .title {
+    font-size: 1.5em;
+  }
+
+  .upload_line {
+    font-size: 0.8rem;
+  }
+
+  .detectiveMag1,
+  .detectiveMag2,
+  .detectiveMag3 {
+    width: 15vw; /* Larger magnifying glasses */
+    background-color: transparent !important;
+  }
+
+  .result {
+    font-size: 1rem;
+  }
+}
+
+@media (max-width: 480px) {
+  .title {
+    font-size: 1.2em;
+  }
+  .upload_line {
+    font-size: 0.7rem;
+  }
+
+  .detectiveMag1,
+  .detectiveMag2,
+  .detectiveMag3 {
+    width: 20vw; /* Even larger magnifying glasses */
+  }
+
+  .result {
+    font-size: 0.9rem;
+  }
+}
+
+@media (max-width: 360px) {
+  .detectiveMag1,
+  .detectiveMag2,
+  .detectiveMag3 {
+    visibility: hidden;
+  }
+}