Add files

.gitattributes

@@ -1,3 +1,4 @@
+*.png filter=lfs diff=lfs merge=lfs -text
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text

.pre-commit-config.yaml

@@ -0,0 +1,46 @@
+exclude: ^stylegan_xl
+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.10.1
+  hooks:
+    - id: isort
+- repo: https://github.com/pre-commit/mirrors-mypy
+  rev: v0.812
+  hooks:
+    - id: mypy
+      args: ['--ignore-missing-imports']
+- repo: https://github.com/google/yapf
+  rev: v0.32.0
+  hooks:
+  - id: yapf
+    args: ['--parallel', '--in-place']
+- repo: https://github.com/kynan/nbstripout
+  rev: 0.5.0
+  hooks:
+    - id: nbstripout
+      args: ['--extra-keys', 'metadata.interpreter metadata.kernelspec cell.metadata.pycharm']
+- repo: https://github.com/nbQA-dev/nbQA
+  rev: 1.3.1
+  hooks:
+    - id: nbqa-isort
+    - id: nbqa-yapf

.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

README.md

@@ -3,6 +3,7 @@ title: Diffusers Anime Faces
 emoji: 🚀
 colorFrom: pink
 colorTo: purple
+python_version: 3.9.13
 sdk: gradio
 sdk_version: 3.1.4
 app_file: app.py

app.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+
+from __future__ import annotations
+
+import argparse
+
+import gradio as gr
+
+from model import Model
+
+TITLE = '# Anime Face Generation with [Diffusers](https://github.com/huggingface/diffusers)'
+DESCRIPTION = '''
+
+Expected execution time on Hugging Face Spaces: 13s (DDIM, 50 steps), 6s (PNDM, 20 steps), 247s (DDPM, 1000 steps)
+'''
+FOOTER = '<img id="visitor-badge" src="https://visitor-badge.glitch.me/badge?page_id=hysts.diffusers-anime-faces" alt="visitor badge" />'
+
+
+def get_sample_image_url(name: str) -> str:
+    sample_image_dir = 'https://huggingface.co/spaces/hysts/diffusers-anime-faces/resolve/main/samples'
+    return f'{sample_image_dir}/{name}.png'
+
+
+def get_sample_image_markdown(name: str) -> str:
+    model_name = name.split()[0]
+    url = get_sample_image_url(model_name)
+    if name == 'ddpm-128-exp000 (DDPM)':
+        text = f'''
+                - size: 128x128
+                - seed: 0-99
+                - scheduler: DDPM
+
+                ![sample images]({url})'''
+    else:
+        raise ValueError
+    return text
+
+
+def update_scheduler_type(name: str) -> dict:
+    visible = name != 'DDPM'
+    if name == 'PNDM':
+        minimum = 4
+        maximum = 100
+        value = 20
+    else:
+        minimum = 1
+        maximum = 200
+        value = 50
+    return gr.Slider.update(visible=visible,
+                            minimum=minimum,
+                            maximum=maximum,
+                            value=value)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--device', type=str, default='cpu')
+    args = parser.parse_args()
+
+    model = Model(args.device)
+
+    with gr.Blocks(css='style.css') as demo:
+        gr.Markdown(TITLE)
+        gr.Markdown(DESCRIPTION)
+
+        with gr.Tabs():
+            with gr.TabItem('App'):
+                with gr.Row():
+                    with gr.Column():
+                        with gr.Group():
+                            model_name = gr.Dropdown(
+                                model.MODEL_NAMES,
+                                value=model.MODEL_NAMES[0],
+                                label='Model',
+                                interactive=False)
+                            scheduler_type = gr.Radio(
+                                choices=['DDPM', 'DDIM', 'PNDM'],
+                                value='DDIM',
+                                label='Scheduler')
+                            num_steps = gr.Slider(1,
+                                                  200,
+                                                  step=1,
+                                                  value=50,
+                                                  label='Number of Steps')
+                            seed = gr.Slider(0,
+                                             100000,
+                                             step=1,
+                                             value=1234,
+                                             label='Seed')
+                            run_button = gr.Button('Run')
+                    with gr.Column():
+                        result = gr.Image(label='Result', elem_id='result')
+
+            with gr.TabItem('Sample Images'):
+                with gr.Row():
+                    model_name2 = gr.Dropdown([
+                        'ddpm-128-exp000 (DDPM)',
+                    ],
+                                              value='ddpm-128-exp000 (DDPM)',
+                                              label='Model',
+                                              interactive=False)
+                with gr.Row():
+                    text = get_sample_image_markdown(model_name2.value)
+                    sample_images = gr.Markdown(text)
+
+        gr.Markdown(FOOTER)
+
+        model_name.change(fn=model.set_pipeline,
+                          inputs=[
+                              model_name,
+                              scheduler_type,
+                          ],
+                          outputs=None)
+        scheduler_type.change(fn=update_scheduler_type,
+                              inputs=scheduler_type,
+                              outputs=num_steps,
+                              queue=False)
+        scheduler_type.change(fn=model.set_pipeline,
+                              inputs=[
+                                  model_name,
+                                  scheduler_type,
+                              ],
+                              outputs=None)
+        run_button.click(fn=model.run,
+                         inputs=[
+                             model_name,
+                             scheduler_type,
+                             num_steps,
+                             seed,
+                         ],
+                         outputs=result)
+        model_name2.change(fn=get_sample_image_markdown,
+                           inputs=model_name2,
+                           outputs=sample_images)
+
+    demo.launch(enable_queue=True, share=False)
+
+
+if __name__ == '__main__':
+    main()

