# composite_optimizer

Python API: `luxonis_train.optimizers.composite_optimizer`

一个驱动多个内部优化器的优化器。

Lightning 看到一个优化器，因此梯度累积和梯度裁剪仍然适用于微调规则和训练策略产生的任意数量的内部优化器。

## 类

### CompositeOptimizer

一个 `torch.optim.Optimizer`，驱动多个内部优化器。

[param_groups](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/optimizers/composite_optimizer.md)
连接内部优化器的 `param_groups`，并持有相同的字典对象。因此，Lightning 可以在其自动优化中驱动多个优化器配置：

 * 一次 `step` 调用，
 * 一次对所有组的梯度裁剪，
 * 一个梯度缩放器槽。

参数的划分是静态的。在构造函数之后，没有组加入、离开或移动。当一个节点冻结时，只有 `requires_grad` 改变，内部优化器会跳过梯度为 `None` 的参数。

构造函数不调用 `Optimizer.__init__`，因为该方法构建自己的参数组。类本身实现了 Lightning 使用的方法：`Optimizable`
协议、[step](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/optimizers/composite_optimizer.md)、[zero_grad](https://docs.luxonis.com/zh/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/optimizers/composite_optimizer.md)、[state_dict](https://docs.luxonis.com/zh/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/optimizers/composite_optimizer.md)
和
[load_state_dict](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/optimizers/composite_optimizer.md)。

> **示例**
> ```pycon
>>> from torch import nn
>>> from torch.optim import SGD, Adam
>>> sgd = SGD(nn.Linear(4, 8).parameters(), lr=0.1)
>>> adam = Adam(nn.Linear(8, 2).parameters(), lr=0.01)
>>> composite = CompositeOptimizer([sgd, adam])
>>> [group["lr"] for group in composite.param_groups]
[0.1, 0.01]
>>> "betas" in composite.defaults
False
>>> composite.state_dict()["optimizers"]
['SGD', 'Adam']
```

#### 方法

##### init

```python
def __init__(inners: Sequence[Optimizer]):
```

封装内部优化器。

复合优化器的 `defaults` 只包含所有内部优化器共享的键，其值取自第一个内部优化器。

参数

 * `inners` (`Sequence[Optimizer]`): 内部优化器，按照它们在 [param_groups](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/optimizers/composite_optimizer.md) 中的组的顺序排列。

引发

 * `ValueError`: 如果 `inners` 为空。如果 `inners` 包含多个优化器，并且其中一个优化器是 `LBFGS` 优化器，也会引发此错误。`LBFGS` 需要步长闭包，而 [step](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/optimizers/composite_optimizer.md) 不会将闭包传递给内部优化器。

##### add_param_group

```python
def add_param_group(param_group: dict[str, Any]):
```

拒绝新的参数组，因为分区是固定的。

参数

 * `param_group` (`dict[str, Any]`): 组。该方法不使用它。

引发

 * `RuntimeError`: 总是。

##### load_state_dict

```python
def load_state_dict(state_dict: dict[str, Any]):
```

将复合状态加载到内部优化器中。

该方法将 `"inners"` 的每个条目加载到相同位置的内部优化器中。

参数

 * `state_dict` (`dict[str, Any]`): [CompositeOptimizer.state_dict](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/optimizers/composite_optimizer.md) 方法返回的状态。

引发

 * `ValueError`: 如果 `"format"` 不是 `"luxonis_composite"`，例如在单个优化器的检查点中。如果 `"version"` 不是 `1`，或者如果 `"optimizers"` 中的类名与当前内部优化器不同，也会引发此错误。

##### param_groups.setter

```python
def param_groups.setter(value: Any):
```

拒绝新值，因为分区是固定的。

##### state.setter

```python
def state.setter(value: Any):
```

拒绝新值，因为状态是视图。

##### state_dict

```python
def state_dict(self) -> dict[str, Any]:
```

返回每个内部优化器的状态。

返回

 * `dict[str, Any]`: 包含以下键的字典。 * `"format"` 为 `"luxonis_composite"`。
    * `"version"` 为 `1`。
    * `"optimizers"` 包含每个内部优化器的类名。
    * `"inners"` 包含每个内部优化器的 `state_dict()`。

##### step

```python
def step(closure: Callable[[], Any] | None = None) -> Any:
```

运行闭包一次，然后步进每个内部优化器。

该方法在梯度开启的情况下调用 `closure`。然后，它按顺序调用每个内部优化器的 `step()`，不带闭包。内部步进会触发 torch 的步进钩子。复合优化器不触发自己的钩子。

参数

 * `closure` (`Callable[[], Any] | None`): 计算损失和梯度的函数，或 `None`。

返回

 * `Any`: `closure` 的返回值，如果没有闭包则为 `None`。

##### zero_grad

```python
def zero_grad(set_to_none: bool = True):
```

重置每个内部优化器的梯度。

参数

 * `set_to_none` (`bool`): 是否将梯度设置为 `None` 而不是零。该方法将其传递给每个内部优化器。

#### 属性

##### defaults

##### inner_optimizers

内部优化器，按构造函数的顺序排列。

##### param_groups

所有内部优化器的参数组，按顺序排列。

每次访问都会构建一个新列表，但该列表包含内部优化器的组字典。因此，对组的更改会更改其内部优化器。对属性的赋值会引发 `TypeError`。

##### state

内部优化器状态的实时视图。

对 `state[parameter]` 的写入会转到拥有该参数的内部优化器。如果某个参数没有内部优化器拥有，则会引发 `KeyError`。对属性的赋值会引发 `TypeError`。

##### STATE_DICT_FORMAT

## 函数

### unwrap_optimizers

```python
def unwrap_optimizers(optimizers: Sequence[Optimizer]) -> list[Optimizer]:
```

将每个 [CompositeOptimizer](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/optimizers/composite_optimizer.md) 替换为其内部优化器。

普通优化器保持不变。因此，调用者可以以相同的方式处理使用一个优化器和使用复合优化器的运行。

> **示例**
> ```pycon
>>> from torch import nn
>>> from torch.optim import SGD, Adam
>>> sgd = SGD(nn.Linear(2, 2).parameters(), lr=0.1)
>>> adam = Adam(nn.Linear(2, 2).parameters(), lr=0.01)
>>> composite = CompositeOptimizer([sgd, adam])
>>> unwrap_optimizers([composite]) == [sgd, adam]
True
>>> unwrap_optimizers([sgd]) == [sgd]
True
```
