[Utils] add utilities for checking if certain utilities are properly documented

.github/workflows/pr_test_peft_backend.yml

@@ -55,6 +55,7 @@ jobs:
         run: |
           python utils/check_copies.py
           python utils/check_dummies.py
+          python utils/check_support_list.py
           make deps_table_check_updated
       - name: Check if failure
         if: ${{ failure() }}

.github/workflows/pr_tests.yml

@@ -63,6 +63,7 @@ jobs:
         run: |
           python utils/check_copies.py
           python utils/check_dummies.py
+          python utils/check_support_list.py
           make deps_table_check_updated
       - name: Check if failure
         if: ${{ failure() }}

docs/source/en/api/attnprocessor.md

@@ -20,12 +20,21 @@ An attention processor is a class for applying different types of attention mech
 ## AttnProcessor2_0
 [[autodoc]] models.attention_processor.AttnProcessor2_0
 
+## FusedAttnProcessor2_0
+[[autodoc]] models.attention_processor.FusedAttnProcessor2_0
+
+## XFormersAttnProcessor
+[[autodoc]] models.attention_processor.XFormersAttnProcessor
+
 ## AttnAddedKVProcessor
 [[autodoc]] models.attention_processor.AttnAddedKVProcessor
 
 ## AttnAddedKVProcessor2_0
 [[autodoc]] models.attention_processor.AttnAddedKVProcessor2_0
 
+## XFormersAttnAddedKVProcessor
+[[autodoc]] models.attention_processor.XFormersAttnAddedKVProcessor
+
 ## CrossFrameAttnProcessor
 [[autodoc]] pipelines.text_to_video_synthesis.pipeline_text_to_video_zero.CrossFrameAttnProcessor
 
@@ -38,23 +47,17 @@ An attention processor is a class for applying different types of attention mech
 ## CustomDiffusionXFormersAttnProcessor
 [[autodoc]] models.attention_processor.CustomDiffusionXFormersAttnProcessor
 
-## FusedAttnProcessor2_0
-[[autodoc]] models.attention_processor.FusedAttnProcessor2_0
-
-## LoRAAttnAddedKVProcessor
-[[autodoc]] models.attention_processor.LoRAAttnAddedKVProcessor
-
-## LoRAXFormersAttnProcessor
-[[autodoc]] models.attention_processor.LoRAXFormersAttnProcessor
-
 ## SlicedAttnProcessor
 [[autodoc]] models.attention_processor.SlicedAttnProcessor
 
 ## SlicedAttnAddedKVProcessor
 [[autodoc]] models.attention_processor.SlicedAttnAddedKVProcessor
 
-## XFormersAttnProcessor
-[[autodoc]] models.attention_processor.XFormersAttnProcessor
+## IPAdapterAttnProcessor
+[[autodoc]] models.attention_processor.IPAdapterAttnProcessor
+
+## IPAdapterAttnProcessor2_0
+[[autodoc]] models.attention_processor.IPAdapterAttnProcessor2_0
 
 ## AttnProcessorNPU
 [[autodoc]] models.attention_processor.AttnProcessorNPU

docs/source/en/api/normalization.md

@@ -29,3 +29,19 @@ Customized normalization layers for supporting various models in 🤗 Diffusers.
 ## AdaGroupNorm
 
 [[autodoc]] models.normalization.AdaGroupNorm
+
+## AdaLayerNormContinuous
+
+[[autodoc]] models.normalization.AdaLayerNormContinuous
+
+## LayerNorm
+
+[[autodoc]] models.normalization.LayerNorm
+
+## RMSNorm
+
+[[autodoc]] models.normalization.RMSNorm
+
+## GlobalResponseNorm
+
+[[autodoc]] models.normalization.GlobalResponseNorm

src/diffusers/models/normalization.py

@@ -151,6 +151,18 @@ def forward(self, x: torch.Tensor, emb: torch.Tensor) -> torch.Tensor:
 
 
 class AdaLayerNormContinuous(nn.Module):
