Synced repo using 'sync_with_huggingface' Github Action

original:
- remote: "https://github.com/xiaoyao9184/docker-dall-e"
- commit: "817977c7edeb8eef1a5c2245179439389c278051"
sync_with_huggingface:
- repository: ""
- ref: ""

README.md

@@ -1,12 +1,16 @@
 ---
-title: Dall E
-emoji: 👁
-colorFrom: purple
-colorTo: red
+title: DALL-E
+emoji: 🖼️
+colorFrom: gray
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.9.0
+sdk_version: 4.44.1
+python_version: '3.8.20'
 app_file: app.py
 pinned: false
+license: apache-2.0
+models:
+  - xiaoyao9184/dall-e
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,50 @@
+import os
+import sys
+import git
+import subprocess
+from huggingface_hub import hf_hub_download
+
+REPO_URL = "https://github.com/openai/DALL-E.git"
+REPO_BRANCH = '5be4b236bc3ade6943662354117a0e83752cc322'
+LOCAL_PATH = "./DALL-E"
+MODEL_ID = "xiaoyao9184/dall-e"
+
+def install_src():
+    if not os.path.exists(LOCAL_PATH):
+        print(f"Cloning repository from {REPO_URL}@{REPO_BRANCH} to {LOCAL_PATH}...")
+        repo = git.Repo.clone_from(REPO_URL, LOCAL_PATH)
+        repo.git.checkout(REPO_BRANCH)
+    else:
+        print(f"Repository already exists at {LOCAL_PATH}")
+
+    requirements_path = os.path.join(LOCAL_PATH, "requirements.txt")
+    if os.path.exists(requirements_path):
+        print("Installing requirements...")
+        subprocess.check_call(["pip", "install", "-r", requirements_path])
+    else:
+        print("No requirements.txt found.")
+
+def install_model():
+    checkpoint_path = os.path.join(LOCAL_PATH)
+    print(f"Downloading model from {MODEL_ID}...")
+    hf_hub_download(repo_id=MODEL_ID, revision='master', filename='encoder.pkl', local_dir=checkpoint_path)
+    hf_hub_download(repo_id=MODEL_ID, revision='master', filename='decoder.pkl', local_dir=checkpoint_path)
+
+# clone repo and download model
+install_src()
+install_model()
+
+# fix sys.path for import
+print(f"LOCAL_PATH: {os.path.abspath(LOCAL_PATH)}")
+os.environ["APP_PATH"] = os.path.abspath(LOCAL_PATH)
+
+# run gradio in subprocess in reloaded mode
+# huggingface space issue: https://github.com/gradio-app/gradio/issues/10048
+# need disable reload for huggingface space
+import re
+import sys
+from gradio.cli import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.argv.append(re.sub(r'app\.py$', 'gradio_app.py', sys.argv[0]))
+    sys.exit(cli())

gradio_app.py

