# mypy: 允许未类型化定义
from 未来
导入
注释
导入
集合
导入
复制
导入 functools
导入 io
导入
线程
导入
警告
from 打字
导入
任何,
角色,
可选 as
可选,
类型检查,
类型变量,
联合
from typing_extensions 导入
自身
导入
火炬
from torch._utils 导入 _to,
_类型
from torch 的类型
导入
_布尔,
内部,
存储
如果
类型检查:
from torch._prims_common 导入 DeviceLikeType
全部 = [
"类型存储",
"无类型存储"]
尝试:
导入 numpy as np
HAS_NUMPY = 真实
除了
模块未找到错误:
HAS_NUMPY = 假
np = 无
# 类型：忽略[赋值]
_share_memory_lock = 线程.
锁()
_share_memory_map: 字典[int,
线程.RLock] = {}
T = 类型变量(
T,
绑定=
Union[_StorageBase, TypedStorage])
类 _StorageBase:
_cdata: 任何
is_sparse: _bool = 假
is_sparse_csr: _bool = 假
设备:
火炬.
设备
# 用于
# (1) 将 FakeTensor 设备存储到 torch.serialization.skip_data 中
将设备存入存储以在 FakeTensorMode 下 torch.load 时传播到 FakeTensor
_假设备:
可选[
火炬.
设备] =
无
在使用 FakeTensorMode 加载时使用，以提供 torch.saved-file 中存储的偏移信息
_检查点偏移:
可选[int] =
无
定义 __init__(self, *
参数, **
关键字参数):
通过
定义 __len__(self) ->
内部翻译:
抛出 NotImplementedError
定义 __getitem__(self,
索引):
抛出 NotImplementedError
定义 __setitem__(self, *
参数, **
关键字参数):
抛出 NotImplementedError
定义
复制_(self,
源: T,
非阻塞:
可选[
布尔] =
无) -> T:
抛出
未实现异常
定义
新(self) ->
联合[_StorageBase,
类型化存储
]
抛出
未实现异常
定义
字节数(self) ->
整数:
抛出
未实现异常
定义
尺寸(self) ->
整数:
返回 self.
字节数()
定义
类型(
self, 数据类型:
可选[str] =
无,
非阻塞: _bool =
假
) -> 联合[_StorageBase,
类型化存储
]
返回 _type(self,
数据类型,
非阻塞)
定义 cuda(
self, 设备=
无,
非阻塞=
假
) -> 联合[_StorageBase,
类型化存储
]
返回此对象在 CUDA 内存中的副本。
如果此对象已在 CUDA 内存中且位于正确的设备上，则
不执行复制，并返回原始对象。
参数：
设备（int）：目标 GPU ID。默认为当前设备。
non_blocking (布尔值): 如果为 ``True`` 且源数据位于固定内存中，
那么复制操作将与主机异步。否则，
该参数将没有效果。
"""
device2 = 火炬.
设备(
cuda,
设备)
如果
设备
否则
火炬.
设备(
cuda)
返回 self.
到(
设备=device2,
非阻塞=
非阻塞)
定义
硬件加速处理器(self,
设备=
无,
非阻塞=False) ->
联合[_StorageBase,
类型化存储
]
返回此对象在 HPU 内存中的副本。
如果此对象已在 HPU 内存中且位于正确的设备上，则
不执行复制，直接返回原始对象。
参数：
设备（int）：目标 HPU ID。默认为当前设备。
non_blocking (布尔值): 如果为 ``True`` 且源数据位于固定内存中，
那么复制操作将与主机异步。否则，
该参数将没有效果。
"""
device2 = 火炬.
设备(
hpu,
设备)
如果
设备
否则
火炬.
设备(
hpu)
返回 self.
到(
设备=device2,
非阻塞=
非阻塞)
定义
元素大小(self) ->
内部翻译:
抛出
未实现异常
定义 get_device(self) -> _int:
返回 self.
设备.
索引
定义
数据指针(self) ->
内部翻译:
抛出
未实现异常
定义
可调整大小的(self) ->
布尔值:
抛出
未实现异常
定义在 torch/csrc/generic/StorageSharing.cpp 中
定义 _share_filename_cpu_(self, *
参数, **
关键字参数):
抛出
不支持异常
定义 _share_fd_cpu_(self, *
参数, **
关键字参数):
抛出
不支持异常
@classmethod
定义 _new_using_filename_cpu(cls,
尺寸:
内联) ->
自身:
抛出
未实现异常
@classmethod
定义 _new_using_fd_cpu(cls,
尺寸:
内联) ->
自身:
抛出
不支持的操作异常
@classmethod
定义 from_buffer(cls, *
参数, **
关键字参数) ->
自身:
抛出
不支持异常
@classmethod
定义 _new_shared_filename_cpu(
cls,
经理,
对象,
尺寸,
*,
设备=
无,
数据类型=
无,
) -> 自身:
抛出
未实现异常
@classmethod
定义
_发布 ipc 计数器_cuda(cls, *
参数, **
关键字参数) ->
自身:
抛出
未实现异常
@classmethod
定义 _new_with_weak_ptr(cls, *
参数, **
关键字参数) ->
自身:
抛出
不支持异常
定义
_共享解引用(self) ->
联合[_StorageBase,
类型化存储
]
抛出
不支持异常
定义
_写入文件(self, *
参数, **
关键字参数):
抛出
不支持异常
定义
调整大小(self,
尺寸:
_整型):
抛出
未实现异常
定义
弱引用(self, *
参数, **
关键字参数) ->
联合[_StorageBase,
类型化存储
]
抛出
未实现异常
定义
从文件设置(self, *
参数, **
关键字参数):
抛出
未实现异常
定义
_设置_cdata(self, *
参数, **
关键字参数):
抛出
未实现异常
定义
_共享_cuda_(self, *
参数, **
关键字参数):
抛出
未实现异常
定义
是否共享(self) ->
_布尔:
抛出
未实现异常
@classmethod
定义 _new_shared_cuda(cls, *
参数, **
关键字参数) ->
自身:
抛出
未实现异常
定义
_共享增加引用(self, *
参数, **
关键字参数):
抛出
未实现异常
@classmethod
定义
_释放弱引用(cls, *
参数, **
关键字参数):
抛出
不支持异常
@property
定义
是 CUDA(self):
抛出
不支持的操作异常
@property
定义 is_hpu(self):
抛出
不支持的操作异常
@classmethod
定义
从文件(cls,
文件名,
共享,
字节数) ->
联合[_StorageBase,
类型化存储
]
抛出
不支持的操作异常
@classmethod
定义
已过期(cls, *
参数, **
关键字参数) ->
联合[_StorageBase,
类型化存储
]
抛出
未实现异常
定义 _byteswap(self, *
参数, **
关键字参数):
抛出
未实现异常
定义
获取文件名(self, *
参数, **
关键字参数) ->
可选[str
]
抛出
未实现异常
定义 __repr__(self):
info_str = f"[{火炬.
类型名(self)}
(设备={self.
设备}
) 尺寸为{
长度(self)}]"
如果 self.
设备.
类型 ==
元数据:
返回
"..."
输入文本翻译为简体中文为：\n" + info_str
data_str = 输入文本为空，请提供需要翻译的文本 + "
输入文本翻译为简体中文为：\n ".
连接(str(self[i])
对于 i
在
范围(self.
尺寸()))
返回 data_str + "
输入文本翻译为简体中文为：\n" + info_str
定义 __iter__(self):
返回
迭代(self[i]
对于 i
在
范围(self.
尺寸()))
定义
复制(self):
返回 self.
克隆()
定义
深拷贝(self,
描述):
备忘录 =
描述.setdefault(
torch, {})
如果 self._cdata
在
描述:
返回
描述[self._cdata]
新存储 = self.
克隆()
描述[self._cdata] =
新存储
返回
新存储
定义 __reduce__(self):
b = 输入/输出.BytesIO()
火炬.
保存(self, b,
使用新的 zip 文件序列化=False)
返回 (
从字节加载, (b.
获取值(),))
定义 __sizeof__(self):
返回
超级().__sizeof__() + self.
尺寸()
定义
克隆(self):
返回此存储的副本。
返回
类型(self)(self.
字节数(),
设备=self.
设备).
复制_(self)
定义
转列表(self):
"返回包含此存储元素列表。"
返回
列表(self)
定义 cpu(self):
"如果此存储尚未在 CPU 上，则返回其 CPU 副本。"
如果 self.
设备.
类型 != "cpu":
返回
火炬.
未类型化存储(self.
尺寸()).
复制_(self, False)
返回 self
定义
会员(self):
返回此存储的 MPS 复制件，如果它尚未在 MPS 上。
如果 self.
设备.
类型 !=
国会议员:
返回
火炬.
未类型化存储(self.
尺寸(),
设备=
国会议员).
复制_(self, False)
返回 self
定义
_到(self,
数据类型):
如果
不 isinstance(
数据类型,
火炬.
数据类型):
抛出
类型错误(f
"参数 'dtype' 必须是 torch.dtype 类型，而不是 "{
类型(
数据类型)}")
存储 = (
火炬.
张量
[]
数据类型=
火炬.uint8,
设备=self.
设备)
.集合(
角色(
存储, self))
.到(
数据类型)
._typed_storage()
)
如果
存储.
数据指针() == self.
数据指针():
存储 =
存储.
克隆()
返回
存储
定义
到(self, *,
设备:
设备类型,
非阻塞:
_布尔 = False):
如果
不 isinstance(
设备,
火炬.
设备):
设备 =
火炬.
设备(
设备)
返回 _to(self,
设备,
非阻塞)
定义 double(self):
将此存储转换为双精度浮点类型。
返回 self._to(
火炬.double)
定义 float(self):
将此存储转换为浮点类型。
返回 self.
到(
火炬.float)
定义
半(self):
将此存储转换为半类型。
返回 self._to(
火炬.
半)
定义
长(self):
将此存储转换为长类型。
返回 self._to(
火炬.
长)
定义 int(self):
将此存储转换为 int 类型。
返回 self._to(
火炬.int)
定义
短整型(self):
将此存储转换为短类型。
返回 self.
_转(
火炬.
短整型)
定义
字符(self):
将此存储转换为 char 类型。
返回 self._to(
火炬.int8)
定义 byte(self):
将此存储转换为字节类型。
返回 self._to(
火炬.uint8)
定义 bool(self):
将此存储转换为布尔类型。
返回 self._to(
火炬.bool)
定义 bfloat16(self):
将此存储转换为 bfloat16 类型。
返回 self._to(
火炬.bfloat16)
定义 complex_double(self):
将此存储转换为复双精度类型。
返回 self._to(
火炬.cdouble)
定义 complex_float(self):
将此存储转换为复浮点类型。
返回 self._to(
火炬.cfloat)
定义 float8_e5m2(self):
将此存储转换为 float8_e5m2 类型
返回 self.
_到(
火炬.float8_e5m2)
定义 float8_e4m3fn(self):
将此存储转换为 float8_e4m3fn 类型
返回 self._to(
火炬.float8_e4m3fn)
定义 float8_e5m2fnuz(self):
将此存储转换为 float8_e5m2fnuz 类型
返回 self._to(
火炬.float8_e5m2fnuz)
定义 float8_e4m3fnuz(self):
将此存储转换为 float8_e4m3fnuz 类型
返回 self.
_到(
火炬.float8_e4m3fnuz)
定义
是否已固定(self,
设备:
联合[str,
火炬.
设备] =
cuda):
r确定 CPU 存储是否已经固定在设备上。
参数：
设备（str 或 torch.device）：指定内存挂载的设备（默认：`'cuda'`）。
此参数不建议使用，并可能被弃用。
返回值：
一个布尔变量。
"""
返回 (
火炬.
张量([],
数据类型=
火炬.uint8,
设备=self.
设备)
.集合(
角色(
存储, self))
.is_pinned(设备)
)
定义
显存(self,
设备:
联合[str,
火炬.
设备] =
cuda):
r将 CPU 存储复制到已固定内存中，如果它尚未固定。
参数：
device (str 或 torch.device): 要固定内存的设备（默认：'cuda'）。
此参数不建议使用，并可能被弃用。
返回值：
固定 CPU 存储。
"""
如果 self.
设备.
类型 != "cpu":
抛出
类型错误(f
"无法固定 '"{self.
类型()}
只有 CPU 内存可以被固定)
固定张量 = (
火炬.
张量([],
数据类型=
火炬.uint8,
设备=self.
设备)
.集合(
角色(
存储, self))
.显存(
设备)
)
返回
固定张量.
未类型化存储()
定义
共享内存_(self):
请参阅 :meth:`torch.UntypedStorage.share_memory_`
from torch.multiprocessing 导入
获取共享策略
如果 self.
设备.
类型
在 [
cuda,
火炬._C._get_privateuse1_backend_name()]:
通过
CUDA 或 PrivateUse1 不使用 POSIX 共享内存
elif 获取共享策略() ==
"文件系统":
self._share_filename_cpu_()
否则:
self._share_fd_cpu_()
返回 self
@classmethod
定义
新共享(cls,
尺寸, *,
设备="cpu"):
在共享内存中创建具有相同数据类型的新存储。
from torch.multiprocessing 导入
获取共享策略
设备 =
火炬.
设备(
设备)
如果
设备.
类型
在 [
cuda,
火炬._C._get_privateuse1_backend_name(),
hpu
]
返回 cls(
尺寸,
设备=
设备)
elif 获取共享策略() ==
"文件系统":
返回 cls._new_using_filename_cpu(
尺寸)
否则:
返回 cls.
使用_fd_cpu 新版本(
尺寸)
定义
未指定类型(self):
返回 self
定义
字节交换(self,
数据类型):
在底层数据中交换字节。
元素大小 =
火炬._utils.
元素大小(
数据类型)
对于复杂类型，不要交换第一和第二个数字
如果
数据类型.
是复杂的:
元素大小 =
最大值(int(
元素大小 / 2), 1)
self.字节交换(
元素大小)
定义
_共享内存锁保护(fn):
@functools.包装(fn)
定义
包装器(self, *
参数, **
关键字参数):
解放 =
无
等待 =
无
替换为
共享内存锁:
键 = self._cdata
如果
键
在
共享内存映射:
等待中 =
共享内存映射[
键]
否则:
共享内存映射[
键] =
线程.RLock()
_共享内存映射[
键].
获取()
待释放 =
键
如果我们已经在共享存储的过程中，请等待
等待它完成。
如果
等待
是
不
无:
替换为
等待:
通过
尝试:
返回 fn(self, *
参数, **
关键字参数)
最后:
如果我们在这里获得了存储锁并且完成了对该存储的工作
现在我们可以释放它并释放条目。
如果 to_free
是
不
无:
确保存储中的 cdata 没有改变，只有
数据指针发生了变化。
断言 self._cdata == to_free
替换为
_共享内存锁:
共享内存映射[
释放].
释放()
删除
共享内存映射[
解放]
返回
包装器
[文档]
类
未类型化存储(
火炬._C.
存储基础, _StorageBase):
定义 __getitem__(self, *
参数, **
关键字参数):
如果 self.
设备.
类型 ==
元数据:
抛出
不支持的操作异常(
"不适用于'meta'设备类型")
返回
超级().__getitem__(*
参数, **
关键字参数)
@property
定义
是 cuda(self):
返回 self.
设备.
类型 == "cuda"
@property
定义
是 hpu(self):
返回 self.
设备.
类型 ==
hpu
@property
定义
文件名(self) ->
可选[str
]
返回与此存储关联的文件名。
如果存储在 CPU 上并且通过 `:meth:`~torch.from_file()` 以 `shared` 为 `True` 创建，则文件名将是一个字符串。否则，此属性为 `None`。
meth:`~torch.from_file()` 以 `shared` 为 `True` 创建。否则，此属性为 `None`。
"""
返回 self.
_获取文件名()
[文档] @保护共享内存锁
def share_memory_(self, *args, **kwargs):
"""
将存储移动到共享内存。
对于已经位于共享内存中的存储和 CUDA 存储，这是一个无操作。
共享内存中的存储无法调整大小。
共享内存中的存储无法调整大小。
注意，为了减轻像这样的问题 `this `_ 的影响
从多个线程中调用此函数是线程安全的。
但是，如果没有适当的同步，调用 self 上的任何其他函数则不是线程安全的。
请参阅 :doc:`/notes/multiprocessing` 获取更多详细信息。
.. 注意::
当删除对共享内存中存储的所有引用时，相关的共享内存对象也将被删除。PyTorch 有一个特殊的清理过程来确保即使当前进程意外退出，也会发生这种情况。
对象将被删除。PyTorch 有一个特殊的清理过程来确保即使当前进程意外退出，也会发生这种情况。
即使当前进程意外退出，也会发生这种情况。
值得注意的是 :meth:`share_memory_` 和 :meth:`from_file` 与 `shared = True` 之间的区别
#. ``share_memory_`` 使用 `shm_open(3) `_ 创建 POSIX 共享内存对象，而 :meth:`from_file` 使用
`open(2) `_ 打开用户传递的文件名。
`open(2) `_ 打开用户传递的文件名。
#. 两者都使用 `mmap(2) 调用 `_ 并带有 ``MAP_SHARED``
将文件/对象映射到当前虚拟地址空间
#. ``share_memory_`` 将在将其映射到对象后调用 ``shm_unlink(3)`` 以确保共享内存
对象在没有任何进程打开对象时被释放。`torch.from_file(shared=True)`不会解除链接。
该文件是持久的，并且将保留直到用户将其删除。
返回值：
self
"""
return super().share_memory_(*args, **kwargs)
@_share_memory_lock_protected
定义 _share_fd_cpu_(self, *
参数, **
关键字参数):
返回
超级()._share_fd_cpu_(*
参数, **
关键字参数)
@_share_memory_lock_protected
定义 _share_filename_cpu_(self, *
参数, **
关键字参数):
返回
超级()._share_filename_cpu_(*
参数, **
关键字参数)
定义 _load_from_bytes(b):
返回
火炬.
加载(
输入/输出.BytesIO(b),
仅权重=False)
@functools.缓存
定义 _new_dtypes():
# 这些是序列化为 UntypedStorage 的 dtypes，与那些在
dtype_to_storage_type_map
返回 {
火炬.float8_e5m2,
火炬.float8_e4m3fn,
火炬.float8_e5m2fnuz,
火炬.float8_e4m3fnuz,
火炬.float8_e8m0fnu,
火炬.bits8,
火炬.bits16,
火炬.
位 1x8,
火炬.
位 2x4,
火炬.
位 4x2,
火炬.complex32,
火炬.uint16,
火炬.uint32,
火炬.uint64,
}
@functools.缓存
定义 _dtype_to_storage_type_map():
# 我们不再向此映射中添加数据类型。此映射
# 仅用于与旧版本的 PyTorch 进行 BC/FC。从现在开始，
# TypedStorage 的新数据类型不应翻译为遗留的
# Storage 类。相反，TypedStorage 的新数据类型
# 被序列化为与 torch.dtype 配对的 UntypedStorage
返回 {
火炬.double:
"双精度存储",
火炬.float:
"浮点存储",
火炬.
半:
半精度存储,
火炬.
长:
长存储,
火炬.int:
整数存储,
火炬.int16:
短存储,
火炬.int8:
字符存储,
火炬.uint8:
字节存储,
火炬.bool:
"布尔存储",
火炬.bfloat16:
"BFloat16 存储",
火炬.cdouble:
"复杂数值存储",
火炬.cfloat:
"复杂数值浮点存储",
火炬.qint8:
QInt8Storage,
火炬.qint32:
QInt32Storage,
火炬.quint8: "QUInt8Storage",
火炬.quint4x2: "QUInt4x2Storage",
火炬.quint2x4:
"QUInt2x4 存储",
}
@functools.缓存
定义
_存储类型到数据类型映射():
数据类型映射 = {val:
键
对于
键, val
在
dtype_to_storage_type_map().
项目()}
返回 dtype_map
定义 _get_storage_from_sequence(sequence,
数据类型,
设备):
如果 dtype
在 [
火炬.quint8,
火炬.quint4x2,
火炬.quint2x4,
火炬.qint32,
火炬.qint8,
]
interpret_dtypes = {
火炬.quint8:
火炬.uint8,
火炬.quint4x2:
火炬.uint8,
火炬.quint2x4:
火炬.uint8,
火炬.qint32:
火炬.int32,
火炬.qint8:
火炬.int8,
}
tmp_tensor = 火炬.
张量(
sequence, 数据类型=interpret_dtypes[
数据类型
]
设备=
设备
)
否则:
tmp_tensor = 火炬.
张量(sequence,
数据类型=
数据类型,
设备=
设备)
返回 tmp_tensor._typed_storage().
_未指定存储
定义 _isint(x):
如果 HAS_NUMPY:
返回 isinstance(x, (int,
numpy.
整数))
否则:
返回 isinstance(x, int)
_always_warn_typed_storage_removal = 假
定义
_获取始终警告类型存储删除():
返回
_始终警告类型存储删除
定义
_设置始终警告类型存储删除(always_warn):
全局
总是警告类型存储移除
断言 isinstance(
总是警告, bool)
总是警告类型存储移除 =
总是警告
定义
警告：类型化存储移除(
栈级别=2):
全局
总是警告已输入存储的移除
定义
是否是第一次():
如果
不
有属性(
警告：类型化存储移除,
已警告):
返回
真实
否则:
返回
不
警告：类型化存储移除.
字典[
"已警告"]
如果
_总是警告获取_always_warn_typed_storage_removal()
或者
是否是第一次():
消息 = (
"TypedStorage 已弃用。它将在未来被移除，"
未类型化存储将是唯一的存储类。这应该只关乎
如果您直接使用存储。要访问 UntypedStorage
直接，使用 tensor.untyped_storage() 而不是 tensor.storage()
)
警告.
警告(
消息,
用户警告,
栈级别=
栈级别 + 1)
警告：类型化存储移除.
字典[
已警告] =
真实
定义
重置警告_已输入存储删除():
警告：类型化存储移除.
字典[
已警告] =
假
定义
从模块获取设备(
模块: str):
最后部分 =
模块.
右分割(
“。”, 1
)]-1]
如果
最后部分
在 [
cuda,
火炬._C._get_privateuse1_backend_name(),
hpu
]
返回
最后部分
否则:
返回
cpu
[文档]
类
类型化存储:
是否稀疏:
_布尔 =
假
用于在 torch.save 中，将 FakeTensor 设备存储到存储中时使用（metadata_only=True）
_假设备:
可选[
火炬.
设备] =
无
数据类型:
火炬.dtype
@property
定义
数据类型(self):
返回 self.dtype
@property
定义
文件名(self) ->
可选[str
]
返回与此存储关联的文件名，如果存储是从文件内存映射创建的。
或者 `None`，如果存储不是通过内存映射文件创建的。
返回 self.
未类型化存储.
文件名
[文档] def fill_(self, value):
_warn_typed_storage_removal()
self._setitem(slice(0, self._size()), value)
return self
定义 __new__(
cls,
*参数,
包装存储=
无,
数据类型=
无,
设备=
无,
内部=False,
):
如果
不
内部:
警告：类型化存储移除()
如果 cls ==
火炬.
存储._LegacyStorage:
抛出
运行时错误(
"只有 _LegacyStorage 的子类才能实例化"
)
如果 cls ==
类型化存储:
返回
超级().__new__(cls)
否则:
程序错误信息 = (
f"{cls}__new__ 方法接收了无效的组合
f"的参数。期望以下之一："
输入文本翻译为简体中文为：\n"
" * 无参数"
输入文本翻译为简体中文为：\n"
" * (int 大小)"
输入文本翻译为简体中文为：\n"
" * (数据序列)"
输入文本翻译为简体中文为：\n"
" * (*, 未类型存储 wrap_storage)"
)
如果
设备
是
不
无:
抛出
运行时错误(
参数错误信息 + "
输入文本翻译为简体中文为：\n
不能指定关键字参数 'device'
)
如果 dtype
是
不
无:
抛出
运行时错误(
参数错误信息 + "
输入文本翻译为简体中文为：\n
不能指定关键字参数 'dtype'
)
如果
包装存储
是
无:
如果
长度(
参数) > 1:
抛出
运行时错误(
参数错误信息 + "
输入文本翻译为简体中文为：\n
参数位置过多
)
如果 (
长度(
参数) == 1
和
不 _isint(
参数[0])
和
不 isinstance(
参数[0
]
集合.abc.
序列)
):
抛出
类型错误(
参数错误信息
+ f"输入文本翻译为简体中文为：\n
参数类型未识别{
类型(
参数[0])}"
)
返回
类型化存储(
*参数,
数据类型=cls.
数据类型,
设备=
获取模块中的设备(cls.
__模块__),
内部=True,
)
否则:
如果
长度(
参数) != 0:
抛出
运行时错误(
参数错误信息
+ "输入文本翻译为简体中文为：\n
使用 " " 时不应提供位置参数
"'wrap_storage'"
)
如果
不 isinstance(
包装存储,
火炬.
未类型化存储):
抛出
类型错误(
参数错误信息
+ f"输入文本翻译为简体中文为：\n
'参数 'wrap_storage' 必须是 UntypedStorage 类型，但得到了'{
类型(
包装存储)}"
)
cls_device = _从模块获取设备(cls.
__模块__)
如果
包装存储.
设备.
类型 != cls_device:
抛出
运行时错误(
参数错误信息
+ f"输入文本翻译为简体中文为：\n
'wrap_storage'的设备必须是{cls_device}"
f", 但得到{
包装存储.
设备.
类型}"
)
返回
类型化存储(
*参数,
包装存储=
包装存储,
数据类型=cls.
数据类型,
内部=True,
)
定义 __init__(
self,
*参数,
设备=
无,
数据类型=
无,
包装存储=
无,
内部=False,
):
如果
不
内部:
警告：类型化存储移除()
程序错误信息 = (
"TypedStorage.__init__ 接收到了一个无效的参数组合 "
"期望以下之一："
输入文本翻译为简体中文为：\n"
" * (*, torch.device 设备, torch.dtype 数据类型)"
输入文本翻译为简体中文为：\n"
" * (int 大小, *, torch.device 设备, torch.dtype 数据类型)"
输入文本翻译为简体中文为：\n"
" * (Sequence 数据序列, *, torch.device 设备, torch.dtype 数据类型)"
输入文本翻译为简体中文为：\n"
" * (*, UntypedStorage 包装存储, torch.dtype 数据类型)"
)
如果
包装存储
是
不
无:
如果
长度(
参数) != 0:
抛出
运行时错误(
参数错误信息
+ "输入文本翻译为简体中文为：\n
使用 " " 时不应提供位置参数
"'包装存储'"
)
如果 dtype
是
无:
抛出
运行时错误(
参数错误信息 + "
输入文本翻译为简体中文为：\n
必须指定 'dtype' 参数
)
如果
不 isinstance(
数据类型,
火炬.
数据类型):
抛出
类型错误(
参数错误信息
+ f"输入文本翻译为简体中文为：\n
'参数 'dtype' 必须是 torch.dtype 类型，而不是 '{
类型(
数据类型)}"
)
如果
设备
是
不
无:
抛出
运行时错误(
参数错误信息
+ "输入文本翻译为简体中文为：\n
当 'wrap_storage' 被提供时，不应指定 'device'
)
self.dtype = dtype
如果
不 isinstance(
包装存储,
火炬.
未类型化存储):
抛出
类型错误(
程序错误信息
+ f"输入文本翻译为简体中文为：\n
参数 'wrap_storage' 必须是 UntypedStorage 类型，但得到了{
类型(
包装存储)}"
)
self._未指定存储 = wrap_storage
否则:
self.dtype = 火炬.
获取默认数据类型()
如果 dtype
是
无
否则 dtype
设备 =
火炬.
设备(
cpu
如果
设备
是
无
否则
设备)
如果 self.dtype
在 [
火炬.quint8,
火炬.quint4x2,
火炬.quint2x4,
火炬.qint32,
火炬.qint8,
]
如果
设备.
类型 ==
cuda:
抛出
运行时错误(
"无法创建具有量化数据类型的 CUDA 存储"
)
如果
长度(
参数) == 0:
self._未指定存储 =
火炬.
未类型化存储(
设备=
设备)
elif 长度(
参数) == 1:
如果 _isint(
参数[0
)]
self._未指定存储 =
火炬.
未类型化存储(
int(参数[0]) * self.
元素大小(),
设备=
设备
)
elif isinstance(参数[0
]
集合.abc.
序列):
self._未指定存储 =
从序列获取存储(
参数[0
] self.
数据类型,
设备
)
否则:
抛出
类型错误(
参数错误信息
+ f"输入文本翻译为简体中文为：\n
识别到的参数类型不正确：{
类型(
参数[0])}"
)
否则:
抛出
运行时错误(
参数错误信息 + "
输入文本翻译为简体中文为：\n
位置参数过多")
@property
定义
是否为 CUDA(self):
警告：类型化存储移除()
返回 self.
未类型化存储.
设备.
类型 == "cuda"
@property
定义 is_hpu(self):
警告：类型化存储移除()
返回 self.
未类型化存储.
设备.
类型 == "hpu"
[文档] def 无类型(self):
"""返回内部 :class:`torch.UntypedStorage`。”
_warn_typed_storage_removal()
返回 self._untyped_storage
定义 _new_wrapped_storage(self,
未类型化存储) ->
自身:
断言
类型(
未类型化存储) ==
火炬.
未类型存储
如果
类型(self) ==
类型化存储:
返回
角色(
自身,
类型化存储(
包装存储=
未类型化存储,
数据类型=self.
数据类型,
内部=
真实
),
)
否则:
返回
类型(self)(
包装存储=
未类型化存储)
定义 __len__(self):
警告：类型化存储移除()
返回 self.
尺寸()
定义
可能包裹索引(self,
索引,
是停止=False):
如果
索引
是
无:
如果
是停止:
返回 self.
尺寸()
否则:
返回 0
否则:
如果
类型(
索引) != int:
抛出
类型错误(f
"无法索引一个"{
类型(self)}
与{
类型(
索引)}")
如果
是停止:
如果 (
索引 > self.
尺寸())
或者 (
索引 < -self.
尺寸()):
抛出
索引错误(
f"索引"{
索引}
超出存储大小的范围{self.
尺寸()}"
)
如果
索引 > 0:
返回
索引
否则:
返回
索引 % self.
尺寸()
否则:
如果 (
索引
≥ self.
尺寸())
或者 (
索引 < -self.
尺寸()):
抛出
索引错误(
f"索引"{
索引}
超出存储大小的范围{self.
尺寸()}"
)
返回
索引 % self.
尺寸()
定义 __setitem__(self,
索引, value):
警告：类型化存储移除()
返回 self._setitem(
索引, value)
定义 _setitem(self,
索引, value):
如果
不 isinstance(
索引, (int,
切片)):
抛出
运行时错误(f
"无法索引"{
类型(self)}
的{
类型(
索引)}")
如果
火炬.
存储空间(value):
抛出
运行时错误(f
"无法设置具有值类型的项"{
类型(value)}")
如果 self.dtype
在 [
火炬.quint8,
火炬.
五倍四乘二,
火炬.
五倍二乘四,
火炬.
整型 32 位,
火炬.
整型 8 位,
]
解释数据类型 = {
火炬.quint8:
火炬.uint8,
火炬.
五倍四乘二:
火炬.uint8,
火炬.
五倍二乘四:
火炬.uint8,
火炬.
整型 32 位:
火炬.
整型 32 位,
火炬.qint8:
火炬.int8,
}
tmp_dtype = interpret_dtypes[self.数据类型]
tmp_tensor = 火炬.
张量(
[]
数据类型=
临时数据类型,
设备=self.
未类型化存储.
设备
)
临时张量.
集合(
类型化存储(
包装存储=self.
未类型化存储,
数据类型=tmp_dtype,
内部=
真实
)
)
否则:
tmp_tensor = 火炬.
张量(
[]
数据类型=self.
数据类型,
设备=self.
未类型化存储.
设备
).集合(self)
tmp_tensor[索引] =
值
定义 __getitem__(self,
索引):
警告：类型化存储移除()
返回 self._getitem(
索引)
定义 _getitem(self,
索引):
如果 self.
未类型化存储.
设备.
类型 ==
元数据:
抛出
不支持的操作异常(
"不适用于'meta'设备类型")
# 在 TypedStorage 存在之前，使用切片进行索引
# 对于Storage 对象是可能的。然而，它会返回
# 一个存储视图，这在 TypedStorage 中实现起来会有些麻烦
因此它已被禁用
如果 isinstance(
索引,
切片):
抛出
运行时错误(
"切片仅在 UntypedStorage.__getitem__ 中受支持"
)
elif 不 isinstance(
索引, int):
抛出
运行时错误(f
"无法索引一个"{
类型(self)}
与{
类型(
索引)}")
如果 self.dtype
在 [
火炬.quint8,
火炬.quint4x2,
火炬.quint2x4,
火炬.qint32,
火炬.qint8,
]
interpret_dtypes = {
火炬.quint8:
火炬.uint8,
火炬.quint4x2:
火炬.uint8,
火炬.quint2x4:
火炬.uint8,
火炬.qint32:
火炬.int32,
火炬.qint8:
火炬.int8,
}
返回
类型化存储(
包装存储=self.
未类型化存储,
数据类型=interpret_dtypes[self.
数据类型
]
内部=True,
)._getitem(索引)
idx_wrapped = self.可能包裹索引(
索引)
from torch._subclasses.fake_tensor 导入
临时取消 fake 设置
替换为
临时取消 fake 设置():
tmp_tensor = 火炬.
张量(
[]
数据类型=self.
数据类型,
设备=self.
未类型化存储.
设备
).集合(self)
返回 tmp_tensor[idx_wrapped].
项目()
[文档] def copy_(self, source: T, non_blocking: _Optional[bool] = None):
_warn_typed_storage_removal()
如果 source 是 TypedStorage 类型
self._untyped_storage.copy_(source._untyped_storage, non_blocking)
否则:
self._untyped_storage.copy_(source, non_blocking)
返回 self
[文档] def nbytes(self):
_warn_typed_storage_removal()
return self._nbytes()
# 仅限内部使用，避免弃用警告
定义 _nbytes(self):
返回 self.
未类型化存储.
字节数()
[文档] def 类型(
self,
数据类型: _Optional[str] = None,
non_blocking: 布尔类型 = False,
) -> 联合体[_StorageBase, TypedStorage, str]:
_warn_typed_storage_removal()
if dtype is None:
legacy_class = self._get_legacy_storage_class()
if legacy_class is not None:
返回 legacy_class.__module__ + "." + legacy_class.__name__
返回 ".".join([self.__module__, type(self).__name__])
else:
返回 self._untyped_storage.type(dtype, non_blocking)
[文档] def cuda(self, device=None, non_blocking=False) -> Self:
_warn_typed_storage_removal()
if self.dtype in [
torch.quint8,
torch.quint4x2,
torch.quint2x4,
torch.qint32,
torch.qint8,
]
raise RuntimeError("无法创建具有量化数据类型的 CUDA 存储")
cuda_storage = self._untyped_storage.cuda(device, non_blocking)
return self._new_wrapped_storage(cuda_storage)
[文档] def hpu(self, device=None, non_blocking=False) -> Self:
_warn_typed_storage_removal()
if self.dtype in [
torch.quint8,
torch.quint4x2,
torch.quint2x4,
torch.qint32,
torch.qint8,
]
抛出运行时错误("无法使用量化数据类型创建 HPU 存储")
hpu_storage = self._untyped_storage.hpu(device, non_blocking)
返回 self._new_wrapped_storage(hpu_storage)
[文档] def to(self, *, device: DeviceLikeType, non_blocking: bool = False) -> Self:
_warn_typed_storage_removal()
if not isinstance(device, torch.device):
device = torch.device(device)
if self.dtype in [
torch.quint8,
torch.quint4x2,
torch.quint2x4,
torch.qint32,
torch.qint8,
]
raise RuntimeError(
无法创建具有量化数据类型的 {device.type.upper()} 存储空间
)
to_storage = self._untyped_storage.to(device=device, non_blocking=non_blocking)
返回 self._new_wrapped_storage(to_storage)
[文档] def 元素大小(self):
_warn_typed_storage_removal()
return self._element_size()
仅内部使用，避免弃用警告
定义
元素大小(self):
返回
火炬._utils.
元素大小(self.
数据类型)
[文档] def get_device(self) -> _int:
_warn_typed_storage_removal()
return self._untyped_storage.get_device()
定义 __str__(self):
警告：类型化存储移除()
info_str = (
f"[{火炬.
类型名(self)}(dtype={self.
数据类型}
，"
f"device={self.设备}
) 尺寸为{
长度(self)}]"
)
如果 self.
设备.
类型 ==
元数据:
返回
"..."
输入文本翻译为简体中文为：\n" + info_str
否则:
data_str = " " + "\n ".连接(str(self[i])
对于 i
在
范围(self.
尺寸()))
返回
数据字符串 + "
输入文本翻译为简体中文为：\n" + info_str
定义 __repr__(self):
警告：类型化存储移除()
返回 str(self)
定义 __iter__(self):
警告：类型化存储移除()
返回
迭代(self[i]
对于 i
在
范围(self.
尺寸()))
定义
复制(self):
警告：类型化存储移除()
返回 self.
新封装存储(
复制.
复制(self.
未类型化存储))
定义
深拷贝(self,
描述):
警告：类型化存储移除()
返回 self.
深拷贝(
描述)
仅限内部使用，避免弃用警告
定义
深拷贝(self,
描述):
返回 self.
_新封装存储(
复制.
深拷贝(self.
未类型化存储,
描述))
定义 __sizeof__(self):
警告：类型化存储移除()
返回
超级().__sizeof__() + self.
字节数()
[文档] def 克隆(self):
"""返回此存储的副本。"""
_warn_typed_storage_removal()
return self._new_wrapped_storage(self._untyped_storage.clone())
[文档] def tolist(self):
"""返回包含此存储元素列表。"""
_warn_typed_storage_removal()
return list(self)
[文档] def cpu(self):
"""返回一个 CPU 副本，如果该存储已经在 CPU 上则不返回。"""
_warn_typed_storage_removal()
return self._new_wrapped_storage(self._untyped_storage.cpu())
[文档] def is_pinned(self, device: Union[str, torch.device] = "cuda"):
r"""确定 CPU TypedStorage 是否已经固定在设备上。"""
Args:
参数（str 或 torch.device）：指定内存挂载的设备（默认：`'cuda'`）。
该参数不建议使用，并可能被弃用。
返回值：
一个布尔变量。
"""
_warn_typed_storage_removal()
返回 self._untyped_storage.is_pinned(device)
[文档] def pin_memory(self, device: Union[str, torch.device] = "cuda"):
将 CPU TypedStorage 复制到固定内存中，如果它尚未固定。
参数:
device (str 或 torch.device): 将内存固定在的设备（默认：``'cuda'``）。
此参数不建议使用，并可能被弃用。
返回：
固定的 CPU 存储。
"""
_warn_typed_storage_removal()
return self._new_wrapped_storage(
self._untyped_storage.pin_memory(device=device)
)
[文档] def share_memory_(self):
"""参见 :meth:`torch.UntypedStorage.share_memory_`"""
_warn_typed_storage_removal()
return self._share_memory_()
仅内部使用，避免弃用警告
定义
共享内存(self):
self.未类型化存储.
共享内存_()
返回 self
定义 _new_shared(self,
尺寸, *,
设备=
无):
在共享内存中创建具有相同数据类型的新存储。
如果
设备
是
无:
设备 =
cpu
设备 =
火炬.
设备(
设备)
未类型化存储 =
火炬.
未类型化存储.
新共享(
大小 * self.
元素大小(),
设备=
设备
)
返回
类型化存储(
包装存储=
未类型化存储,
数据类型=self.
数据类型,
内部=
真实
)
@property
定义 _cdata(self):
返回 self.
未类型化存储._cdata
@property
定义
设备(self):
警告：类型化存储移除()
返回 self.
未类型化存储.
设备
[文档] def size(self):
_warn_typed_storage_removal()
return self._size()
# 仅限内部使用，避免弃用警告
定义
尺寸(self):
# NB: 不要通过 __len__ 间接，因为这需要
# 一个整数来返回
返回 self.
未类型化存储.
字节数() // self.
元素大小()
[文档] def pickle_storage_type(self):
_warn_typed_storage_removal()
return self._pickle_storage_type()
# 仅限内部使用，避免弃用警告
定义
_pickle 存储类型(self):
尝试:
返回 _dtype_to_storage_type_map()[self.
数据类型]
除了 KeyError as e:
抛出
键错误(f
"dtype"{self.
数据类型}
未识别的类型) from e
定义 __reduce__(self):
b = 输入/输出.BytesIO()
火炬.
保存(self, b,
使用新的 zip 文件序列化=False)
返回 (_load_from_bytes, (b.
获取值(),))
[文档] def data_ptr(self):
_warn_typed_storage_removal()
return self._data_ptr()
# 仅限内部使用，避免弃用警告
定义
_数据指针(self):
返回 self.
未类型化存储.
数据指针()
[文档] def resizable(self):
_warn_typed_storage_removal()
return self._untyped_storage.resizable()
[文档] def resize_(self, size):
_warn_typed_storage_removal()
self._resize_(size)
仅限内部使用，避免弃用警告
定义
_resize_()(self,
尺寸):
self.未类型化存储.
调整大小(
大小 * self.
元素大小())
@classmethod
定义
_释放弱引用(cls, *
参数, **
关键字参数):
返回
未类型化存储.
_释放弱引用(*
参数, **
关键字参数)
定义
弱引用(self, *
参数, **
关键字参数):
返回 self.
未类型化存储.
弱引用(*
参数, **
关键字参数)
[文档] @类方法
def from_buffer(cls, *args, **kwargs):
_warn_typed_storage_removal()
return cls._from_buffer(*args, **kwargs)
@classmethod
定义
从缓冲区读取(cls, *
参数,
数据类型=
无,
设备=
无, **
关键字参数):
如果
类 ==
类型化存储:
dtype = 火炬.
获取默认数据类型()
如果 dtype
是
无
否则 dtype
设备 =
火炬.
设备(
cpu
如果
设备
是
无
否则
设备)
如果
设备.
类型 != "cpu":
抛出
运行时错误(
f"TypedStorage.from_buffer: 不适用于设备"{
设备.
类型}"
)
未类型化存储:
火炬.
未类型存储 =
火炬.
未类型化存储.from_buffer(
*参数,
数据类型=
数据类型, **kwargs
)
否则:
如果 dtype
是
不
无
或者
长度(
参数) == 5:
抛出
运行时错误(
"from_buffer: 'dtype' 只能在 "
"UntypedStorage.from_buffer 和 TypedStorage.from_buffer"
)
如果
设备
是
不
无:
抛出
运行时错误(
"from_buffer: 'device' 只能在 "
"UntypedStorage.from_buffer 和 TypedStorage.from_buffer"
)
dtype = cls._dtype
未类型化存储 =
火炬.
未类型化存储.from_buffer(
*参数,
数据类型=
数据类型, **kwargs
)
返回
类型化存储(
包装存储=
未类型化存储,
数据类型=
数据类型,
内部=True)
定义
_到(self,
数据类型):
如果
不 isinstance(
数据类型,
火炬.
数据类型):
抛出
类型错误(f
"参数 'dtype' 必须是 torch.dtype 类型，而不是 "{
类型(
数据类型)}")
存储 = (
火炬.
张量([],
数据类型=self.
数据类型,
设备=self.
设备)
.集合(self)
.到(
数据类型)
._typed_storage()
)
如果
存储.
数据指针() == self.
数据指针():
存储 =
存储.
克隆()
返回
存储
[文档] def double(self):
将此存储转换为双精度类型。
_warn_typed_storage_removal()
return self._to(torch.double)
[文档] def float(self):
将此存储转换为浮点类型。
_warn_typed_storage_removal()
return self._to(torch.float)
[文档] def half(self):
将此存储转换为半精度类型。
_warn_typed_storage_removal()
return self._to(torch.half)
[文档] def long(self):
将此存储转换为长整型。
_warn_typed_storage_removal()
return self._to(torch.long)
[文档] def int(self):
将此存储转换为 int 类型。
_warn_typed_storage_removal()
return self._to(torch.int)
[文档] def short(self):
将此存储转换为 short 类型。
_warn_typed_storage_removal()
return self._to(torch.short)
[文档] def char(self):
将此存储转换为 char 类型。
_warn_typed_storage_removal()
return self._to(torch.int8)
[文档] def byte(self):
将此存储转换为字节类型。
_warn_typed_storage_removal()
return self._to(torch.uint8)
[文档] def bool(self):
将此存储转换为布尔类型。
_warn_typed_storage_removal()
return self._to(torch.bool)
[文档] def bfloat16(self):
将此存储转换为 bfloat16 类型。
_warn_typed_storage_removal()
return self._to(torch.bfloat16)
[文档] def complex_double(self):
将此存储转换为复数双精度类型。
_warn_typed_storage_removal()
return self._to(torch.cdouble)
[文档] def complex_float(self):
将此存储转换为复浮点类型。
_warn_typed_storage_removal()
return self._to(torch.cfloat)
[文档] def float8_e5m2(self):
"""将此存储转换为 float8_e5m2 类型"""
_warn_typed_storage_removal()
return self._to(torch.float8_e5m2)
[文档] def float8_e4m3fn(self):
将此存储转换为 float8_e4m3fn 类型
_warn_typed_storage_removal()
return self._to(torch.float8_e4m3fn)
[文档] def float8_e5m2fnuz(self):
将此存储转换为 float8_e5m2fnuz 类型
_warn_typed_storage_removal()
return self._to(torch.float8_e5m2fnuz)
[文档] def float8_e4m3fnuz(self):
将此存储转换为 float8_e4m3fnuz 类型
_warn_typed_storage_removal()
return self._to(torch.float8_e4m3fnuz)
[文档] @classmethod
def from_file(cls, filename, shared, size):
"""from_file(filename, shared=False, size=0) -> Storage
创建一个由内存映射文件支持的 CPU 存储。
如果 `shared` 是 `True`，则所有进程之间共享内存。
所有更改都写入文件。如果 `shared` 为 `False`，则更改...
存储不影响文件。
`size` 是存储中元素的数量。如果 `shared` 为 `False`，
文件必须至少包含 ``size * sizeof(Type)`` 字节
（``Type`` 是存储类型）。如果 ``shared`` 为 ``True``，则如果需要将创建文件。
参数：
filename (str): 映射的文件名
共享（布尔值）：是否共享内存（是否传递了 ``MAP_SHARED`` 或 ``MAP_PRIVATE`` 给底层的 `mmap(2) 调用 `_）
（底层 `mmap(2) 调用 `_）
大小（整型）：存储中元素的数量
"""
_warn_typed_storage_removal()
如果 cls 等于 TypedStorage
抛出 RuntimeError("from_file 只能在派生类中调用")
untyped_storage = UntypedStorage.from_file(
文件名，共享，大小 * torch._utils._element_size(cls.dtype)
)
storage = cls(wrap_storage=untyped_storage)
返回 storage
@classmethod
定义
已过期(cls, *
参数, **
关键字参数):
返回
未类型化存储.
已过期(*
参数, **
关键字参数)
定义
_写入文件(self, *
参数, **
关键字参数):
返回 self.
未类型化存储.
_写入文件(*
参数, **
关键字参数)
定义
从文件设置(self, *
参数, **
关键字参数):
返回 self.
未类型化存储.
从文件设置(*
参数, **
关键字参数)
定义
_设置_cdata(self, *
参数, **
关键字参数):
返回 self.
未类型化存储.
_设置_cdata(*
参数, **
关键字参数)
定义
_共享_cuda_(self, *
参数, **
关键字参数):
返回 self.
未类型化存储.
_共享_cuda_(*
参数, **
关键字参数)
[文档] def is_shared(self):
_warn_typed_storage_removal()
return self._is_shared()
# 仅限内部使用，避免弃用警告
定义
共享(self):
返回 self.
未类型化存储.
是否共享()
@classmethod
定义 _new_shared_cuda(cls, *
参数, **
关键字参数):
返回
火炬.
未类型化存储._new_shared_cuda(*
参数, **
关键字参数)
定义 _share_filename_cpu_(self, *
参数, **
关键字参数):
(
管理员处理,
存储处理,
尺寸,
) = self.未类型化存储._share_filename_cpu_(*
参数, **
关键字参数)
返回
管理员处理,
存储句柄,
大小 // self.
元素大小()
定义
_共享解引用(self):
self.未类型化存储.
_共享解引用()
返回 self
@classmethod
定义
释放 IPC 计数器(cls, *
参数,
设备=
无, **
关键字参数):
返回
火炬.
未类型化存储.
_发布 ipc 计数器_cuda(*
参数, **
关键字参数)
定义
_共享增加引用(self, *
参数, **
关键字参数):
返回 self.
未类型化存储.
_共享增加引用(*
参数, **
关键字参数)
定义 _share_fd_cpu_(self, *
参数, **
关键字参数):
fd, 大小 = self.
未类型化存储._share_fd_cpu_(*
参数, **
关键字参数)
返回 fd,
大小 // self.
元素大小()
定义 _get_legacy_storage_class(self):
如果 self.dtype
不
在 _dtype_to_storage_type_map():
返回
无
存储名称 = _dtype_to_storage_type_map()[self.
数据类型]
如果 self.
设备.
类型
不
在 [
"cpu",
cuda,
hpu,
火炬._C._get_privateuse1_backend_name(),
]
返回
无
模块 = (
火炬
如果 self.
设备.
类型 ==
cpu
否则 getattr(
火炬, self.
设备.
类型)
)
尝试:
返回 getattr(
模块,
存储名称)
除了
属性错误:
返回
无
类型化存储.
类型.
__文档__ =
类型.
__文档__
类型化存储.cuda.
__文档__ = _StorageBase.cuda.
__文档__
类型化存储.hpu.
__文档__ = _StorageBase.hpu.
__文档__
类型化存储.
到.
__文档__ =
_到.
__文档__
类 _LegacyStorageMeta(
类型):
数据类型:
火炬.dtype
定义 __instancecheck__(cls,
实例):
如果
类型(
实例) ==
类型化存储:
类设备 =
获取模块中的设备(cls.
__模块__)
返回 (
类设备 ==
实例.
设备.
类型)
和 (
cls.dtype == 实例.dtype
)
返回
假
类 _LegacyStorage(
类型化存储,
元类=_LegacyStorageMeta):
@classmethod
定义
新共享(cls,
尺寸):
在共享内存中创建具有相同数据类型的新存储。
未类型化存储 =
火炬.
未类型化存储.
新共享(
大小 * cls().
元素大小())
返回 cls(
包装存储=
未类型化存储)
@classmethod
定义
发布 IPC 计数器(cls, *
参数, **
关键字参数):
返回
火炬.
未类型化存储.
_发布 ipc 计数器_cuda(*
参数, **
关键字参数)
@classmethod
定义 _new_shared_filename(cls,
经理,
对象,
尺寸):
字节数大小 =
大小 *
火炬._utils.
元素大小(cls.
数据类型)
返回 cls(
包装存储=
火炬.
未类型化存储._new_shared_filename_cpu(
经理,
对象,
字节数大小
)
)
定义
_从 pickle 存储类型获取数据类型(
Pickle 存储类型: str):
尝试:
返回
_存储类型到数据类型映射()[
Pickle 存储类型]
除了
键错误 as e:
抛出
键错误(
f'pickle 存储类型"{pickle_storage_type}
"不被识别"
) from e
