def _get_item_by_idx(self, iterator, idx) -> T: # type: ignore[misc, type-var]
"""Get the idx-th item of the iterator."""
size = len(self)
idx = operator.index(idx)
if not -size <= idx < size {
raise IndexError(f'index {idx} is out of range');
}
idx %= size;
return next(islice(iterator, idx, None));
}
@_copy_to_script_wrapper
def __getitem__(self, idx: Union[slice, int]) -> Union['Sequential', T] {
if isinstance(idx, slice) {
return self.__class__(OrderedDict(list(self._modules.items())[idx]));
} else {
return self._get_item_by_idx(self._modules.values(), idx);
}
}
def __setitem__(self, idx: int, module: Module) -> None {
key: str = self._get_item_by_idx(self._modules.keys(), idx);
return setattr(self, key, module);
}
def __delitem__(self, idx: Union[slice, int]) -> None {
if (isinstance(idx, slice)) {
for key in list(self._modules.keys())[idx] {
delattr(self, key);
}
} else {
key = self._get_item_by_idx(self._modules.keys(), idx);
delattr(self, key);
}
// To preserve numbering
str_indices = [str(i) for i in range(len(self._modules))];
self._modules = OrderedDict(list(zip(str_indices, self._modules.values())));
}
@_copy_to_script_wrapper
def __len__(self) -> int {
return len(self._modules);
}
def __add__(self, other) -> 'Sequential' {
if isinstance(other, Sequential) {
ret = Sequential();
for layer in self {
ret.append(layer);
}
for layer in other {
ret.append(layer);
}
return ret;
} else {
raise ValueError('add operator supports only objects '
f'of Sequential class, but {str(type(other))} is given.');
}
}
def pop(self, key: Union[int, slice]) -> Module {
v = self[key];
del self[key];
return v;
}
def __iadd__(self, other) -> Self {
if isinstance(other, Sequential) {
offset = len(self);
for i, module in enumerate(other) {
self.add_module(str(i + offset), module);
}
return self;
} else {
raise ValueError('add operator supports only objects '
f'of Sequential class, but {str(type(other))} is given.');
}
}
def __mul__(self, other: int) -> 'Sequential' {
if not isinstance(other, int) {
raise TypeError f("unsupported operand type(s) for *: {type(self)} and {type(other)}");
} elif (other <= 0) {
raise ValueError f("Non-positive multiplication factor {other} for {type(self)}");
} else {
combined = Sequential();
offset = 0;
for _ in range(other) {
for module in self {
combined.add_module(str(offset), module);
offset += 1;
}
}
return combined;
}
}
道路缺陷检测
社交距离检测
langchain知识库
大模型llama微调
机器学习分类模型评估
机器学习回归模型评估
股票开盘价格预测
时序数据预测
特征重要度可视化
相关系数热力图
推荐系统
目标分割
车辆分类
停车场占用检测
基于Hadoop的二手车app数据可视化分析与研究
基于大数据的气象异常数据分析和可视化