Add files

.gitignore

@@ -0,0 +1,164 @@
+gradio_cached_examples/
+shap_e_model_cache/
+corgi.png
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

.pre-commit-config.yaml

@@ -0,0 +1,36 @@
+repos:
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v4.2.0
+  hooks:
+  - id: check-executables-have-shebangs
+  - id: check-json
+  - id: check-merge-conflict
+  - id: check-shebang-scripts-are-executable
+  - id: check-toml
+  - id: check-yaml
+  - id: double-quote-string-fixer
+  - id: end-of-file-fixer
+  - id: mixed-line-ending
+    args: ['--fix=lf']
+  - id: requirements-txt-fixer
+  - id: trailing-whitespace
+- repo: https://github.com/myint/docformatter
+  rev: v1.4
+  hooks:
+  - id: docformatter
+    args: ['--in-place']
+- repo: https://github.com/pycqa/isort
+  rev: 5.12.0
+  hooks:
+    - id: isort
+- repo: https://github.com/pre-commit/mirrors-mypy
+  rev: v0.991
+  hooks:
+    - id: mypy
+      args: ['--ignore-missing-imports']
+      additional_dependencies: ['types-python-slugify']
+- repo: https://github.com/google/yapf
+  rev: v0.32.0
+  hooks:
+  - id: yapf
+    args: ['--parallel', '--in-place']

.style.yapf

@@ -0,0 +1,5 @@
+[style]
+based_on_style = pep8
+blank_line_before_nested_class_or_def = false
+spaces_before_comment = 2
+split_before_logical_operator = true

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 hysts
+
+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 whom the Software is
+furnished 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.

LICENSE.Shap-E

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 OpenAI
+
+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 whom the Software is
+furnished 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.

README.md

@@ -1,12 +1,14 @@
 ---
-title: Shap E
+title: Shap-E
 emoji: 📉
 colorFrom: yellow
 colorTo: blue
 sdk: gradio
 sdk_version: 3.28.2
+python_version: 3.10.11
 app_file: app.py
 pinned: false
+license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+
+import os
+
+import gradio as gr
+import torch
+
+from app_image_to_3d import create_demo as create_demo_image_to_3d
+from app_text_to_3d import create_demo as create_demo_text_to_3d
+from model import Model
+
+DESCRIPTION = '# [Shap-E](https://github.com/openai/shap-e)'
+
+if (SPACE_ID := os.getenv('SPACE_ID')) is not None:
+    DESCRIPTION += f'\n<p>For faster inference without waiting in queue, you may duplicate the space and upgrade to GPU in settings. <a href="https://huggingface.co/spaces/{SPACE_ID}?duplicate=true"><img style="display: inline; margin-top: 0em; margin-bottom: 0em" src="https://bit.ly/3gLdBN6" alt="Duplicate Space" /></a></p>'
+if not torch.cuda.is_available():
+    DESCRIPTION += '\n<p>Running on CPU 🥶 This demo does not work on CPU.</p>'
+
+model = Model()
+
+with gr.Blocks(css='style.css') as demo:
+    gr.Markdown(DESCRIPTION)
+    with gr.Tabs():
+        with gr.Tab(label='Text to 3D'):
+            create_demo_text_to_3d(model)
+        with gr.Tab(label='Image to 3D'):
+            create_demo_image_to_3d(model)
+demo.queue(api_open=False, max_size=5).launch()