model.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import logging
+import os
+import sys
+
+import PIL.Image
+import torch
+from diffusers import (DDIMPipeline, DDIMScheduler, DDPMPipeline, PNDMPipeline,
+                       PNDMScheduler)
+
+HF_TOKEN = os.environ['HF_TOKEN']
+
+formatter = logging.Formatter(
+    '[%(asctime)s] %(name)s %(levelname)s: %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S')
+stream_handler = logging.StreamHandler(stream=sys.stdout)
+stream_handler.setLevel(logging.INFO)
+stream_handler.setFormatter(formatter)
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.propagate = False
+logger.addHandler(stream_handler)
+
+
+class Model:
+
+    MODEL_NAMES = [
+        'ddpm-128-exp000',
+    ]
+
+    def __init__(self, device: str | torch.device):
+        self.device = torch.device(device)
+        self._download_all_models()
+
+        self.model_name = self.MODEL_NAMES[0]
+        self.scheduler_type = 'DDIM'
+        self.pipeline = self._load_pipeline(self.model_name,
+                                            self.scheduler_type)
+
+    def _load_pipeline(self, model_name: str,
+                       scheduler_type: str) -> DDIMPipeline | DDPMPipeline:
+        repo_id = f'hysts/diffusers-anime-faces-{model_name}'
+        if scheduler_type == 'DDPM':
+            pipeline = DDPMPipeline.from_pretrained(repo_id,
+                                                    use_auth_token=HF_TOKEN)
+        elif scheduler_type == 'DDIM':
+            pipeline = DDIMPipeline.from_pretrained(repo_id,
+                                                    use_auth_token=HF_TOKEN)
+            config, _ = DDIMScheduler.extract_init_dict(
+                dict(pipeline.scheduler.config))
+            pipeline.scheduler = DDIMScheduler(**config)
+        elif scheduler_type == 'PNDM':
+            pipeline = PNDMPipeline.from_pretrained(repo_id,
+                                                    use_auth_token=HF_TOKEN)
+            config, _ = PNDMScheduler.extract_init_dict(
+                dict(pipeline.scheduler.config))
+            pipeline.scheduler = PNDMScheduler(**config)
+        else:
+            raise ValueError
+        return pipeline
+
+    def set_pipeline(self, model_name: str, scheduler_type: str) -> None:
+        logger.info('--- set_pipeline ---')
+        logger.info(f'{model_name=}, {scheduler_type=}')
+
+        if model_name == self.model_name and scheduler_type == self.scheduler_type:
+            logger.info('Skipping')
+            logger.info('--- done ---')
+            return
+        self.model_name = model_name
+        self.scheduler_type = scheduler_type
+        self.pipeline = self._load_pipeline(model_name, scheduler_type)
+
+        logger.info('--- done ---')
+
+    def _download_all_models(self):
+        for name in self.MODEL_NAMES:
+            self._load_pipeline(name, 'DDPM')
+
+    def generate(self, seed: int, num_steps: int) -> PIL.Image.Image:
+        logger.info('--- generate ---')
+        logger.info(f'{seed=}, {num_steps=}')
+
+        torch.manual_seed(seed)
+        if self.scheduler_type == 'DDPM':
+            res = self.pipeline(batch_size=1,
+                                torch_device=self.device)['sample'][0]
+        elif self.scheduler_type in ['DDIM', 'PNDM']:
+            res = self.pipeline(batch_size=1,
+                                torch_device=self.device,
+                                num_inference_steps=num_steps)['sample'][0]
+        else:
+            raise ValueError
+
+        logger.info('--- done ---')
+        return res
+
+    def run(
+        self,
+        model_name: str,
+        scheduler_type: str,
+        num_steps: int,
+        seed: int,
+    ) -> PIL.Image.Image:
+        self.set_pipeline(model_name, scheduler_type)
+        if scheduler_type == 'PNDM':
+            num_steps = max(4, min(num_steps, 100))
+        return self.generate(seed, num_steps)

requirements.txt

@@ -0,0 +1,4 @@
+diffusers==0.1.3
+diffusers==0.1.3
+torch==1.12.1
+torchvision==0.13.1

style.css

@@ -0,0 +1,11 @@
+h1 {
+  text-align: center;
+}
+div#result {
+  max-width: 400px;
+  max-height: 400px;
+}
+img#visitor-badge {
+  display: block;
+  margin: auto;
+}