functional.partial

Python 内置的 functools.partial 类的实现。这个类可以用来创建一个新的函数对象，该对象是对一个原有函数的参数进行了部分应用后得到的。
这个类的 slots 属性指定了该类的实例可以拥有的属性，包括 func、args、keywords、 dict 和 weakref。其中，func 属性表示被部分应用的原有函数，args 属性表示被部分应用的参数（作为元组），keywords 属性表示被部分应用的关键字参数（作为字典）。 dict 和 weakref 属性是 Python 对象所具有的一些默认属性。

这个类的 new() 方法用于创建新的对象，它接受一个原有函数 func 和一些参数和关键字参数，返回一个新的部分应用后的函数对象。

这个类的 call() 方法用于调用被部分应用后的函数，接受一些新的参数和关键字参数，将它们与之前的部分应用参数合并后调用原有函数。

这个类的 repr() 方法用于返回一个对象的字符串表示形式，它将对象的类名、被部分应用的函数、部分应用的参数和关键字参数拼接起来作为字符串返回。

这个类的 reduce() 方法和 setstate() 方法用于将一个对象序列化为字节流并恢复成对象。

slots

__slots__是 Python 中的一个特殊属性，它可以用于限制一个类的实例能够拥有的属性（或者说实例属性的名称）。在定义一个类时，Python 会自动为该类的每个实例分配一个字典来存储实例的属性。这个字典可以无限制地添加任意的属性，这在某些情况下可能会导致不必要的内存开销和运行速度的下降。而 slots 属性可以用来控制实例可以拥有的属性名称，从而限制了实例属性的数量和名称。这样可以节省内存，提高运行速度。
下面是一个使用 slots 的例子，其中 partial 类只允许具有 func、args、keywords, _dict_, _weakref_ 这三个属性的实例.

需要注意的是，使用 slots 后会禁用 Python 的一些特性，例如动态添加属性和使用 _dict_ 属性。因此，只有在对内存使用和性能有非常高要求的情况下才需要使用它。

__new__中的cls, /是什么意思？

cls is a conventional name for the class object that is passed to the new method when it is called to create a new instance of a class. It is used here to reference the partial class object.

The / syntax in the argument list indicates that all arguments before it must be passed positionally (without using keywords). In this case, func must be passed positionally, while args and keywords can be passed either positionally or using keywords.
cls是类对象的常规名称，当调用__new__方法创建类的新实例时，该类对象被传递给__new__方法。这里使用它来引用partial类对象。

参数列表中的 / 语法表示它之前的所有参数必须按位置传递(不使用关键字)。在这种情况下，func必须按位置传递，而args和关键字可以按位置传递，也可以使用关键字传递。

################################################################################
### partial() argument application
################################################################################

# Purely functional, no descriptor behaviour
class partial:
    """New function with partial application of the given arguments
    and keywords.
    """
    __slots__ = "func", "args", "keywords", "__dict__", "__weakref__"
    def __new__(cls, func, /, *args, **keywords):
        if not callable(func):
            raise TypeError("the first argument must be callable")

        if hasattr(func, "func"):
            args = func.args + args
            keywords = {**func.keywords, **keywords}
            func = func.func

        self = super(partial, cls).__new__(cls)

        self.func = func
        self.args = args
        self.keywords = keywords
        return self

    def __call__(self, /, *args, **keywords):
        keywords = {**self.keywords, **keywords}
        return self.func(*self.args, *args, **keywords)

    @recursive_repr()
    def __repr__(self):
        qualname = type(self).__qualname__
        args = [repr(self.func)]
        args.extend(repr(x) for x in self.args)
        args.extend(f"{k}={v!r}" for (k, v) in self.keywords.items())
        if type(self).__module__ == "functools":
            return f"functools.{qualname}({', '.join(args)})"
        return f"{qualname}({', '.join(args)})"

    def __reduce__(self):
        return type(self), (self.func,), (self.func, self.args,
               self.keywords or None, self.__dict__ or None)

    def __setstate__(self, state):
        if not isinstance(state, tuple):
            raise TypeError("argument to __setstate__ must be a tuple")
        if len(state) != 4:
            raise TypeError(f"expected 4 items in state, got {len(state)}")
        func, args, kwds, namespace = state
        if (not callable(func) or not isinstance(args, tuple) or
           (kwds is not None and not isinstance(kwds, dict)) or
           (namespace is not None and not isinstance(namespace, dict))):
            raise TypeError("invalid partial state")

        args = tuple(args) # just in case it's a subclass
        if kwds is None:
            kwds = {}
        elif type(kwds) is not dict: # XXX does it need to be *exactly* dict?
            kwds = dict(kwds)
        if namespace is None:
            namespace = {}

        self.__dict__ = namespace
        self.func = func
        self.args = args
        self.keywords = kwds

