nhradek/FLUX-Detection-Classifier

An embedding model to classify images into FLUX generated images and non-flux photographs. The embeddings are 128 dimensional and can be used in another classifier to classify. Current classifiers can classify up to 83% accuracy. XGBoost has an F1 = 0.83 and KNN F1 = 0.87

The model can load Fourier transformed images of size 512x512 which are then fed into the model and a 128 length output vector is produced. The steps to create the embeddings can be described as:

1. Resize the images to 512x512.
2. Transform the images into their Fourier image.
3. Input the images into the model using predict.
4. The output will be a 128-length vector for use in classification models.

The preprocessing code along with predict can calculate the embeddings for classification.

# load an image and apply the Fourier transform

import numpy as np
from PIL import Image
from scipy.fftpack import fft2
from tensorflow.keras.models import load_model, Model

# Function to apply Fourier transform
def apply_fourier_transform(image):
    image = np.array(image)
    fft_image = fft2(image)
    return np.abs(fft_image)

# Function to preprocess image
def preprocess_image(image_path):
    try:
      image = Image.open(image_path).convert('L')
      image = image.resize((512, 512))
      image = apply_fourier_transform(image)
      image = np.expand_dims(image, axis=-1)  # Expand dimensions to match model input shape
      image = np.expand_dims(image, axis=0)   # Expand to add batch dimension
      return image
    except Exception as e:
        print(f"Error processing image {image_path}: {e}")
        return None

# Function to load embedding model and calculate embeddings
def calculate_embeddings(image_path, model_path='embedding_model.keras'):
    # Load the trained model
    model = load_model(model_path)

    # Remove the final classification layer to get embeddings
    embedding_model = Model(inputs=model.input, outputs=model.output)

    # Preprocess the image
    preprocessed_image = preprocess_image(image_path)

    # Calculate embeddings
    embeddings = embedding_model.predict(preprocessed_image)

    return embeddings



calculate_embeddings('filename.jpg')