app_image_to_3d.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+
+import shlex
+import subprocess
+
+import gradio as gr
+
+from model import Model
+from settings import CACHE_EXAMPLES, MAX_SEED
+from utils import randomize_seed_fn
+
+
+def create_demo(model: Model) -> gr.Blocks:
+    subprocess.run(
+        shlex.split(
+            'wget https://raw.githubusercontent.com/openai/shap-e/d99cedaea18e0989e340163dbaeb4b109fa9e8ec/shap_e/examples/example_data/corgi.png -O corgi.png'
+        ))
+    examples = ['corgi.png']
+
+    def process_example_fn(image_path: str) -> str:
+        return model.run_image(image_path, output_image_size=128)
+
+    with gr.Blocks() as demo:
+        with gr.Box():
+            image = gr.Image(label='Input image',
+                             show_label=False,
+                             type='filepath')
+            run_button = gr.Button('Run')
+            result = gr.Video(label='Result', elem_id='result-2')
+            with gr.Accordion('Advanced options', open=False):
+                seed = gr.Slider(label='Seed',
+                                 minimum=0,
+                                 maximum=MAX_SEED,
+                                 step=1,
+                                 value=0)
+                randomize_seed = gr.Checkbox(label='Randomize seed',
+                                             value=True)
+                guidance_scale = gr.Slider(label='Guidance scale',
+                                           minimum=1,
+                                           maximum=20,
+                                           step=0.1,
+                                           value=3.0)
+                num_inference_steps = gr.Slider(
+                    label='Number of inference steps',
+                    minimum=1,
+                    maximum=100,
+                    step=1,
+                    value=64)
+                image_size = gr.Slider(label='Image size',
+                                       minimum=64,
+                                       maximum=256,
+                                       step=64,
+                                       value=128)
+                render_mode = gr.Dropdown(label='Render mode',
+                                          choices=['nerf', 'stf'],
+                                          value='nerf',
+                                          visible=False)
+
+        gr.Examples(examples=examples,
+                    inputs=image,
+                    outputs=result,
+                    fn=process_example_fn,
+                    cache_examples=CACHE_EXAMPLES)
+
+        inputs = [
+            image,
+            seed,
+            guidance_scale,
+            num_inference_steps,
+            image_size,
+            render_mode,
+        ]
+
+        run_button.click(
+            fn=randomize_seed_fn,
+            inputs=[seed, randomize_seed],
+            outputs=seed,
+            queue=False,
+        ).then(
+            fn=model.run_image,
+            inputs=inputs,
+            outputs=result,
+        )
+    return demo

app_text_to_3d.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+
+import gradio as gr
+
+from model import Model
+from settings import CACHE_EXAMPLES, MAX_SEED
+from utils import randomize_seed_fn
+
+
+def create_demo(model: Model) -> gr.Blocks:
+    examples = [
+        'A chair that looks like an avocado',
+        'An airplane that looks like a banana',
+        'A spaceship',
+        'A birthday cupcake',
+        'A chair that looks like a tree',
+        'A green boot',
+        'A penguin',
+        'Ube ice cream cone',
+        'A bowl of vegetables',
+    ]
+
+    def process_example_fn(prompt: str) -> str:
+        return model.run_text(prompt, output_image_size=128)
+
+    with gr.Blocks() as demo:
+        with gr.Box():
+            with gr.Row(elem_id='prompt-container'):
+                prompt = gr.Text(
+                    label='Prompt',
+                    show_label=False,
+                    max_lines=1,
+                    placeholder='Enter your prompt').style(container=False)
+                run_button = gr.Button('Run').style(full_width=False)
+            result = gr.Video(label='Result', elem_id='result-1')
+            with gr.Accordion('Advanced options', open=False):
+                seed = gr.Slider(label='Seed',
+                                 minimum=0,
+                                 maximum=MAX_SEED,
+                                 step=1,
+                                 value=0)
+                randomize_seed = gr.Checkbox(label='Randomize seed',
+                                             value=True)
+                guidance_scale = gr.Slider(label='Guidance scale',
+                                           minimum=1,
+                                           maximum=20,
+                                           step=0.1,
+                                           value=15.0)
+                num_inference_steps = gr.Slider(
+                    label='Number of inference steps',
+                    minimum=1,
+                    maximum=100,
+                    step=1,
+                    value=64)
+                image_size = gr.Slider(label='Image size',
+                                       minimum=64,
+                                       maximum=256,
+                                       step=64,
+                                       value=128)
+                render_mode = gr.Dropdown(label='Render mode',
+                                          choices=['nerf', 'stf'],
+                                          value='nerf',
+                                          visible=False)
+
+        gr.Examples(examples=examples,
+                    inputs=prompt,
+                    outputs=result,
+                    fn=process_example_fn,
+                    cache_examples=CACHE_EXAMPLES)
+
+        inputs = [
+            prompt,
+            seed,
+            guidance_scale,
+            num_inference_steps,
+            image_size,
+            render_mode,
+        ]
+        prompt.submit(
+            fn=randomize_seed_fn,
+            inputs=[seed, randomize_seed],
+            outputs=seed,
+            queue=False,
+        ).then(
+            fn=model.run_text,
+            inputs=inputs,
+            outputs=result,
+        )
+
+        run_button.click(
+            fn=randomize_seed_fn,
+            inputs=[seed, randomize_seed],
+            outputs=seed,
+            queue=False,
+        ).then(
+            fn=model.run_text,
+            inputs=inputs,
+            outputs=result,
+        )
+    return demo