try:
    from _functools import partial
except ImportError:
    pass

functools.partial

在Python中，使用类functools.partial创建一个可调用的部分函数对象，该对象包含了一个原始函数和其部分参数。

在你的代码中，compute_losses变量被赋值为一个部分函数对象，其中self.diffusion.training_losses是原始函数，self.ddp_model、micro、t是该函数的部分参数，model_kwargs=micro_cond是该函数的关键字参数。

在调用compute_losses时，该部分函数对象会自动传递部分参数和关键字参数给原始函数，从而实现部分调用的功能。具体来说，它会调用self.diffusion.training_losses函数，并传递部分参数self.ddp_model、micro、t和关键字参数model_kwargs=micro_cond，然后返回结果。

在functools.partial类的实现中，它重载了__new__方法和__call__方法，用于创建部分函数对象和调用原始函数。其中，__new__方法创建一个新的部分函数对象，并存储原始函数和部分参数；__call__方法实际上调用了原始函数，传递了部分参数和关键字参数，并返回结果。

这个partial类有什么作用

functools.partial是Python标准库functools模块中提供的一个函数，它的作用是创建一个部分函数对象，这个对象可以用来包装一个函数，指定部分参数，从而将其转换为另一个函数。

部分函数通常用于简化函数的调用方式，特别是在需要反复调用同一个函数，但只有部分参数不同的情况下。通过使用functools.partial，我们可以把这些共同的部分提取出来，创建一个新的部分函数，然后只需要传递不同的部分参数即可。

举个例子，假设有一个函数add(x, y, z)，我们想固定其中的两个参数x和y，然后再传递一个不同的参数z进行多次调用。我们可以使用functools.partial来创建一个部分函数对象：

import functools

def add(x, y, z):
    return x + y + z

add_1_2 = functools.partial(add, 1, 2)
# 等价于：def add_1_2(z): return add(1, 2, z)

print(add_1_2(3)) # 输出：6
print(add_1_2(4)) # 输出：7

在上面的代码中，我们使用functools.partial创建了一个名为add_1_2的部分函数对象，它绑定了add函数和部分参数1和2。这样，当我们调用add_1_2时，实际上是调用了add(1, 2, z)，其中z为传递进来的参数。

总之，functools.partial是一个非常方便的工具，它可以帮助我们简化函数调用的方式，并提高代码的可读性和可维护性。

类中没有__init__函数

如果在Python的class中没有定义__init__函数，那么Python会在实例化对象时自动调用默认的构造函数__init__，该函数不会执行任何操作，也不会接受任何参数。

但是如果你需要进行实例化初始化的操作，你可以定义其他函数（如__new__或__call__），或者重载__init__函数的父类object中的__init__方法，来进行初始化操作。

例如，你可以在类中定义__new__方法来进行实例化初始化操作：

class MyClass:
    def __new__(cls, *args, **kwargs):
        # 实例化初始化操作
        instance = super().__new__(cls)
        # 进行其他初始化操作
        return instance

或者你可以在类中重载__init__方法，如下所示：

class MyClass:
    def __init__(self):
        # 实例化初始化操作
        pass