Upload 2 files

CLIP_CreativeTesting.py

@@ -0,0 +1,76 @@
+import os
+
+from PIL import Image
+import requests
+# Create function to pass input image and text to model and return the label probabilities
+import torch
+import time
+from detect_adv import detect_text, analyze_layout, analyze_shapes
+from transformers import CLIPProcessor, CLIPModel
+# Streamlit code to upload image and output label probabilities
+import streamlit as st
+import tempfile
+
+model = CLIPModel.from_pretrained("openai/clip-vit-large-patch14")
+processor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")
+
+
+def get_label_probs(image, text, model, processor):
+    torch.cuda.empty_cache()  # Release cached memory
+    inputs = processor(text=text, images=image, return_tensors="pt", padding=True)
+    inputs = inputs
+    outputs = model(**inputs)
+    logits_per_image = outputs.logits_per_image
+    probs = logits_per_image.softmax(dim=1)
+    # Clear GPU memory
+    torch.cuda.empty_cache()
+    del inputs, outputs, logits_per_image
+    return probs
+
+text = ['Advertisement Creative(Contains Text)', 'Not an Advertisement Creative(Contains No Text)', 'Simple Product Image and not an Advertisement)']
+
+
+
+st.title("Advertisement Detection using CLIP")
+
+# Upload image
+uploaded_image = st.file_uploader("Choose an image...", type="jpg")
+
+
+if uploaded_image is not None:
+    temp_dir = tempfile.mkdtemp()
+    path = os.path.join(temp_dir, uploaded_image.name)
+    with open(path, "wb") as f:
+        f.write(uploaded_image.getvalue())
+
+    image = Image.open(uploaded_image)
+    st.image(image, caption="Uploaded Image.", use_column_width=True)
+    # Get label probabilities
+    probs = get_label_probs(image, text, model, processor)
+    # Output label probabilities
+    prob = probs.tolist()
+    prob = prob[0]
+    # st.write("Label Probabilities:", prob)
+    # st.write("Label Probabilities:", probs)
+    # # Output predicted label
+    # predicted_label = text[torch.argmax(probs[0])]
+    # st.write("Predicted Label:", predicted_label)
+
+    # Augmenting using classic techniques
+    layout_result = analyze_layout(path)
+    shape_result = analyze_shapes(path)
+    #
+    # # Output classic technique results
+    # st.write("Layout Analysis Result:", layout_result)
+    # st.write("Shape Analysis Result:", shape_result)
+    final_out = False
+    # Find index of max value from list
+    max_index = prob.index(max(prob))
+    if max_index == 0 and (layout_result == True or shape_result == True):
+        final_out = True
+    # Write 'Advertisement' if the image is an advertisement
+    if final_out == True:
+        st.write("Advertisement")
+    else:
+        st.write("Not an Advertisement")
+

detect_adv.py

@@ -0,0 +1,139 @@
+import cv2
+import numpy as np
+from collections import Counter
+
+
+
+from paddleocr import PaddleOCR, draw_ocr
+
+# Paddleocr supports Chinese, English, French, German, Korean and Japanese.
+# You can set the parameter `lang` as `ch`, `en`, `fr`, `german`, `korean`, `japan`
+# to switch the language model in order.
+ocr = PaddleOCR(use_angle_cls=True, lang='en')  # need to run only once to download and load model into memory
+def detect_text(image):
+
+    result = ocr.ocr(image, cls=True)
+    txt = ''
+    for idx in range(len(result)):
+        res = result[idx]
+        for line in res:
+            txt += line[1][0]
+
+    return txt
+def analyze_text(text):
+    marketing_keywords = ['sale', 'offer', 'discount', 'promotion', 'limited', 'buy', 'now', ]
+
+    # Count the occurrences of marketing keywords
+    word_count = Counter([word.lower() for word in text.split()])
+    keyword_count = sum(word_count[keyword] for keyword in marketing_keywords)
+
+    # Classify based on the number of marketing keywords
+    if keyword_count > 2:
+        return "Advertisement"
+    else:
+        return "Normal Product Image"
+
+
+# Point 2: Layout and Composition Analysis
+
+def analyze_layout(image_path):
+
+    image = cv2.imread(image_path)
+
+    # Convert image to grayscale
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+    # Invert the grayscale image
+    inverted = cv2.bitwise_not(gray)
+
+    # Apply Otsu's thresholding
+    _, thresholded = cv2.threshold(inverted, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
+
+    # Find contours in the thresholded image
+    contours, _ = cv2.findContours(thresholded, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Initialize counters
+    asymmetric_count = 0
+    dynamic_shape_count = 0
+
+    # Iterate through contours
+    for contour in contours:
+        # Calculate the bounding rectangle of the contour
+        x, y, w, h = cv2.boundingRect(contour)
+
+        # Calculate aspect ratio
+        aspect_ratio = float(w) / h
+
+        # Check for asymmetric layout
+        if aspect_ratio < 0.8 or aspect_ratio > 1.2:
+            asymmetric_count += 1
+
+        # Check for dynamic shape
+        if len(contour) > 5:
+            _, _, angle = cv2.fitEllipse(contour)
+            if angle > 30 and angle < 150:
+                dynamic_shape_count += 1
+
+    # Determine if it's an advertisement based on criteria
+    is_advertisement = False
+    if asymmetric_count > 1 or dynamic_shape_count > 1:
+        is_advertisement = True
+
+    return is_advertisement
+
+
+
+
+
+# Point 3: Color Analysis
+def analyze_color(image_path):
+    # Load the image
+    image = cv2.imread(image_path)
+
+    # Convert image to HSV
+    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+
+    # Calculate mean saturation and value
+    mean_saturation = np.mean(hsv_image[:, :, 1])
+    mean_value = np.mean(hsv_image[:, :, 2])
+
+    # Check for high saturation and value (vivid colors)
+    if mean_saturation > 150 and mean_value > 150:
+        return "Advertisement"
+    else:
+        return "Not Advertisement"
+
+
+
+# Point 4: Edge Detection and Shape Analysis
+def analyze_shapes(image_path):
+    image = cv2.imread(image_path)
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    edges = cv2.Canny(gray, 100, 200)
+
+    # Find contours
+    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Check for specific shapes (e.g., arrows, starbursts)
+    for cnt in contours:
+        approx = cv2.approxPolyDP(cnt, 0.01 * cv2.arcLength(cnt, True), True)
+        if len(approx) in [3, 5, 7]:  # Triangles, pentagons, or starbursts
+            return True
+
+    return False
+
+
+# # Load the image
+# image = '/home/karun/PycharmProjects/AdGod/250.jpg'
+# img_open = Image.open(image)
+#
+# # Analyze the image using different techniques
+# text_result = analyze_text(detect_text(image))
+# layout_result = analyze_layout(image)
+# color_result = analyze_color(image)
+# shape_result = analyze_shapes(image)
+#
+# # Print the results
+# print("Text Analysis Result:", text_result)
+# print("Layout Analysis Result:", layout_result)
+# print("Shape Analysis Result:", shape_result)