+    r"""
+    Adaptive normalization layer with a norm layer (layer_norm or rms_norm).
+
+    Args:
+        embedding_dim (`int`): Embedding dimension to use during projection.
+        conditioning_embedding_dim (`int`): Dimension of the input condition.
+        elementwise_affine (`bool`): Boolean flag to denote if affine transformation should be applied.
+        eps (`int`): Epsilon factor.
+        bias (`bias`): Boolean flag to denote if bias should be use.
+        norm_type (`str`): Normalization layer to use. Values supported: "layer_norm", "rms_norm".
+    """
+
     def __init__(
         self,
         embedding_dim: int,
@@ -188,6 +200,16 @@ def forward(self, x: torch.Tensor, conditioning_embedding: torch.Tensor) -> torc
     # Has optional bias parameter compared to torch layer norm
     # TODO: replace with torch layernorm once min required torch version >= 2.1
     class LayerNorm(nn.Module):
+        r"""
+        LayerNorm with the bias parameter.
+
+        Args:
+            dim (`int`): Dimensionality to use for the parameters.
+            eps (`int`): Epsilon factor.
+            elementwise_affine (`bool`): Boolean flag to denote if affine transformation should be applied.
+            bias (`bias`): Boolean flag to denote if bias should be use.
+        """
+
         def __init__(self, dim, eps: float = 1e-5, elementwise_affine: bool = True, bias: bool = True):
             super().__init__()
 
@@ -210,6 +232,15 @@ def forward(self, input):
 
 
 class RMSNorm(nn.Module):
+    r"""
+    RMS Norm as introduced in https://arxiv.org/abs/1910.07467 by Zhang et al.
+
+    Args:
+        dim (`int`): Number of dimensions to use for `weights`. Only effective when `elementwise_affine` is True.
+        eps (`float`): Small value to use when calculating the reciprocal of the square-root.
+        elementwise_affine (`bool`): Boolean flag to denote if affine transformation should be applied.
+    """
+
     def __init__(self, dim, eps: float, elementwise_affine: bool = True):
         super().__init__()
 
@@ -242,6 +273,13 @@ def forward(self, hidden_states):
 
 
 class GlobalResponseNorm(nn.Module):
+    r"""
+    Global response normalization as introduced in ConvNeXt-v2 (https://arxiv.org/abs/2301.00808).
+
+    Args:
+        dim (`int`): Number of dimensions to use for the `gamma` and `beta`.
+    """
+
     # Taken from https://github.com/facebookresearch/ConvNeXt-V2/blob/3608f67cc1dae164790c5d0aead7bf2d73d9719b/models/utils.py#L105
     def __init__(self, dim):
         super().__init__()

utils/check_support_list.py

@@ -0,0 +1,106 @@
+# coding=utf-8
+# Copyright 2024 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Utility that checks that modules like attention processors are listed in the documentation file.
+
+```bash
+python utils/check_support_list.py
+```
+
+It has no auto-fix mode.
+"""
+import os
+import re
+
+
+# All paths are set with the intent you should run this script from the root of the repo with the command
+# python utils/check_doctest_list.py
+REPO_PATH = "."
+
+
+def check_attention_processors():
+    with open(os.path.join(REPO_PATH, "docs/source/en/api/attnprocessor.md"), "r") as f:
+        doctext = f.read()
+        matches = re.findall(r"\[\[autodoc\]\]\s([^\n]+)", doctext)
+        documented_attention_processors = [match.split(".")[-1] for match in matches]
+
+    with open(os.path.join(REPO_PATH, "src/diffusers/models/attention_processor.py"), "r") as f:
+        doctext = f.read()
+        processor_classes = re.findall(r"class\s+(\w+Processor(?:\d*_?\d*))[(:]", doctext)
+        processor_classes = [proc for proc in processor_classes if "LoRA" not in proc and proc != "Attention"]
+
+    for processor in processor_classes:
+        if processor not in documented_attention_processors:
+            raise ValueError(
+                f"{processor} should be in listed in the attention processor documentation but is not. Please update the documentation."
+            )
+
+
+def check_image_processors():
+    with open(os.path.join(REPO_PATH, "docs/source/en/api/image_processor.md"), "r") as f:
+        doctext = f.read()
+        matches = re.findall(r"\[\[autodoc\]\]\s([^\n]+)", doctext)
+        documented_image_processors = [match.split(".")[-1] for match in matches]
+
+    with open(os.path.join(REPO_PATH, "src/diffusers/image_processor.py"), "r") as f:
+        doctext = f.read()
+        processor_classes = re.findall(r"class\s+(\w+Processor(?:\d*_?\d*))[(:]", doctext)
+
+    for processor in processor_classes:
+        if processor not in documented_image_processors:
+            raise ValueError(
+                f"{processor} should be in listed in the image processor documentation but is not. Please update the documentation."
+            )
+
+
+def check_activations():
+    with open(os.path.join(REPO_PATH, "docs/source/en/api/activations.md"), "r") as f:
+        doctext = f.read()
+        matches = re.findall(r"\[\[autodoc\]\]\s([^\n]+)", doctext)
+        documented_activations = [match.split(".")[-1] for match in matches]
+
+    with open(os.path.join(REPO_PATH, "src/diffusers/models/activations.py"), "r") as f:
+        doctext = f.read()
+        activation_classes = re.findall(r"class\s+(\w+)\s*\(.*?nn\.Module.*?\):", doctext)
+
+    for activation in activation_classes:
+        if activation not in documented_activations:
+            raise ValueError(
+                f"{activation} should be in listed in the activations documentation but is not. Please update the documentation."
+            )
+
+
+def check_normalizations():
+    with open(os.path.join(REPO_PATH, "docs/source/en/api/normalization.md"), "r") as f:
+        doctext = f.read()
+        matches = re.findall(r"\[\[autodoc\]\]\s([^\n]+)", doctext)
+        documented_normalizations = [match.split(".")[-1] for match in matches]
+
+    with open(os.path.join(REPO_PATH, "src/diffusers/models/normalization.py"), "r") as f:
+        doctext = f.read()
+        normalization_classes = re.findall(r"class\s+(\w+)\s*\(.*?nn\.Module.*?\):", doctext)
+
+    for norm in normalization_classes:
+        if norm not in documented_normalizations:
+            raise ValueError(
+                f"{norm} should be in listed in the normalizations documentation but is not. Please update the documentation."
+            )
+
+
+if __name__ == "__main__":
+    check_attention_processors()
+    check_image_processors()
+    check_activations()
+    check_normalizations()