First commit

README.md

@@ -1,14 +1,317 @@
 ---
-title: SuSyGame
-emoji: 🏃
-colorFrom: pink
-colorTo: red
+title: SuSy
+emoji: 🔎
+colorFrom: gray
+colorTo: pink
 sdk: gradio
-sdk_version: 5.3.0
+sdk_version: 4.44.1
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: A game of synthetic image detection against SuSy
+short_description: Spot AI-Generated images with SuSy!
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SuSy - Synthetic Image Detector
+
+<img src="https://cdn-uploads.huggingface.co/production/uploads/62f7a16192950415b637e201/NobqlpFbFkTyBi1LsT9JE.png" alt="image" width="300" height="auto">
+
+
+- **Paper:** https://arxiv.org/abs/2409.14128
+- **Model:** https://huggingface.co/HPAI-BSC/SuSy
+- **Code:** https://github.com/HPAI-BSC/SuSy
+- **Dataset:** https://huggingface.co/datasets/HPAI-BSC/SuSy-Dataset
+
+**Model Results**
+
+| Dataset             | Type      | Model                     | Year | Recall |
+|:-------------------:|:---------:|:-------------------------:|:----:|:------:|
+| Flickr30k           | Authentic | -                         | 2014 | 90.53  |
+| Google Landmarks v2 | Authentic | -                         | 2020 | 64.54  |
+| Synthbuster         | Synthetic | Glide                     | 2021 | 53.50  |
+| Synthbuster         | Synthetic | Stable Diffusion 1.3      | 2022 | 87.00  |
+| Synthbuster         | Synthetic | Stable Diffusion 1.4      | 2022 | 87.10  |
+| Synthbuster         | Synthetic | Stable Diffusion 2        | 2022 | 68.40  |
+| Synthbuster         | Synthetic | DALL-E 2                  | 2022 | 20.70  |
+| Synthbuster         | Synthetic | MidJourney V5             | 2023 | 73.10  |
+| Synthbuster         | Synthetic | Stable Diffusion XL       | 2023 | 79.50  |
+| Synthbuster         | Synthetic | Firefly                   | 2023 | 40.90  |
+| Synthbuster         | Synthetic | DALL-E 3                  | 2023 | 88.60  |
+| Authors             | Synthetic | Stable Diffusion 3 Medium | 2024 | 93.23  |
+| Authors             | Synthetic | Flux.1-dev                | 2024 | 96.46  |
+| In-the-wild         | Synthetic | Mixed/Unknown             | 2024 | 89.90  |
+| In-the-wild         | Authentic | -                         | 2024 | 33.06  |
+
+## Model Details
+
+<!-- Provide a longer summary of what this model is. -->
+
+SuSy is a Spatial-Based Synthetic Image Detection and Recognition Model, designed and trained to detect synthetic images and attribute them to a generative model (i.e., two StableDiffusion models, two Midjourney versions and DALL·E 3). The model takes image patches of size 224x224 as input, and outputs the probability of the image being authentic or having been created by each of the aforementioned generative models.
+
+<img src="model_architecture.png" alt="image" width="900" height="auto">
+
+The model is based on a CNN architecture and is trained using a supervised learning approach. It's design is based on [previous work](https://upcommons.upc.edu/handle/2117/395959), originally intended for video superresolution detection, adapted here for the tasks of synthetic image detection and recognition. The architecture consists of two modules: a feature extractor and a multi-layer perceptron (MLP), as it's quite light weight. SuSy has a total of 12.7M parameters, with the feature extractor accounting for 12.5M parameters and the MLP accounting for the remaining 197K.
+
+The CNN feature extractor consists of five stages following a ResNet-18 scheme. The output of each of the blocks is used as input for various bottleneck modules that are arranged in a staircase pattern. The bottleneck modules consist of three 2D convolutional layers. Each level of bottlenecks takes input at a later stage than the previous level, and each bottleneck module takes input from the current stage and, except the first bottleneck of each level, from the previous bottleneck module.
+
+The outputs of each level of bottlenecks and stage 4 are passed to a 2D adaptative average pooling layer and then concatenated to form the feature map feeding the MLP. The MLP consists of three fully connected layers with 512, 256 and 256 units, respectively. Between each layer, a dropout layer (rate of 0.5) prevents overfitting. The output of the MLP has 6 units, corresponding to the number of classes in the dataset (5 synthetic models and 1 real image class).
+
+The model can be used as a detector by either taking the class with the highest probability as the output or summing the probabilities of the synthetic classes and comparing them to the real class. The model can also be used as an recognition model by taking the class with the highest probability as the output.
+
+### Model Description
+
+- **Developed by:** [Pablo Bernabeu Perez](https://huggingface.co/pabberpe), [Enrique Lopez Cuena](https://huggingface.co/Cuena) and [Dario Garcia Gasulla](https://huggingface.co/dariog) from [HPAI](https://hpai.bsc.es/)
+- **Model type:** Spatial-Based Synthetic Image Detection and Recognition Convolutional Neural Network
+- **License:** [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+## Uses
+
+This model can be used to detect synthetic images in a scalable manner, thanks to its small size. Since it operates on patches of 224x224, a moving window should be implemented in inference when applied on larger inputs (the most likely scenario, and the one it was trained under). This also enables the capacity for synthetic content localization within a high resolution input.
+
+Any individual or organization seeking for support on the identification of synthetic content can use this model. However, it should not be used as the only source of evidence, particularly when applied to inputs produced by generative models not included in its training (see details in Training Data below).
+
+### Intended Uses
+
+Intended uses include the following:
+
+* Detection of authentic and synthetic images
+* Attribution of synthetic images to their generative model (if included in the training data)
+* Localization of image patches likely to be synthetic or tampered.
+
+### Out-of-Scope Uses
+
+Out-of-scope uses include the following:
+
+* Detection of manually edited images using traditional tools.
+* Detection of images automatically downscaled and/or upscaled. These are considered as non-synthetic samples in the model training phase. 
+* Detection of inpainted images.
+* Detection of synthetic vs manually crafted illustrations. The model is trained mainly on photorealistic samples.
+* Attribution of synthetic images to their generative model if the model was not included in the training data. AThis model may not be used to train generative models or tools aimed at lthough some generalization capabilities are expected, reliability in this case cannot be estimated.
+
+### Forbidden Uses
+
+This model may not be used to train generative models or tools aimed at purposefully deceiving the model or creating misleading content.
+
+## Bias, Risks, and Limitations
+
+The model may be biased in the following ways:
+
+* The model may be biased towards the training data, which may not be representative of all authentic and synthetic images. Particularly for the class of real world images, which were obtained from a single source.
+* The model may be biased towards the generative models included in the training data, which may not be representative of all possible generative models. Particularly new ones, since all models included were released between 2022 and 2023.
+* The model may be biased towards certain type of images or contents. While it is trained using roughly 18K synthetic images, no assessment was made on which domains and profiles are included in those.
+
+The model has the following technical limitations:
+
+* The performance of the model may be influenced by transformations and editions performed on the images. While the model was trained on some alterations (blur, brightness, compression and gamma) there are other alterations applicable to images that could reduce the model accuracy.
+* The performance of the model might vary depending on the type and source of images
+* The model will not be able to attribute synthetic images to their generative model if the model was not included in the training data.
+* The model is trained on patches with high gray-level contrast. For images composed entirely by low contrast regions, the model may not work as expected.
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+```python
+import torch
+from PIL import Image
+from torchvision import transforms
+
+# Load the model
+model = torch.jit.load("SuSy.pt")
+
+# Load patch
+patch = Image.open("midjourney-images-example-patch0.png")
+
+# Transform patch to tensor
+patch = transforms.PILToTensor()(patch).unsqueeze(0) / 255.
+
+# Predict patch
+model.eval()
+with torch.no_grad():
+    preds = model(patch)
+
+print(preds)
+```
+
+See `test_image.py` and `test_patch.py` for other examples on how to use the model.
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+The dataset is available at: https://huggingface.co/datasets/HPAI-BSC/SuSy-Dataset
+
+|      Dataset      | Year | Train | Validation | Test  | Total |
+|:-----------------:|:----:|:-----:|:----------:|:-----:|:-----:|
+|        COCO       | 2017 | 2,967 |    1,234   | 1,234 | 5,435 |
+|   dalle-3-images  | 2023 |  987  |     330    |  330  | 1,647 |
+|    diffusiondb    | 2022 | 2,967 |    1,234   | 1,234 | 5,435 |
+|   realisticSDXL   | 2023 | 2,967 |    1,234   | 1,234 | 5,435 |
+|   midjourney-tti  | 2022 | 2,718 |     906    |  906  | 4,530 |
+| midjourney-images | 2023 | 1,845 |     617    |  617  | 3,079 |
+
+#### Authentic Images
+
+- [COCO](https://cocodataset.org/)
+
+We use a random subset of the COCO dataset, containing 5,435 images, for the authentic images in our training dataset. The partitions are made respecting the original COCO splits, with 2,967 images in the training partition and 1,234 in the validation and test partitions.
+
+#### Synthetic Images
+
+- [dalle-3-images](https://huggingface.co/datasets/ehristoforu/dalle-3-images)
+- [diffusiondb](https://poloclub.github.io/diffusiondb/)
+- [midjourney-images](https://huggingface.co/datasets/ehristoforu/midjourney-images)
+- [midjourney-texttoimage](https://www.kaggle.com/datasets/succinctlyai/midjourney-texttoimage)
+- [realistic-SDXL](https://huggingface.co/datasets/DucHaiten/DucHaiten-realistic-SDXL)
+
+For the diffusiondb dataset, we use a random subset of 5,435 images, with 2,967 in the training partition and 1,234 in the validation and test partitions. We use only the realistic images from the realisticSDXL dataset, with images in the realistic-2.2 split in our training data and the realistic-1 split for our test partition. The remaining datasets are used in their entirety, with 60% of the images in the training partition, 20% in the validation partition and 20% in the test partition.
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+The training code is available at: https://github.com/HPAI-BSC/SuSy
+
+#### Preprocessing
+
+**Patch Extraction**
+
+To prepare the training data, we extract 240x240 patches from the images, minimizing the overlap between them. We then select the most informative patches by calculating the gray-level co-occurrence matrix (GLCM) for each patch. Given the GLCM, we calculate the contrast and select the five patches with the highest contrast. These patches are then passed to the model in their original RGB format and cropped to 224x224.
+
+**Data Augmentation**
+
+| Technique                | Probability | Other Parameters                          |
+|:------------------------:|:-----------:|:-----------------------------------------:|
+| HorizontalFlip           |     0.50    | -                                         |
+| RandomBrightnessContrast |     0.20    | brightness\_limit=0.2 contrast\_limit=0.2 |
+| RandomGamma              |     0.20    | gamma\_limit=(80, 120)                    |
+| AdvancedBlur             |     0.20    |                                           |
+| GaussianBlur             |     0.20    |                                           |
+| JPEGCompression          |     0.20    | quality\_lower=75 quality\_upper=100      |
+
+
+#### Training Hyperparameters
+
+- Loss Function: Cross-Entropy Loss
+- Optimizer: Adam
+- Learning Rate: 0.0001
+- Weight Decay: 0
+- Scheduler: ReduceLROnPlateau
+- Factor: 0.1
+- Patience: 4
+- Batch Size: 128
+- Epochs: 10
+- Early Stopping: 2
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+The evaluation code is available at: https://github.com/HPAI-BSC/SuSy
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+- Test Split of our Training Dataset
+- Synthetic Images generated with [Stable Diffusion 3 Medium](https://huggingface.co/stabilityai/stable-diffusion-3-medium) and [FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev) using prompts from [Gustavosta/Stable-Diffusion-Prompts](https://huggingface.co/datasets/Gustavosta/Stable-Diffusion-Prompts)
+- Synthetic Images in the Wild: Dataset containing 210 Authentic and Synthetic Images obtained from Social Media Platforms
+- [Flickr 30k Dataset](https://www.kaggle.com/datasets/hsankesara/flickr-image-dataset)
+- [Google Landmarks v2](https://github.com/cvdfoundation/google-landmark)
+- [Synthbuster](https://zenodo.org/records/10066460)
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+- Recall: The proportion of correctly classified positive instances out of all actual positive instances in a dataset.
+
+### Results
+
+<!-- This section provides the results of the evaluation. -->
+
+#### Authentic Sources
+
+| Dataset             | Year | Recall |
+|:-------------------:|:----:|:------:|
+| Flickr30k           | 2014 | 90.53  |
+| Google Landmarks v2 | 2020 | 64.54  |
+| In-the-wild         | 2024 | 33.06  |
+
+#### Synthetic Sources
+
+| Dataset     | Model                     | Year | Recall |
+|:-----------:|:-------------------------:|:----:|:------:|
+| Synthbuster | Glide                     | 2021 | 53.50  |
+| Synthbuster | Stable Diffusion 1.3      | 2022 | 87.00  |
+| Synthbuster | Stable Diffusion 1.4      | 2022 | 87.10  |
+| Synthbuster | Stable Diffusion 2        | 2022 | 68.40  |
+| Synthbuster | DALL-E 2                  | 2022 | 20.70  |
+| Synthbuster | MidJourney V5             | 2023 | 73.10  |
+| Synthbuster | Stable Diffusion XL       | 2023 | 79.50  |
+| Synthbuster | Firefly                   | 2023 | 40.90  |
+| Synthbuster | DALL-E 3                  | 2023 | 88.60  |
+| Authors     | Stable Diffusion 3 Medium | 2024 | 93.23  |
+| Authors     | Flux.1-dev                | 2024 | 96.46  |
+| In-the-wild | Mixed/Unknown             | 2024 | 89.90  |
+
+### Summary
+
+The results for authentic image datasets reveal varying detection performance across different sources. Recall rates range from 33.06% for the In-the-wild dataset to 90.53% for the Flickr30k dataset. The Google Landmarks v2 dataset shows an intermediate recall rate of 64.54%. These results indicate a significant disparity in the detectability of authentic images across different datasets, with the In-the-wild dataset presenting the most challenging case for SuSy.
+
+The results for synthetic image datasets show varying detection performance across different image generation models. Recall rates range from 20.70% for DALL-E 2 (2022) to 96.46% for Flux.1-dev (2024). Stable Diffusion models generally exhibited high detectability, with versions 1.3 and 1.4 (2022) showing recall rates above 87%. More recent models tested by the authors, such as Stable Diffusion 3 Medium (2024) and Flux.1-dev (2024), demonstrate even higher detectability with recall rates above 93%. The in-the-wild mixed/unknown synthetic dataset from 2024 showed a high recall of 89.90%, indicating effective detection across various unknown generation methods. These results suggest an overall trend of improving detection capabilities for synthetic images, with newer generation models generally being more easily detectable.
+
+It must be noted that these metrics were computed using the center-patch of images, instead of using the patch voting mechanisms described previously. This strategy allows a more fair comparison with other state-of-the-art methods although it hinders the performance of SuSy.
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+- **Hardware Type:** H100
+- **Hours used:** 16
+- **Hardware Provider:** Barcelona Supercomputing Center (BSC)
+- **Compute Region:** Spain
+- **Carbon Emitted:** 0.63kg
+
+## Citation
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+```bibtex
+@misc{bernabeu2024susy,
+    title={Present and Future Generalization of Synthetic Image Detectors}, 
+    author={Pablo Bernabeu-Perez and Enrique Lopez-Cuena and Dario Garcia-Gasulla},
+    year={2024},
+    eprint={2409.14128},
+    archivePrefix={arXiv},
+    primaryClass={cs.CV},
+    url={https://arxiv.org/abs/2409.14128}, 
+}
+```
+
+```bibtex
+@thesis{bernabeu2024aidetection,
+    title={Detecting and Attributing AI-Generated Images with Machine Learning},
+    author={Bernabeu Perez, Pablo},
+    school={UPC, Facultat d'Informàtica de Barcelona, Departament de Ciències de la Computació},
+    year={2024},
+    month={06}
+}
+```
+
+## Model Card Authors
+
+[Pablo Bernabeu Perez](https://huggingface.co/pabberpe) and [Dario Garcia Gasulla](https://huggingface.co/dariog)
+
+## Model Card Contact
+
+For further inquiries, please contact [HPAI](mailto:[email protected])

app.py

@@ -0,0 +1,270 @@
+import gradio as gr
+import numpy as np
+import torch
+import random
+from PIL import Image
+from skimage.feature import graycomatrix, graycoprops
+from torchvision import transforms
+import os
+
+NUM_ROUNDS = 5  # Adjust the number of game rounds here
+PROB_THRESHOLD = 0.5  # Adjust the probability threshold for model prediction here
+
+# Load the model
+model = torch.jit.load("SuSy.pt")
+
+def process_image(image):
+    # Set Parameters
+    top_k_patches = 5
+    patch_size = 224
+
+    # Get the image dimensions
+    width, height = image.size
+
+    # Calculate the number of patches
+    num_patches_x = width // patch_size
+    num_patches_y = height // patch_size
+
+    # Divide the image in patches
+    patches = np.zeros((num_patches_x * num_patches_y, patch_size, patch_size, 3), dtype=np.uint8)
+    for i in range(num_patches_x):
+        for j in range(num_patches_y):
+            x = i * patch_size
+            y = j * patch_size
+            patch = image.crop((x, y, x + patch_size, y + patch_size))
+            patches[i * num_patches_y + j] = np.array(patch)
+
+    # Compute the most relevant patches (optional)
+    dissimilarity_scores = []
+    for patch in patches:
+        transform_patch = transforms.Compose([transforms.PILToTensor(), transforms.Grayscale()])
+        grayscale_patch = transform_patch(Image.fromarray(patch)).squeeze(0)
+        glcm = graycomatrix(grayscale_patch, [5], [0], 256, symmetric=True, normed=True)
+        dissimilarity_scores.append(graycoprops(glcm, "contrast")[0, 0])
+
+    # Sort patch indices by their dissimilarity score
+    sorted_indices = np.argsort(dissimilarity_scores)[::-1]
+
+    # Extract top k patches and convert them to tensor
+    top_patches = patches[sorted_indices[:top_k_patches]]
+    top_patches = torch.from_numpy(np.transpose(top_patches, (0, 3, 1, 2))) / 255.0
+
+    # Predict patches
+    model.eval()
+    with torch.no_grad():
+        preds = model(top_patches)
+
+    # Process results
+    classes = ['Authentic', 'DALL·E 3', 'Stable Diffusion 1.x', 'MJ V5/V6', 'MJ V1/V2', 'Stable Diffusion XL']
+    mean_probs = preds.mean(dim=0).numpy()
+    
+    # Create a dictionary of class probabilities
+    class_probs = {cls: prob for cls, prob in zip(classes, mean_probs)}
+    
+    # Sort probabilities in descending order
+    sorted_probs = dict(sorted(class_probs.items(), key=lambda item: item[1], reverse=True))
+
+    return sorted_probs
+
+
+class GameState:
+    def __init__(self):
+        self.user_score = 0
+        self.model_score = 0
+        self.current_round = 0
+        self.total_rounds = 2
+        self.game_images = []
+        self.is_game_active = False
+        self.last_results = None
+        self.waiting_for_input = True
+
+    def reset(self):
+        self.__init__()
+
+game_state = GameState()
+
+def load_images():
+    real_image_folder = "real_images"
+    fake_image_folder = "fake_images"
+    real_images = [os.path.join(real_image_folder, img) for img in os.listdir(real_image_folder)]
+    fake_images = [os.path.join(fake_image_folder, img) for img in os.listdir(fake_image_folder)]
+    selected_images = random.sample(real_images, 1) + random.sample(fake_images, 1)
+    random.shuffle(selected_images)
+    return selected_images
+
+def create_score_html():
+    results_html = ""
+    if game_state.last_results:
+        results_html = f"""
+        <div style='margin-top: 1rem; padding: 1rem; background-color: #e0e0e0; border-radius: 8px; color: #333;'>
+            <h4 style='color: #333; margin-bottom: 0.5rem;'>Last Round Results:</h4>
+            <p style='color: #333;'>Your guess: {game_state.last_results['user_guess']}</p>
+            <p style='color: #333;'>Model's guess: {game_state.last_results['model_guess']}</p>
+            <p style='color: #333;'>Correct answer: {game_state.last_results['correct_answer']}</p>
+        </div>
+        """
+
+    current_display_round = min(game_state.current_round + 1, game_state.total_rounds)
+    
+    return f"""
+    <div style='padding: 1rem; background-color: #f0f0f0; border-radius: 8px; color: #333;'>
+        <h3 style='margin-bottom: 1rem; color: #333;'>Score Board</h3>
+        <div style='display: flex; justify-content: space-around;'>
+            <div>
+                <h4 style='color: #333;'>You</h4>
+                <p style='font-size: 1.5rem; color: #333;'>{game_state.user_score}</p>
+            </div>
+            <div>
+                <h4 style='color: #333;'>AI Model</h4>
+                <p style='font-size: 1.5rem; color: #333;'>{game_state.model_score}</p>
+            </div>
+        </div>
+        <div style='margin-top: 1rem;'>
+            <p style='color: #333;'>Round: {current_display_round}/{game_state.total_rounds}</p>
+        </div>
+        {results_html}
+    </div>
+    """
+
+def start_game():
+    game_state.reset()
+    game_state.game_images = load_images()
+    game_state.is_game_active = True
+    game_state.waiting_for_input = True
+    current_image = Image.open(game_state.game_images[0])
+    
+    return (
+        gr.update(value=current_image, visible=True),  # Show image
+        gr.update(visible=False),  # Hide start button
+        gr.update(interactive=True, visible=True, value=None),  # Show radio buttons
+        gr.update(visible=True, interactive=True),  # Show submit button
+        create_score_html(),
+        gr.update(visible=False)  # Hide feedback
+    )
+
+def submit_guess(user_guess):
+    if not game_state.is_game_active or not game_state.waiting_for_input or user_guess is None:
+        return [gr.update()] * 6  # Return no updates if invalid state
+    
+    current_image = Image.open(game_state.game_images[game_state.current_round])
+    model_prediction = process_image(current_image)
+    correct_answer = "Real" if "real_images" in game_state.game_images[game_state.current_round] else "Fake"
+    
+    # Determine model's guess based on probabilities
+    model_guess = "Real" if model_prediction['Authentic'] > 0.5 else "Fake"
+    
+    # Update scores
+    if user_guess == correct_answer:
+        game_state.user_score += 1
+    if model_guess == correct_answer:
+        game_state.model_score += 1
+    
+    # Store last results for display
+    game_state.last_results = {
+        'user_guess': user_guess,
+        'model_guess': model_guess,
+        'correct_answer': correct_answer
+    }
+    
+    game_state.current_round += 1
+    game_state.waiting_for_input = True
+    
+    # Check if game is over
+    if game_state.current_round >= game_state.total_rounds:
+        game_state.is_game_active = False
+        return (
+            gr.update(value=None, visible=False),  # Hide image
+            gr.update(visible=True),  # Show start button
+            gr.update(interactive=False, visible=False, value=None),  # Hide radio
+            gr.update(visible=False),  # Hide submit button
+            create_score_html(),
+            gr.update(visible=True, value="<div style='text-align: center; margin-top: 20px; font-size: 1.2em;'>Game Over! Click 'Start New Game' to play again.</div>")
+        )
+    
+    # Continue to next round
+    next_image = Image.open(game_state.game_images[game_state.current_round])
+    return (
+        gr.update(value=next_image, visible=True),  # Show next image
+        gr.update(visible=False),  # Keep start button hidden
+        gr.update(interactive=True, visible=True, value=None),  # Reset radio
+        gr.update(visible=True, interactive=True),  # Show submit button
+        create_score_html(),
+        gr.update(visible=False)  # Keep feedback hidden
+    )
+
+# Custom CSS
+custom_css = """
+#game-container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 20px;
+}
+#start-button {
+    max-width: 200px;
+    margin: 0 auto;
+}
+"""
+
+# Define Gradio interface
+with gr.Blocks(css=custom_css) as iface:
+    with gr.Column(elem_id="game-container"):
+        gr.Markdown("# Real or Fake Image Challenge")
+        gr.Markdown("Can you beat the AI at detecting synthetic images?")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                image_display = gr.Image(
+                    type="pil",
+                    label="Current Image",
+                    interactive=False,
+                    visible=False
+                )
+                guess_input = gr.Radio(
+                    choices=["Real", "Fake"],
+                    label="Your Guess",
+                    interactive=False,
+                    visible=False
+                )
+                submit_button = gr.Button(
+                    "Submit Guess",
+                    visible=False,
+                    variant="primary"
+                )
+            
+            with gr.Column(scale=1):
+                score_display = gr.HTML()
+                
+        with gr.Row():
+            with gr.Column(elem_id="start-button"):
+                start_button = gr.Button("Start New Game", variant="primary", size="sm")
+        
+        feedback_display = gr.Markdown(visible=False)
+        
+        # Event handlers
+        start_button.click(
+            fn=start_game,
+            outputs=[
+                image_display,
+                start_button,
+                guess_input,
+                submit_button,
+                score_display,
+                feedback_display
+            ]
+        )
+        
+        submit_button.click(
+            fn=submit_guess,
+            inputs=[guess_input],
+            outputs=[
+                image_display,
+                start_button,
+                guess_input,
+                submit_button,
+                score_display,
+                feedback_display
+            ]
+        )
+
+# Launch the interface
+iface.launch()

config.json

@@ -0,0 +1,8 @@
+{
+    "model_architecture": "ResNet18",
+    "num_classes": 6,
+    "input_size": [224, 224],
+    "pretrained": true,
+    "learning_rate": 0.0001,
+    "batch_size": 256
+  }

requirements.txt

@@ -0,0 +1,5 @@
+torch
+torchvision
+pillow
+scikit-image
+gradio