first version using classifier

app.py

@@ -0,0 +1,14 @@
+# Interactive code
+import argparse
+from interactivity import run_interactive_pipeline
+
+if __name__ == "__main__":
+    BACKEND_OPTIONS = ["gradio", "qt", "mpl"]
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-b", "--backend", type=str,
+                        choices=BACKEND_OPTIONS, default=BACKEND_OPTIONS[0])
+    args = parser.parse_args()
+    backend = args.backend
+    markdown_description = "# 🔍 EXAMPLE Interactive-pipe + machine learning \n"
+    run_interactive_pipeline(
+        backend=backend, markdown_description=markdown_description)

core.py

@@ -0,0 +1,74 @@
+# "Production code"
+import numpy as np
+from PIL import Image
+from interactive_pipe import interactive_pipeline, interactive, Curve, SingleCurve
+from transformers import pipeline
+
+
+@interactive(
+    radius=(0.005, [0., 0.01]),
+    isotropy=(0.5, [0., 1.]),
+)
+def gen_color(
+    radius: int = 0,  # discrete slider (int)
+    isotropy: float = 0.,  # continuous slider (float)
+):
+    out = np.zeros((256, 256, 3))  # Initial background set to black
+    out[:, :, 1] = 0.5
+    x, y = np.meshgrid(np.linspace(-1, 1, 256), np.linspace(-1, 1, 256))
+    # ball positions and colors: [(cx, cy), [R, G, B]]
+    balls = [
+        ((0, 0), [0.8, 0.8, 0.8]),  # Cue ball (white)
+        ((0.0, -0.6), [1, 1, 0]),
+        ((-0.15, -0.85), [1, 0, 0]),
+        ((0.0, -0.85), [0, 1, 0]),
+        ((0.15, -0.85), [1, 0, 0]),
+        ((-0.075, -0.725), [1, 1, 0]),
+        ((0.075, -0.725), [1, 0, 0]),
+    ]
+    if isotropy <= 0.5:
+        # 0.5 -> 1
+        x_scale, y_scale = isotropy, 1
+    else:
+        x_scale, y_scale = 1, 1-isotropy
+    for (cx, cy), color in balls:
+        r = (x_scale * (x - cx) ** 2 + y_scale * (y - cy) ** 2) < radius
+        out[r, :] = color  # Set the color for each ball based on its position
+
+    return out
+
+
+@interactive(detect=(True, "Enable classification"))
+def apply_classifier(img, context={}, detect=False):
+    result = {}
+    if detect:
+        if not context.get("clf", None):
+            context["clf"] = pipeline("image-classification")
+        result = context["clf"](Image.fromarray((img*255).astype(np.uint8)))
+    else:
+        result = [{"score": 0., "label": "No classification"}]*5
+    context["result"] = result
+    # return result
+
+
+def display_result(context={}):
+    result_dict = context.get("result", [])
+    curves = [
+        SingleCurve(
+            x=[id, id, id+1, id+1],
+            y=[0, r['score'], r['score'], 0],
+            label=r["label"], style="-"
+        )
+        for id, r in enumerate(result_dict)]
+    result_curves = Curve(curves, ylim=[0, 1])
+    return result_curves
+# -------------------
+# Pipeline definition
+# -------------------
+
+
+def tutorial_pipeline():
+    inp = gen_color()
+    apply_classifier(inp)
+    result_curve = display_result()
+    return inp, result_curve

interactivity.py

@@ -0,0 +1,49 @@
+from interactive_pipe import interactive_pipeline, interactive
+from core import (gen_color, tutorial_pipeline)
+import argparse
+# --------------------------------------------------------------
+
+
+def add_interactivity() -> None:
+    # Depending on the level of control you want,
+    # you can add more or less controls to the pipeline
+    # interactive(
+    #     ratio=(0.5, [0., 1.], "Side by Side comparison")
+    # )(compare_by_splitting)
+    # interactive(
+    #     bnw=(True, "Black and White")
+    # )(change_color)
+    # interactive(
+    #     effect=("flip", ["flip", "mirror", "flip+mirror", "identity"])
+    # )(modify_geometry)
+    # interactive(
+    #     frequency=(80, [1, 100]),
+    #     isotropy=(0.8, [0.1, 1.])
+    # )(gen_color)
+    pass
+
+
+def run_interactive_pipeline(
+    backend: str = "gradio",
+    markdown_description: str = "# Tuto"
+) -> None:
+    add_interactivity()
+    playable_tutorial_pipeline = interactive_pipeline(
+        gui=backend,
+        cache=True,
+        markdown_description=markdown_description,
+        context={"initialized_param": 42}
+        # context is shared between processing blocks.
+        # Initialization allow to pre-load a neural network for example.
+    )(tutorial_pipeline)
+    playable_tutorial_pipeline()
+
+
+if __name__ == "__main__":
+    BACKEND_OPTIONS = ["gradio", "qt"]
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-b", "--backend", type=str,
+                        choices=BACKEND_OPTIONS, default=BACKEND_OPTIONS[0])
+    args = parser.parse_args()
+    run_interactive_pipeline(backend=args.backend,
+                             markdown_description="# Tutorial")

requirements.txt

@@ -0,0 +1,3 @@
+interactive-pipe>=0.7.6
+torch>=2.0.0
+transformers