@@ -0,0 +1,198 @@
+import os
+import sys
+import git
+
+if "APP_PATH" in os.environ:
+    # fix sys.path for import
+    os.chdir(os.environ["APP_PATH"])
+    if os.getcwd() not in sys.path:
+        sys.path.append(os.getcwd())
+
+# remove duplicate gradio_app path from sys.path
+sys.path = list(dict.fromkeys(sys.path))
+
+# remove gradio reload env if in huggingface space
+if "SPACE_ID" in os.environ:
+    for key in ["GRADIO_WATCH_DIRS", "GRADIO_WATCH_MODULE_NAME", "GRADIO_WATCH_DEMO_NAME", "GRADIO_WATCH_DEMO_PATH"]:
+        if key in os.environ:
+            del os.environ[key]
+
+def get_app_git_commit():
+    app_path = os.environ.get("APP_PATH")
+    if not app_path:
+        return None
+    try:
+        repo = git.Repo(app_path, search_parent_directories=False)
+        hexsha = repo.head.commit.hexsha
+        return hexsha
+    except (git.exc.InvalidGitRepositoryError, ValueError, git.exc.GitError):
+        return None
+
+# here the subprocess stops loading, because __name__ is NOT '__main__'
+# gradio will reload
+if '__main__' == __name__:
+
+    import gradio as gr
+    from contextlib import suppress
+
+    import os
+    import torch
+    import torchvision.transforms as T
+    import torchvision.transforms.functional as TF
+    import torch.nn.functional as F
+    import json
+    from PIL import Image
+
+    from dall_e          import map_pixels, unmap_pixels, load_model
+
+    CHECKPOINT_MODEL_PATH = os.environ.get("CHECKPOINT_MODEL_PATH", './')
+
+    # Device configuration
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    enc = load_model(f"{CHECKPOINT_MODEL_PATH}/encoder.pkl", device)
+    dec = load_model(f"{CHECKPOINT_MODEL_PATH}/decoder.pkl", device)
+
+    target_image_size = 256
+    transform = T.Compose([
+        T.Resize(target_image_size, interpolation=Image.LANCZOS),
+        T.CenterCrop(target_image_size),
+        T.ToTensor(),
+    ])
+
+    def encode_image(image):
+        """
+        Encodes the given image.
+
+        Args:
+            image (Union[PIL.Image.Image, str]): Input image, can be a PIL Image object, image array, or URL.
+
+        Returns:
+            dict: A dictionary with the following fields:
+                - ``shape`` (List[int]): Spatial size of the code grid, fixed as ``[32, 32]``.
+                - ``vocab_size`` (int): Vocabulary size of the model, fixed as `8192`.
+                - ``tokens`` (List[List[int]]): Quantized image tokens on a ``32 x 32`` grid,
+                  converted from the internal one-hot representation to nested Python lists
+                  on CPU for serialization and front-end display.
+        """
+        if image is None:
+            raise gr.Error("Please upload an image before clicking the \"Encoding\" button.")
+
+        if isinstance(image, Image.Image) is False:
+            image = Image.fromarray(image)
+
+        x = transform(image).to(device)
+        x = map_pixels(x.unsqueeze(0))
+
+        z_logits = enc(x)
+        z = torch.argmax(z_logits, axis=1)
+
+        z_cpu = z.squeeze(0).cpu().numpy().tolist()
+        return {
+            "shape": [32, 32],
+            "vocab_size": enc.vocab_size,
+            "tokens": z_cpu
+        }
+
+    def decode_code(code):
+        """
+        Embeds one or more watermarks into the input image.
+
+        Args:
+            code (Union[str, dict]): Encoded image code. It can be a JSON string or a
+                Python dictionary with the same structure as the output of ``encode_image``,
+                i.e. containing at least a ``"tokens"`` field that holds the quantized
+                image tokens.
+
+        Returns:
+            image (Union[PIL.Image.Image, str]): Output image, either a PIL Image object or a URL pointing to the image.
+        """
+        if isinstance(code, str):
+            code = json.loads(code)
+
+        # code["tokens"] is expected to be a 32x32 grid of token ids
+        # match the shape used in process_image: [1, 32, 32] -> one-hot -> [1, vocab, 32, 32]
+        z = torch.tensor(code["tokens"], dtype=torch.long).unsqueeze(0).to(device)  # [1,32,32]
+        z = F.one_hot(z, num_classes=enc.vocab_size).permute(0, 3, 1, 2).float()  # [1,vocab,32,32]
+
+        x_stats = dec(z).float()
+        x_rec = unmap_pixels(torch.sigmoid(x_stats[:, :3]))
+        x_rec = T.ToPILImage(mode='RGB')(x_rec[0].cpu())
+
+        return x_rec
+
+    def process_image(image):
+        if isinstance(image, Image.Image) is False:
+            image = Image.fromarray(image)
+
+        x = transform(image).to(device)
+        x = map_pixels(x.unsqueeze(0))
+
+        z_logits = enc(x)
+        z = torch.argmax(z_logits, axis=1)
+
+
+        z = F.one_hot(z, num_classes=enc.vocab_size).permute(0, 3, 1, 2).float()
+
+        x_stats = dec(z).float()
+        x_rec = unmap_pixels(torch.sigmoid(x_stats[:, :3]))
+        x_rec = T.ToPILImage(mode='RGB')(x_rec[0].to('cpu'))
+
+        return x_rec
+
+    DALLE_VERSION = get_app_git_commit() or "unknown"
+
+    with gr.Blocks(title="DALL- Demo", css="""
+            .align-bottom {display:flex; flex-direction:column; justify-content:flex-end;}
+            """) as demo:
+        gr.Markdown(f"""
+        # DALL-E Demo
+
+        > DALL-E: [`{DALLE_VERSION}`](https://github.com/openai/DALL-E/tree/{DALLE_VERSION})
+
+        Find the original project [here](https://github.com/openai/DALL-E).
+        Or this project [here](https://github.com/xiaoyao9184/docker-dall-e).
+        See the [README](./blob/main/README.md) for Spaces's metadata.
+        """)
+
+        with gr.Tabs():
+            with gr.TabItem("Encoding -> Decoding"):
+                with gr.Row():
+                    with gr.Column():
+                        original_img = gr.Image(label="Original Image", type="numpy", height=512)
+                        process_btn = gr.Button("process")
+                    with gr.Column():
+                        reconstructed_image = gr.Image(label="Reconstructed Image")
+            with gr.TabItem("Encoding"):
+                with gr.Row():
+                    with gr.Column():
+                        encoding_img = gr.Image(label="Input Image", type="numpy", height=512)
+                        encoding_btn = gr.Button("Encoding")
+                    with gr.Column():
+                        encoding_messages = gr.JSON(label="Encoding Messages")
+            with gr.TabItem("Decoding"):
+                with gr.Row():
+                    with gr.Column():
+                        encoding_code = gr.Code(label="Encoding Code", language="json")
+                        decoding_btn = gr.Button("Decoding")
+                    with gr.Column(elem_classes="align-bottom"):
+                        decoding_image = gr.Image(label="Decoding Image")
+
+                encoding_btn.click(
+                    fn=encode_image,
+                    inputs=encoding_img,
+                    outputs=encoding_messages
+                )
+                decoding_btn.click(
+                    fn=decode_code,
+                    inputs=encoding_code,
+                    outputs=decoding_image
+                )
+                process_btn.click(
+                    fn=process_image,
+                    inputs=[original_img],
+                    outputs=[reconstructed_image],
+                    api_name=False
+                )
+
+    if __name__ == '__main__':
+        demo.launch(server_name="0.0.0.0", server_port=7860, share=True)

gradio_run.py

@@ -0,0 +1,7 @@
+# NOTE: copy from gradio bin
+import re
+import sys
+from gradio.cli import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli())

requirements.txt

@@ -0,0 +1,12 @@
+torch==1.7.1
+torchvision==0.8.2
+GitPython==3.1.43
+gradio==4.44.1
+huggingface-hub==0.28.1
+
+Pillow==9.3.0
+blobfile==3.1.0
+mypy==1.14.1
+numpy==1.24.3
+pytest==8.3.5
+requests==2.32.4