Upload 4 files

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app.py

@@ -0,0 +1,130 @@
+import gradio as gr
+from PIL import Image
+import numpy as np
+import io, os, zipfile, tempfile, time
+from spm import spm_augment
+
+TITLE = "Shuffle PatchMix (SPM) Augmentation"
+DESC = """
+Upload an image, choose **number of patches (N×N)**, and generate SPM-augmented variants.
+For batch processing, upload a .zip of images (PNG/JPG/JPEG), and download a .zip of outputs.
+"""
+
+def _parse_grid(grid_choice: str) -> int:
+    # Expect strings like "2x2", "4x4", "8x8", "16x16"
+    try:
+        n = int(grid_choice.lower().split("x")[0])
+        return max(1, n)
+    except Exception:
+        return 4
+
+def run_single(image, grid_choice, mix_prob, beta_a, beta_b, num_augs, seed):
+    if image is None:
+        return []
+    outs = []
+    base_seed = int(seed) if seed is not None else None
+    N = _parse_grid(grid_choice)
+    for i in range(num_augs):
+        s = (base_seed + i) if base_seed is not None else None
+        out_img = spm_augment(
+            image,
+            num_patches=N,
+            mix_prob=float(mix_prob),
+            beta_a=float(beta_a),
+            beta_b=float(beta_b),
+            seed=s
+        )
+        outs.append(out_img)
+    return outs
+
+def run_batch(zip_file, grid_choice, mix_prob, beta_a, beta_b, seed):
+    if zip_file is None:
+        return None, "Please upload a .zip file with images."
+    tempdir = tempfile.mkdtemp()
+    outdir = os.path.join(tempdir, "outputs")
+    os.makedirs(outdir, exist_ok=True)
+    # Extract
+    with zipfile.ZipFile(zip_file, 'r') as zf:
+        zf.extractall(tempdir)
+    # Collect images
+    valid_exts = {".png", ".jpg", ".jpeg"}
+    count_in, count_out = 0, 0
+    N = _parse_grid(grid_choice)
+    for root_dir, _, files in os.walk(tempdir):
+        for f in files:
+            if f.lower().endswith(tuple(valid_exts)):
+                in_path = os.path.join(root_dir, f)
+                try:
+                    img = Image.open(in_path).convert("RGB")
+                except Exception:
+                    continue
+                count_in += 1
+                out_img = spm_augment(
+                    img,
+                    num_patches=N,
+                    mix_prob=float(mix_prob),
+                    beta_a=float(beta_a),
+                    beta_b=float(beta_b),
+                    seed=int(seed) if seed is not None else None
+                )
+                rel = os.path.relpath(in_path, tempdir)
+                out_path = os.path.join(outdir, rel)
+                os.makedirs(os.path.dirname(out_path), exist_ok=True)
+                out_img.save(out_path)
+                count_out += 1
+    # Zip results
+    out_zip = os.path.join(tempdir, f"spm_outputs_{int(time.time())}.zip")
+    with zipfile.ZipFile(out_zip, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for root_dir, _, files in os.walk(outdir):
+            for f in files:
+                p = os.path.join(root_dir, f)
+                arc = os.path.relpath(p, outdir)
+                zf.write(p, arcname=arc)
+    msg = f"Processed {count_out}/{count_in} files."
+    return out_zip, msg
+
+with gr.Blocks() as demo:
+    gr.Markdown(f"# {TITLE}")
+    gr.Markdown(DESC)
+    with gr.Tabs():
+        with gr.TabItem("Single Image"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    inp = gr.Image(label="Input image", type="pil")
+                    grid_choice = gr.Radio(choices=["2x2","4x4","8x8","16x16"], value="4x4", label="Grid (N×N)")
+                    mix_prob = gr.Slider(0, 1, value=0.5, step=0.05, label="Mix probability (per patch)")
+                    with gr.Row():
+                        beta_a = gr.Slider(0.1, 8, value=2.0, step=0.1, label="Beta α")
+                        beta_b = gr.Slider(0.1, 8, value=2.0, step=0.1, label="Beta β")
+                    num_augs = gr.Slider(1, 12, value=4, step=1, label="Number of variants")
+                    seed = gr.Number(value=42, precision=0, label="Seed (int, optional)")
+                    run_btn = gr.Button("Generate")
+                with gr.Column(scale=1):
+                    gallery = gr.Gallery(label="Augmented outputs", columns=2, height="auto")
+            run_btn.click(
+                fn=run_single,
+                inputs=[inp, grid_choice, mix_prob, beta_a, beta_b, num_augs, seed],
+                outputs=[gallery]
+            )
+        with gr.TabItem("Batch (.zip)"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    zip_in = gr.File(label="Upload a .zip of images", file_types=[".zip"])
+                    grid_choice_b = gr.Radio(choices=["2x2","4x4","8x8","16x16"], value="4x4", label="Grid (N×N)")
+                    mix_prob_b = gr.Slider(0, 1, value=0.5, step=0.05, label="Mix probability (per patch)")
+                    with gr.Row():
+                        beta_a_b = gr.Slider(0.1, 8, value=2.0, step=0.1, label="Beta α")
+                        beta_b_b = gr.Slider(0.1, 8, value=2.0, step=0.1, label="Beta β")
+                    seed_b = gr.Number(value=42, precision=0, label="Seed (int, optional)")
+                    run_b = gr.Button("Process Zip")
+                with gr.Column(scale=1):
+                    zip_out = gr.File(label="Download results (.zip)")
+                    status = gr.Markdown()
+            run_b.click(
+                fn=run_batch,
+                inputs=[zip_in, grid_choice_b, mix_prob_b, beta_a_b, beta_b_b, seed_b],
+                outputs=[zip_out, status]
+            )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=5.0.0
+pillow
+numpy

spm.py

@@ -0,0 +1,82 @@
+from PIL import Image
+import numpy as np
+
+def _to_divisible_by(img, N):
+    """Crop so width and height are divisible by N (top-left anchored)."""
+    w, h = img.size
+    W = (w // N) * N
+    H = (h // N) * N
+    if W == 0 or H == 0:
+        raise ValueError("N is larger than the image grid (image too small).")
+    if W != w or H != h:
+        img = img.crop((0, 0, W, H))
+    return img, W, H
+
+def spm_augment(
+    image,
+    num_patches=4,   # N for an N×N grid
+    mix_prob=0.5,
+    beta_a=2.0,
+    beta_b=2.0,
+    seed=None
+):
+    """
+    SPM-style augmentation using a global shuffle over an N×N patch grid.
+      1) Divide image into N×N patches (cropping to be divisible by N if needed).
+      2) Globally permute patch indices.
+      3) Per patch, with probability `mix_prob`, replace by a convex blend of
+         original and a shuffled patch using alpha~Beta(beta_a,beta_b) (one alpha per image).
+    """
+    # Normalize input
+    if isinstance(image, np.ndarray):
+        img = Image.fromarray(image).convert("RGB")
+    else:
+        img = image.convert("RGB")
+
+    N = int(num_patches)
+    rng = np.random.default_rng(seed)
+
+    # Ensure divisibility and compute patch size
+    img, W, H = _to_divisible_by(img, N)
+    arr = np.array(img, dtype=np.uint8)
+    ph = H // N
+    pw = W // N
+
+    # Build patch list (row-major)
+    patches = []
+    for i in range(N):
+        for j in range(N):
+            y0 = i * ph
+            x0 = j * pw
+            patches.append(arr[y0:y0+ph, x0:x0+pw])
+
+    total = N * N
+    perm = rng.permutation(total)
+
+    # Sample one alpha for the whole image
+    if beta_a > 0 and beta_b > 0:
+        alpha = float(rng.beta(beta_a, beta_b))
+    else:
+        alpha = 1.0
+
+    # Patchwise mix
+    out = arr.copy()
+    mask = rng.random(total) < float(mix_prob)
+    idx = 0
+    for i in range(N):
+        for j in range(N):
+            y0 = i * ph
+            x0 = j * pw
+            if mask[idx]:
+                src = patches[idx].astype(np.float32)
+                shf = patches[perm[idx]].astype(np.float32)
+                if 0.0 < alpha < 1.0:
+                    mixed = alpha * shf + (1.0 - alpha) * src
+                    out[y0:y0+ph, x0:x0+pw] = np.clip(mixed, 0, 255).astype(np.uint8)
+                else:
+                    out[y0:y0+ph, x0:x0+pw] = patches[perm[idx]]
+            else:
+                out[y0:y0+ph, x0:x0+pw] = patches[idx]
+            idx += 1
+
+    return Image.fromarray(out)