model.py

@@ -0,0 +1,162 @@
+import tempfile
+
+import imageio
+import numpy as np
+import PIL.Image
+import torch
+from shap_e.diffusion.gaussian_diffusion import diffusion_from_config
+from shap_e.diffusion.sample import sample_latents
+from shap_e.models.download import load_config, load_model
+from shap_e.models.nn.camera import (DifferentiableCameraBatch,
+                                     DifferentiableProjectiveCamera)
+from shap_e.models.transmitter.base import Transmitter, VectorDecoder
+from shap_e.util.collections import AttrDict
+from shap_e.util.image_util import load_image
+
+
+# Copied from https://github.com/openai/shap-e/blob/d99cedaea18e0989e340163dbaeb4b109fa9e8ec/shap_e/util/notebooks.py#L15-L42
+def create_pan_cameras(size: int,
+                       device: torch.device) -> DifferentiableCameraBatch:
+    origins = []
+    xs = []
+    ys = []
+    zs = []
+    for theta in np.linspace(0, 2 * np.pi, num=20):
+        z = np.array([np.sin(theta), np.cos(theta), -0.5])
+        z /= np.sqrt(np.sum(z**2))
+        origin = -z * 4
+        x = np.array([np.cos(theta), -np.sin(theta), 0.0])
+        y = np.cross(z, x)
+        origins.append(origin)
+        xs.append(x)
+        ys.append(y)
+        zs.append(z)
+    return DifferentiableCameraBatch(
+        shape=(1, len(xs)),
+        flat_camera=DifferentiableProjectiveCamera(
+            origin=torch.from_numpy(np.stack(origins,
+                                             axis=0)).float().to(device),
+            x=torch.from_numpy(np.stack(xs, axis=0)).float().to(device),
+            y=torch.from_numpy(np.stack(ys, axis=0)).float().to(device),
+            z=torch.from_numpy(np.stack(zs, axis=0)).float().to(device),
+            width=size,
+            height=size,
+            x_fov=0.7,
+            y_fov=0.7,
+        ),
+    )
+
+
+# Copied from https://github.com/openai/shap-e/blob/d99cedaea18e0989e340163dbaeb4b109fa9e8ec/shap_e/util/notebooks.py#L45-L60
+@torch.no_grad()
+def decode_latent_images(
+    xm: Transmitter | VectorDecoder,
+    latent: torch.Tensor,
+    cameras: DifferentiableCameraBatch,
+    rendering_mode: str = 'stf',
+):
+    decoded = xm.renderer.render_views(
+        AttrDict(cameras=cameras),
+        params=(xm.encoder if isinstance(xm, Transmitter) else
+                xm).bottleneck_to_params(latent[None]),
+        options=AttrDict(rendering_mode=rendering_mode,
+                         render_with_direction=False),
+    )
+    arr = decoded.channels.clamp(0, 255).to(torch.uint8)[0].cpu().numpy()
+    return [PIL.Image.fromarray(x) for x in arr]
+
+
+class Model:
+    def __init__(self):
+        self.device = torch.device(
+            'cuda' if torch.cuda.is_available() else 'cpu')
+        self.xm = load_model('transmitter', device=self.device)
+        self.diffusion = diffusion_from_config(load_config('diffusion'))
+        self.model_name = ''
+        self.model = None
+
+    def load_model(self, model_name: str) -> None:
+        assert model_name in ['text300M', 'image300M']
+        if model_name == self.model_name:
+            return
+        self.model = load_model(model_name, device=self.device)
+        self.model_name = model_name
+
+    @staticmethod
+    def to_video(frames: list[PIL.Image.Image], fps: int = 5) -> str:
+        out_file = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
+        writer = imageio.get_writer(out_file.name, format='FFMPEG', fps=fps)
+        for frame in frames:
+            writer.append_data(np.asarray(frame))
+        writer.close()
+        return out_file.name
+
+    def run_text(self,
+                 prompt: str,
+                 seed: int = 0,
+                 guidance_scale: float = 15.0,
+                 num_steps: int = 64,
+                 output_image_size: int = 64,
+                 render_mode: str = 'nerf') -> str:
+        self.load_model('text300M')
+
+        torch.manual_seed(seed)
+
+        latents = sample_latents(
+            batch_size=1,
+            model=self.model,
+            diffusion=self.diffusion,
+            guidance_scale=guidance_scale,
+            model_kwargs=dict(texts=[prompt]),
+            progress=True,
+            clip_denoised=True,
+            use_fp16=True,
+            use_karras=True,
+            karras_steps=num_steps,
+            sigma_min=1e-3,
+            sigma_max=160,
+            s_churn=0,
+        )
+
+        cameras = create_pan_cameras(output_image_size, self.device)
+        frames = decode_latent_images(self.xm,
+                                      latents[0],
+                                      cameras,
+                                      rendering_mode=render_mode)
+        return self.to_video(frames)
+
+    def run_image(self,
+                  image_path: str,
+                  seed: int = 0,
+                  guidance_scale: float = 3.0,
+                  num_steps: int = 64,
+                  output_image_size: int = 64,
+                  render_mode: str = 'nerf') -> str:
+        self.load_model('image300M')
+
+        torch.manual_seed(seed)
+
+        image = load_image(image_path)
+
+        latents = sample_latents(
+            batch_size=1,
+            model=self.model,
+            diffusion=self.diffusion,
+            guidance_scale=guidance_scale,
+            model_kwargs=dict(images=[image]),
+            progress=True,
+            clip_denoised=True,
+            use_fp16=True,
+            use_karras=True,
+            karras_steps=num_steps,
+            sigma_min=1e-3,
+            sigma_max=160,
+            s_churn=0,
+        )
+
+        cameras = create_pan_cameras(output_image_size, self.device)
+        frames = decode_latent_images(self.xm,
+                                      latents[0],
+                                      cameras,
+                                      rendering_mode=render_mode)
+        return self.to_video(frames)

requirements.txt

@@ -0,0 +1,6 @@
+blobfile==2.0.2
+git+https://github.com/openai/shap-e@d99ceda
+gradio==3.28.2
+imageio[ffmpeg]==2.28.1
+torch==2.0.0
+torchvision==0.15.1

settings.py

@@ -0,0 +1,7 @@
+import os
+
+import numpy as np
+
+CACHE_EXAMPLES = os.getenv('CACHE_EXAMPLES') == '1'
+
+MAX_SEED = np.iinfo(np.int32).max

style.css

@@ -0,0 +1,21 @@
+h1 {
+  text-align: center;
+}
+
+#component-0 {
+  max-width: 730px;
+  margin: auto;
+  padding-top: 1.5rem;
+}
+
+#result-1 video {
+  object-fit: scale-down;
+}
+
+#result-2 video {
+  object-fit: scale-down;
+}
+
+#prompt-container {
+  gap: 0;
+}

utils.py

@@ -0,0 +1,9 @@
+import random
+
+from settings import MAX_SEED
+
+
+def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+    return seed