├── docs ├── torchvision │ ├── torchvision.md │ ├── torchvision-utils.md │ ├── torchvision-transform.md │ ├── torchvision-models.md │ └── torchvision-datasets.md ├── package_references │ ├── legacy.md │ ├── model_zoo.md │ ├── ffi.md │ ├── Storage.md │ ├── data.md │ ├── torch-multiprocessing.md │ ├── torch-cuda.md │ ├── nn_init.md │ ├── torch-autograd.md │ ├── torch-optim.md │ ├── functional.md │ ├── Tensor.md │ └── torch-nn.md ├── notes │ ├── serialization.md │ ├── cuda.md │ ├── multiprocessing.md │ ├── autograd.md │ └── extending.md ├── index.md └── acknowledgement.md ├── mkdocs.yml └── README.md /docs/torchvision/torchvision.md: -------------------------------------------------------------------------------- 1 | # torchvision 2 | `torchvision`包包含了目前流行的数据集，模型结构和常用的图片转换工具。 3 | -------------------------------------------------------------------------------- /docs/package_references/legacy.md: -------------------------------------------------------------------------------- 1 | # 遗产包 - torch.legacy 2 | 此包中包含从Lua Torch移植来的代码。 3 | 4 | 为了可以使用现有的模型并且方便当前Lua Torch使用者过渡，我们创建了这个包。可以在`torch.legacy.nn`中找到`nn`代码，并在`torch.legacy.optim`中找到`optim`代码。 API应该完全匹配Lua Torch。 5 | -------------------------------------------------------------------------------- /docs/notes/serialization.md: -------------------------------------------------------------------------------- 1 | # 序列化语义 2 | ## 最佳实践 3 | ### 保存模型的推荐方法 4 | 这主要有两种方法序列化和恢复模型。 5 | 6 | 第一种（推荐）只保存和加载模型参数： 7 | ```python 8 | torch.save(the_model.state_dict(), PATH) 9 | ``` 10 | 然后： 11 | ```python 12 | the_model = TheModelClass(*args, **kwargs) 13 | the_model.load_state_dict(torch.load(PATH)) 14 | ``` 15 | 第二种保存和加载整个模型： 16 | ```python 17 | torch.save(the_model, PATH) 18 | ``` 19 | 然后： 20 | ```python 21 | the_model = torch.load(PATH) 22 | ``` 23 | 然而，在这种情况下，序列化的数据被绑定到特定的类和固定的目录结构，所以当在其他项目中使用时，或者在一些严重的重构器之后它可能会以各种方式break。 24 | -------------------------------------------------------------------------------- /docs/package_references/model_zoo.md: -------------------------------------------------------------------------------- 1 | # torch.utils.model_zoo 2 | 3 | ```python 4 | torch.utils.model_zoo.load_url(url, model_dir=None) 5 | ``` 6 | 7 | 在给定URL上加载Torch序列化对象。 8 | 9 | 如果对象已经存在于 *model_dir* 中，则将被反序列化并返回。URL的文件名部分应遵循命名约定`filename-.ext`，其中``是文件内容的SHA256哈希的前八位或更多位数字。哈希用于确保唯一的名称并验证文件的内容。 10 | 11 | *model_dir* 的默认值为`$TORCH_HOME/models`，其中`$TORCH_HOME`默认为`~/.torch`。可以使用`$TORCH_MODEL_ZOO`环境变量来覆盖默认目录。 12 | 13 | **参数：** 14 | 15 | - **url** (*string*) - 要下载对象的URL 16 | - **model_dir** (*string*, optional) - 保存对象的目录 17 | 18 | **例子：** 19 | ```python 20 | >>> state_dict = torch.utils.model_zoo.load_url('https://s3.amazonaws.com/pytorch/models/resnet18-5c106cde.pth') 21 | ``` 22 | -------------------------------------------------------------------------------- /docs/torchvision/torchvision-utils.md: -------------------------------------------------------------------------------- 1 | # torchvision.utils 2 | 3 | ## torchvision.utils.make_grid(tensor, nrow=8, padding=2, normalize=False, range=None, scale_each=False) 4 | 猜测，用来做 `雪碧图的`（`sprite image`）。 5 | 6 | 给定 `4D mini-batch Tensor`，形状为 `(B x C x H x W)`,或者一个`a list of image`，做成一个`size`为`(B / nrow, nrow)`的雪碧图。 7 | 8 | - normalize=True ，会将图片的像素值归一化处理 9 | 10 | - 如果 range=(min, max)， min和max是数字，那么`min`，`max`用来规范化`image` 11 | 12 | - scale_each=True ，每个图片独立规范化，而不是根据所有图片的像素最大最小值来规范化 13 | 14 | [Example usage is given in this notebook](https://gist.github.com/anonymous/bf16430f7750c023141c562f3e9f2a91) 15 | 16 | ## torchvision.utils.save_image(tensor, filename, nrow=8, padding=2, normalize=False, range=None, scale_each=False) 17 | 18 | 将给定的`Tensor`保存成image文件。如果给定的是`mini-batch tensor`，那就用`make-grid`做成雪碧图，再保存。 19 | -------------------------------------------------------------------------------- /docs/package_references/ffi.md: -------------------------------------------------------------------------------- 1 | # torch.utils.ffi 2 | ```python 3 | torch.utils.ffi.create_extension(name, headers, sources, verbose=True, with_cuda=False, package=False, relative_to='.', **kwargs) 4 | ``` 5 | 创建并配置一个cffi.FFI对象,用于PyTorch的扩展。 6 | 7 | **参数：** 8 | 9 | - **name** (*str*) – 包名。可以是嵌套模块，例如 `.ext.my_lib`。 10 | - **headers** (*str* or List[*str*]) – 只包含导出函数的头文件列表 11 | - **sources** (List[*str*]) – 用于编译的sources列表 12 | - **verbose** (*bool*, optional) – 如果设置为False，则不会打印输出（默认值：`True`）。 13 | - **with_cuda** (*bool*, optional) – 设置为True以使用CUDA头文件进行编译（默认值：`False`）。 14 | - **package** (*bool*, optional) – 设置为True以在程序包模式下构建（对于要作为pip程序包安装的模块）（默认值：`False`）。 15 | - **relative_to** (*str*, optional) –构建文件的路径。`package`为`True`时需要。最好使用`__file__`作为参数。 16 | - **kwargs** – 传递给ffi以声明扩展的附加参数。有关详细信息，请参阅[Extension API reference](https://docs.python.org/3/distutils/apiref.html#distutils.core.Extension)。 17 | -------------------------------------------------------------------------------- /docs/index.md: -------------------------------------------------------------------------------- 1 | # PyTorch中文文档 2 | PyTorch是使用GPU和CPU优化的深度学习张量库。 3 | 4 | ## 说明 5 | - [自动求导机制](notes/autograd.md) 6 | - [CUDA语义](notes/cuda.md) 7 | - [扩展PyTorch](notes/extending.md) 8 | - [多进程最佳实践](notes/multiprocessing.md) 9 | - [序列化语义](notes/serialization.md) 10 | 11 | ## Package参考 12 | - [torch](package_references/torch.md) 13 | - [torch.Tensor](package_references/Tensor.md) 14 | - [torch.Storage](package_references/Storage.md) 15 | - [torch.nn](package_references/torch-nn.md) 16 | - [torch.nn.functional](package_references/functional.md) 17 | - [torch.nn.init](package_references/nn_init.md) 18 | - [torch.optim](package_references/torch-optim.md) 19 | - [torch.autograd](package_references/torch-autograd.md) 20 | - [torch.multiprocessing](package_references/torch-multiprocessing.md) 21 | - [torch.legacy](package_references/legacy.md) 22 | - [torch.cuda](package_references/torch-cuda.md) 23 | - [torch.utils.ffi](package_references/ffi.md) 24 | - [torch.utils.data](package_references/data.md) 25 | - [torch.utils.model_zoo](package_references/model_zoo.md) 26 | 27 | ## torchvision参考 28 | - [torchvision](torchvision/torchvision.md) 29 | - [torchvision.datasets](torchvision/torchvision-datasets.md) 30 | - [torchvision.models](torchvision/torchvision-models.md) 31 | - [torchvision.transforms](torchvision/torchvision-transform.md) 32 | - [torchvision.utils](torchvision/torchvision-utils.md) 33 | ## 致谢 34 | - [致谢](acknowledgement.md) 35 | -------------------------------------------------------------------------------- /docs/notes/cuda.md: -------------------------------------------------------------------------------- 1 | # CUDA语义 2 | `torch.cuda`会记录当前选择的GPU，并且分配的所有CUDA张量将在上面创建。可以使用`torch.cuda.device`上下文管理器更改所选设备。 3 | 4 | 但是，一旦张量被分配，您可以直接对其进行操作，而不考虑所选择的设备，结果将始终放在与张量相同的设备上。 5 | 6 | 默认情况下，不支持跨GPU操作，唯一的例外是`copy_()`。除非启用对等存储器访问，否则对分布不同设备上的张量任何启动操作的尝试都将会引发错误。 7 | 8 | 下面你可以找到一个展示如下的小例子： 9 | ```python 10 | x = torch.cuda.FloatTensor(1) 11 | # x.get_device() == 0 12 | y = torch.FloatTensor(1).cuda() 13 | # y.get_device() == 0 14 | 15 | with torch.cuda.device(1): 16 | # allocates a tensor on GPU 1 17 | a = torch.cuda.FloatTensor(1) 18 | 19 | # transfers a tensor from CPU to GPU 1 20 | b = torch.FloatTensor(1).cuda() 21 | # a.get_device() == b.get_device() == 1 22 | 23 | c = a + b 24 | # c.get_device() == 1 25 | 26 | z = x + y 27 | # z.get_device() == 0 28 | 29 | # even within a context, you can give a GPU id to the .cuda call 30 | d = torch.randn(2).cuda(2) 31 | # d.get_device() == 2 32 | ``` 33 | 34 | ## 最佳实践 35 | ### 使用固定的内存缓冲区 36 | 当副本来自固定（页锁）内存时，主机到GPU的复制速度要快很多。CPU张量和存储开放了一个`pin_memory()`方法，它返回该对象的副本，而它的数据放在固定区域中。 37 | 38 | 另外，一旦固定了张量或存储，就可以使用异步的GPU副本。只需传递一个额外的`async=True`参数到`cuda()`的调用。这可以用于将数据传输与计算重叠。 39 | 40 | 通过将`pin_memory=True`传递给其构造函数，可以使`DataLoader`将batch返回到固定内存中。 41 | ### 使用 nn.DataParallel 替代 multiprocessing 42 | 大多数涉及批量输入和多个GPU的情况应默认使用`DataParallel`来使用多个GPU。尽管有GIL的存在，单个python进程也可能使多个GPU饱和。 43 | 44 | 从0.1.9版本开始，大量的GPU(8+)可能未被充分利用。然而，这是一个已知的问题，也正在积极开发。和往常一样，测试你的用例吧。 45 | 46 | 调用`multiprocessing`来利用CUDA模型存在重要的注意事项；使用具有多处理功能的CUDA模型有重要的注意事项; 除非就是需要谨慎地满足数据处理需求，否则您的程序很可能会出现错误或未定义的行为。 47 | -------------------------------------------------------------------------------- /mkdocs.yml: -------------------------------------------------------------------------------- 1 | site_name: PyTorch中文文档 2 | pages: 3 | - 主页: index.md 4 | - 说明: 5 | - 自动求导机制: notes/autograd.md 6 | - CUDA语义: notes/cuda.md 7 | - 扩展PyTorch: notes/extending.md 8 | - 多进程最佳实践: notes/multiprocessing.md 9 | - 序列化语义: notes/serialization.md 10 | - PACKAGE参考: 11 | - torch: package_references/torch.md 12 | - torch.Tensor: package_references/Tensor.md 13 | - torch.Storage: package_references/Storage.md 14 | - torch.nn: package_references/torch-nn.md 15 | - torch.nn.functional: package_references/functional.md 16 | - torch.autograd: package_references/torch-autograd.md 17 | - torch.optim: package_references/torch-optim.md 18 | - torch.nn.init: package_references/nn_init.md 19 | - torch.multiprocessing: package_references/torch-multiprocessing.md 20 | - torch.legacy: package_references/legacy.md 21 | - torch.cuda: package_references/torch-cuda.md 22 | - torch.utils.ffi: package_references/ffi.md 23 | - torch.utils.data: package_references/data.md 24 | - torch.utils.model_zoo: package_references/model_zoo.md 25 | - TORCHVISION参考: 26 | - torchvision: torchvision/torchvision.md 27 | - torchvision.datasets: torchvision/torchvision-datasets.md 28 | - torchvision.models: torchvision/torchvision-models.md 29 | - torchvision.transforms: torchvision/torchvision-transform.md 30 | - torchvision.utils: torchvision/torchvision-utils.md 31 | - 致谢: acknowledgement.md 32 | 33 | theme: readthedocs 34 | 35 | extra_javascript: ['https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML','js/mathjaxhelper.js'] 36 | -------------------------------------------------------------------------------- /docs/package_references/Storage.md: -------------------------------------------------------------------------------- 1 | # torch.Storage 2 | 3 | 一个`torch.Storage`是一个单一数据类型的连续一维数组。 4 | 5 | 每个`torch.Tensor`都有一个对应的、相同数据类型的存储。 6 | 7 | ```python 8 | class torch.FloatStorage 9 | ``` 10 | 11 | #### byte() 12 | 将此存储转为byte类型 13 | 14 | #### char() 15 | 将此存储转为char类型 16 | 17 | #### clone() 18 | 返回此存储的一个副本 19 | 20 | #### copy_() 21 | 22 | #### cpu() 23 | 如果当前此存储不在CPU上，则返回一个它的CPU副本 24 | 25 | #### cuda(*device=None, async=False*) 26 | 返回此对象在CUDA内存中的一个副本。 27 | 如果此对象已在CUDA内存中且在正确的设备上，那么不会执行复制操作，直接返回原对象。 28 | 29 | **参数：** 30 | 31 | - **device** (*[int]()*) - 目标GPU的id。默认值是当前设备。 32 | - **async** (*[bool]()*) -如果值为True，且源在锁定内存中，则副本相对于宿主是异步的。否则此参数不起效果。 33 | 34 | #### data_ptr() 35 | 36 | #### double() 37 | 将此存储转为double类型 38 | 39 | #### element_size() 40 | 41 | #### fill_() 42 | 43 | #### float() 44 | 将此存储转为float类型 45 | 46 | #### from_buffer() 47 | 48 | #### half() 49 | 将此存储转为half类型 50 | 51 | #### int() 52 | 将此存储转为int类型 53 | 54 | #### is_cuda = *False* 55 | 56 | #### is_pinned() 57 | 58 | #### is_shared() 59 | 60 | #### is_sparse = *False* 61 | 62 | #### long() 63 | 将此存储转为long类型 64 | 65 | #### new() 66 | 67 | #### pin_memory() 68 | 如果此存储当前未被锁定，则将它复制到锁定内存中。 69 | 70 | #### resize_() 71 | 72 | #### share_memory_() 73 | 将此存储移动到共享内存中。 74 | 对于已经在共享内存中的存储或者CUDA存储，这是一条空指令，它们不需要移动就能在进程间共享。共享内存中的存储不能改变大小。 75 | 返回：self 76 | 77 | #### short() 78 | 将此存储转为short类型 79 | 80 | #### size() 81 | 82 | #### tolist() 83 | 返回一个包含此存储中元素的列表 84 | 85 | #### type(*new_type=None, async=False*) 86 | 将此对象转为指定类型。 87 | 如果已经是正确类型，不会执行复制操作，直接返回原对象。 88 | 89 | **参数：** 90 | 91 | - **new_type** (*[type]() or [string]()*) -需要转成的类型 92 | - **async** (*[bool]()*) -如果值为True，且源在锁定内存中而目标在GPU中——或正好相反，则复制操作相对于宿主异步执行。否则此参数不起效果。 -------------------------------------------------------------------------------- /docs/acknowledgement.md: -------------------------------------------------------------------------------- 1 | # 致谢 2 | 本项目贡献者如下： 3 | 4 | ## 文档翻译 5 | 6 | | 贡献者 | 页面 | 章节 | 7 | |:----:|:----:|:----:| 8 | |ycszen|主页|| 9 | |ycszen|说明|自动求导机制| 10 | |ycszen|说明|CUDA语义| 11 | |KeithYin|说明|扩展PyTorch| 12 | |ycszen|说明|多进程最佳实践| 13 | |ycszen|说明|序列化语义| 14 | |koshinryuu|package参考|torch| 15 | |weigp|package参考|torch.Tensor| 16 | |kophy|package参考|torch.Storage| 17 | |KeithYin|package参考|torch.nn/Parameters| 18 | |KeithYin|package参考|torch.nn/Containers| 19 | |yichuan9527|package参考|torch.nn/Convolution Layers| 20 | |yichuan9527|package参考|torch.nn/Pooling Layers| 21 | |swordspoet|package参考|torch.nn/Non-linear Activations| 22 | |XavierLin|package参考|torch.nn/Normalization layers| 23 | |KeithYin|package参考|torch.nn/Recurrent layers| 24 | ||package参考|torch.nn/Linear layers| 25 | ||package参考|torch.nn/Dropout layers| 26 | ||package参考|torch.nn/Distance functions| 27 | |KeithYin|package参考|torch.nn/Loss functions| 28 | |KeithYin|package参考|torch.nn/Vision layers| 29 | |KeithYin|package参考|torch.nn/Multi-GPU layers| 30 | |KeithYin|package参考|torch.nn/Utilities| 31 | |ycszen|package参考|torch.nn.functional/Convolution functions| 32 | |ycszen|package参考|torch.nn.functional/Pooling function| 33 | |ycszen|package参考|torch.nn.functional/Non-linear activations functions| 34 | |ycszen|package参考|torch.nn.functional/Normalization functions| 35 | |dyl745001196|package参考|torch.nn.functional/Linear functions| 36 | |dyl745001196|package参考|torch.nn.functional/Dropout functions| 37 | |dyl745001196|package参考|torch.nn.functional/Distance functions| 38 | |tfygg|package参考|torch.nn.functinal/Loss functions| 39 | |KeithYin|package参考|torch.nn.functional/Vision functions| 40 | |kophy|package参考|torch.nn.init| 41 | |KeithYin|package参考|torch.autograd| 42 | |songbo.han|package参考|torch.multiprocessing| 43 | |ZijunDeng|package参考|torch.optim| 44 | |ycszen|pacakge参考|torch.legacy| 45 | |ycszen|package参考|torch.cuda| 46 | |ycszen|pacakge参考|torch.utils.ffi| 47 | |ycszen|package参考|torch.utils.model_zoo| 48 | |ycszen|package参考|torch.utils.data| 49 | |KeithYin|torchvision参考|torchvision| 50 | |KeithYin|torchvision参考|torchvision.datasets| 51 | |KeithYin|torchvision参考|torchvision.models| 52 | |KeithYin|torchvision参考|torchvision.transforms| 53 | |KeithYin|torchvision参考|torchvision.utils| 54 | |ycszen|致谢|| 55 | -------------------------------------------------------------------------------- /docs/package_references/data.md: -------------------------------------------------------------------------------- 1 | # torch.utils.data 2 | ```python 3 | class torch.utils.data.Dataset 4 | ``` 5 | 6 | 表示Dataset的抽象类。 7 | 8 | 所有其他数据集都应该进行子类化。所有子类应该override`__len__`和`__getitem__`，前者提供了数据集的大小，后者支持整数索引，范围从0到len(self)。 9 | 10 | ```python 11 | class torch.utils.data.TensorDataset(data_tensor, target_tensor) 12 | ``` 13 | 包装数据和目标张量的数据集。 14 | 15 | 通过沿着第一个维度索引两个张量来恢复每个样本。 16 | 17 | **参数：** 18 | 19 | - **data_tensor** (*Tensor*) －　包含样本数据 20 | - **target_tensor** (*Tensor*) －　包含样本目标（标签） 21 | 22 | ```python 23 | class torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, num_workers=0, collate_fn=, pin_memory=False, drop_last=False) 24 | ``` 25 | 数据加载器。组合数据集和采样器，并在数据集上提供单进程或多进程迭代器。 26 | 27 | **参数：** 28 | 29 | - **dataset** (*Dataset*) – 加载数据的数据集。 30 | - **batch_size** (*int*, optional) – 每个batch加载多少个样本(默认: 1)。 31 | - **shuffle** (*bool*, optional) – 设置为`True`时会在每个epoch重新打乱数据(默认: False). 32 | - **sampler** (*Sampler*, optional) – 定义从数据集中提取样本的策略。如果指定，则忽略`shuffle`参数。 33 | - **num_workers** (*int*, optional) – 用多少个子进程加载数据。0表示数据将在主进程中加载(默认: 0) 34 | - **collate_fn** (*callable*, optional) – 35 | - **pin_memory** (*bool*, optional) – 36 | - **drop_last** (*bool*, optional) – 如果数据集大小不能被batch size整除，则设置为True后可删除最后一个不完整的batch。如果设为False并且数据集的大小不能被batch size整除，则最后一个batch将更小。(默认: False) 37 | 38 | ```python 39 | class torch.utils.data.sampler.Sampler(data_source) 40 | ``` 41 | 所有采样器的基础类。 42 | 43 | 每个采样器子类必须提供一个`__iter__`方法，提供一种迭代数据集元素的索引的方法，以及返回迭代器长度的`__len__`方法。 44 | 45 | ```python 46 | class torch.utils.data.sampler.SequentialSampler(data_source) 47 | ``` 48 | 样本元素顺序排列，始终以相同的顺序。 49 | 50 | **参数：** 51 | - **data_source** (*Dataset*) – 采样的数据集。 52 | 53 | ```python 54 | class torch.utils.data.sampler.RandomSampler(data_source) 55 | ``` 56 | 样本元素随机，没有替换。 57 | 58 | **参数：** 59 | - **data_source** (*Dataset*) – 采样的数据集。 60 | 61 | 62 | ```python 63 | class torch.utils.data.sampler.SubsetRandomSampler(indices) 64 | ``` 65 | 样本元素从指定的索引列表中随机抽取，没有替换。 66 | 67 | **参数：** 68 | - **indices** (*list*) – 索引的列表 69 | 70 | ```python 71 | class torch.utils.data.sampler.WeightedRandomSampler(weights, num_samples, replacement=True) 72 | ``` 73 | 样本元素来自于[0,..,len(weights)-1]，给定概率（weights）。 74 | 75 | **参数：** 76 | - **weights** (*list*) – 权重列表。没必要加起来为1 77 | - **num_samples** (*int*) – 抽样数量 78 | -------------------------------------------------------------------------------- /docs/package_references/torch-multiprocessing.md: -------------------------------------------------------------------------------- 1 | # torch.multiprocessing 2 | 封装了`multiprocessing`模块。用于在相同数据的不同进程中共享视图。 3 | 4 | 一旦张量或者存储被移动到共享单元(见`share_memory_()`),它可以不需要任何其他复制操作的发送到其他的进程中。 5 | 6 | 这个API与原始模型完全兼容，为了让张量通过队列或者其他机制共享，移动到内存中，我们可以 7 | 8 | 由原来的`import multiprocessing`改为`import torch.multiprocessing`。 9 | 10 | 由于API的相似性，我们没有记录这个软件包的大部分内容，我们建议您参考原始模块的非常好的文档。 11 | 12 | **`warning：`** 13 | 如果主要的进程突然退出(例如，因为输入信号)，Python中的`multiprocessing`有时会不能清理他的子节点。 14 | 15 | 这是一个已知的警告，所以如果您在中断解释器后看到任何资源泄漏，这可能意味着这刚刚发生在您身上。 16 | 17 | ## Strategy management 18 | ```python 19 | torch.multiprocessing.get_all_sharing_strategies() 20 | ``` 21 | 返回一组由当前系统所支持的共享策略 22 | 23 | ```python 24 | torch.multiprocessing.get_sharing_strategy() 25 | ``` 26 | 返回当前策略共享CPU中的张量。 27 | 28 | ```python 29 | torch.multiprocessing.set_sharing_strategy(new_strategy) 30 | ``` 31 | 设置共享CPU张量的策略 32 | 33 | 参数: new_strategy(str)-被选中策略的名字。应当是`get_all_sharing_strategies()`中值当中的一个。 34 | 35 | ## Sharing CUDA tensors 36 | 共享CUDA张量进程只支持Python3，使用`spawn`或者`forkserver`开始方法。 37 | 38 | Python2中的`multiprocessing`只能使用`fork`创建子进程，并且不被CUDA支持。 39 | 40 | **`warning：`** 41 | CUDA API要求导出到其他进程的分配一直保持有效，只要它们被使用。 42 | 43 | 你应该小心，确保您共享的CUDA张量不要超出范围。 44 | 45 | 这不应该是共享模型参数的问题，但传递其他类型的数据应该小心。请注意，此限制不适用于共享CPU内存。 46 | 47 | ## Sharing strategies 48 | 本节简要概述了不同的共享策略如何工作。 49 | 50 | 请注意，它仅适用于CPU张量 - CUDA张量将始终使用CUDA API，因为它们是唯一的共享方式。 51 | 52 | ### File descriptor-`file_descripor` 53 | **`NOTE：`** 54 | 这是默认策略（除了不支持的MacOS和OS X）。 55 | 56 | 此策略将使用文件描述符作为共享内存句柄。当存储被移动到共享内存中，一个由`shm_open`获得的文件描述符被缓存， 57 | 58 | 并且当它将被发送到其他进程时，文件描述符将被传送（例如通过UNIX套接字）。 59 | 60 | 接收者也将缓存文件描述符，并且`mmap`它，以获得对存储数据的共享视图。 61 | 62 | 请注意，如果要共享很多张量，则此策略将保留大量文件描述符。 63 | 64 | 如果你的系统对打开的文件描述符数量有限制，并且无法提高，你应该使用`file_system`策略。 65 | 66 | ### File system -file_system 67 | 这个策略将提供文件名称给`shm_open`去定义共享内存区域。 68 | 69 | 该策略不需要缓存从其获得的文件描述符的优点，但是容易发生共享内存泄漏。 70 | 71 | 该文件创建后不能被删除，因为其他进程需要访问它以打开其视图。 72 | 73 | 如果进程崩溃或死机，并且不能调用存储析构函数，则文件将保留在系统中。 74 | 75 | 这是非常严重的，因为它们在系统重新启动之前不断使用内存，或者手动释放它们。 76 | 77 | 为了记录共享内存文件泄露数量，`torch.multiprocessing`将产生一个守护进程叫做`torch_shm_manager` 78 | 79 | 将自己与当前进程组隔离，并且将跟踪所有共享内存分配。一旦连接到它的所有进程退出， 80 | 81 | 它将等待一会儿，以确保不会有新的连接，并且将遍历该组分配的所有共享内存文件。 82 | 83 | 如果发现它们中的任何一个仍然存在，它们将被释放。我们已经测试了这种方法，并且它已被证明对于各种故障都是稳健的。 84 | 85 | 如果你的系统有足够高的限制，并且`file_descriptor`是被支持的策略，我们不建议切换到这个。 86 | -------------------------------------------------------------------------------- /docs/notes/multiprocessing.md: -------------------------------------------------------------------------------- 1 | # 多进程最佳实践 2 | `torch.multiprocessing`是Python`multiprocessing`的替代品。它支持完全相同的操作，但扩展了它以便通过`multiprocessing.Queue`发送的所有张量将其数据移动到共享内存中，并且只会向其他进程发送一个句柄。 3 | 4 | > **Note** 5 | > 6 | > 当`Variable`发送到另一个进程时，`Variable.data`和`Variable.grad.data`都将被共享。 7 | 8 | 这允许实现各种训练方法，如Hogwild，A3C或需要异步操作的任何其他方法。 9 | 10 | ## 共享CUDA张量 11 | 仅在Python 3中使用`spawn`或`forkserver`启动方法才支持在进程之间共享CUDA张量。Python 2中的`multiprocessing`只能使用`fork`创建子进程，并且不被CUDA运行时所支持。 12 | 13 | >**Warning** 14 | > 15 | >CUDA API要求导出到其他进程的分配，只要它们被使用就要一直保持有效。您应该小心，确保您共享的CUDA张量只要有必要就不要超出范围。这不是共享模型参数的问题，但传递其他类型的数据应该小心。注意，此限制不适用于共享CPU内存。 16 | 17 | 参考：[使用 nn.DataParallel 替代 multiprocessing](cuda.md) 18 | 19 | ## 最佳实践和提示 20 | ### 避免和抵制死锁 21 | 当一个新进程被产生时，有很多事情可能会出错，最常见的死锁原因是后台线程。如果有任何线程持有锁或导入模块，并且`fork`被调用，则子进程很可能处于损坏的状态，并以不同的方式死锁或失败。注意，即使您没有，Python内置的库也可能会这样做 —— 不需要看得比`multiprocessing`更远。`multiprocessing.Queue`实际上是一个非常复杂的类，它产生用于序列化，发送和接收对象的多个线程，它们也可能引起上述问题。如果您发现自己处于这种情况，请尝试使用`multiprocessing.queues.SimpleQueue`，这不会使用任何其他线程。 22 | 23 | 我们正在竭尽全力把它设计得更简单，并确保这些死锁不会发生，但有些事情无法控制。如果有任何问题您无法一时无法解决，请尝试在论坛上提出，我们将看看是否可以解决问题。 24 | 25 | ### 重用经过队列的缓冲区 26 | 记住每次将`Tensor`放入`multiprocessing.Queue`时，必须将其移动到共享内存中。如果它已经被共享，它是一个无效的操作，否则会产生一个额外的内存副本，这会减缓整个进程。即使你有一个进程池来发送数据到一个进程，使它返回缓冲区 —— 这几乎是免费的，并且允许你在发送下一个batch时避免产生副本。 27 | 28 | ### 异步多进程训练（例如Hogwild） 29 | 使用`torch.multiprocessing`，可以异步地训练模型，参数可以一直共享，也可以定期同步。在第一种情况下，我们建议发送整个模型对象，而在后者中，我们建议只发送`state_dict()`。 30 | 31 | 我们建议使用`multiprocessing.Queue`来在进程之间传递各种PyTorch对象。例如，当使用fork启动方法时，可能会继承共享内存中的张量和存储器，但这是非常容易出错的，应谨慎使用，而且只能由高级用户使用。队列虽然有时是一个较不优雅的解决方案，但基本上能在所有情况下正常工作。 32 | 33 | > **Warning** 34 | > 你应该注意有关全局语句，它们没有被`if __name__ == '__main__'`保护。如果使用与`fork`不同的启动方法，则它们将在所有子进程中执行。 35 | 36 | #### Hogwild 37 | 在[examples repository](https://github.com/pytorch/examples/tree/master/mnist_hogwild)中可以找到具体的Hogwild实现，可以展示代码的整体结构。下面也有一个小例子： 38 | ```Python 39 | import torch.multiprocessing as mp 40 | from model import MyModel 41 | 42 | def train(model): 43 | # Construct data_loader, optimizer, etc. 44 | for data, labels in data_loader: 45 | optimizer.zero_grad() 46 | loss_fn(model(data), labels).backward() 47 | optimizer.step() # This will update the shared parameters 48 | 49 | if __name__ == '__main__': 50 | num_processes = 4 51 | model = MyModel() 52 | # NOTE: this is required for the ``fork`` method to work 53 | model.share_memory() 54 | processes = [] 55 | for rank in range(num_processes): 56 | p = mp.Process(target=train, args=(model,)) 57 | p.start() 58 | processes.append(p) 59 | for p in processes: 60 | p.join() 61 | ``` 62 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # pytorch-cn 2 | 3 | --- 4 | 5 | 本项目由[awfssv](https://github.com/awfssv), [ycszen](https://github.com/ycszen), [KeithYin](https://github.com/KeithYin), [kophy](https://github.com/kophy), [swordspoet](https://github.com/swordspoet), [dyl745001196](https://github.com/dyl745001196), [koshinryuu](https://github.com/koshinryuu), [tfygg](https://github.com/tfygg), [weigp](https://github.com/weigq), [ZijunDeng](https://github.com/ZijunDeng), [yichuan9527](https://github.com/yichuan9527)等PyTorch爱好者发起，并已获得PyTorch官方授权。我们目的是建立[PyTorch](http://pytorch.org/docs/)的中文文档，并力所能及地提供更多的帮助和建议。 6 | 7 | 本项目网址为[pytorch-cn](http://pytorch-cn.readthedocs.io/zh/latest/)，文档翻译QQ群：628478868 8 | 9 | 如果你在使用pytorch和pytorch-cn的过程中有任何问题，欢迎在issue中讨论，可能你的问题也是别人的问题。 10 | 11 | ## 翻译进度 12 | 现在正在进行审阅任务（大家赶紧认领吧～） 13 | 第一个名字代表翻译人，第二个代表审阅人 14 | ### Notes 15 | - [x] Autograd mechanics (*ycszen*)(DL-ljw) 16 | - [x] CUDA semantics (*ycszen*) 17 | - [x] Extending PyTorch (*KeithYin*) 18 | - [x] Multiprocessing best practices (*ycszen*) 19 | - [x] Serialization semantics (*ycszen*) 20 | 21 | ### Package Reference 22 | - [x] torch(*koshinryuu*)(飞彦) 23 | - [x] torch.Tensor(*weigp*)(飞彦) 24 | - [x] torch.Storage(*kophy*) 25 | - [ ] **torch.nn** 26 | - [x] Parameters(*KeithYin*) 27 | - [x] Containers(*KeithYin*) 28 | - [x] Convolution Layers(*yichuan9527*) 29 | - [x] Pooling Layers(*yichuan9527*) 30 | - [x] Non-linear Activations(*swordspoet*) 31 | - [x] Normalization layers(*XavierLin*) 32 | - [x] Recurrent layers(*KeithYin*)(Mosout) 33 | - [x] Linear layers( )(Mosout) 34 | - [x] Dropout layers( )(Mosout) 35 | - [x] Sparse layers(Mosout) 36 | - [x] Distance functions 37 | - [x] Loss functions(*KeithYin*)(DL-ljw) 38 | - [x] Vision layers(*KeithYin*) 39 | - [x] Multi-GPU layers(*KeithYin*) 40 | - [x] Utilities(*KeithYin*) 41 | - [x] torch.nn.functional 42 | - [x] Convolution functions(*ycszen*)(铁血丹心) 43 | - [x] Pooling functions(*ycszen*)(铁血丹心) 44 | - [x] Non-linear activations functions(*ycszen*) 45 | - [x] Normalization functions(*ycszen*) 46 | - [x] Linear functions(*dyl745001196*) 47 | - [x] Dropout functions(*dyl745001196*) 48 | - [x] Distance functions(*dyl745001196*) 49 | - [x] Loss functions(*tfygg*)(DL-ljw) 50 | - [x] Vision functions(*KeithYin*) 51 | - [x] torch.nn.init(*kophy*)(luc) 52 | - [x] torch.optim(*ZijunDeng*)(祁杰) 53 | - [x] torch.autograd(*KeithYin*)(祁杰) 54 | - [x] torch.multiprocessing(*songbo.han*) 55 | - [x] torch.legacy(*ycszen*) 56 | - [x] torch.cuda(*ycszen*) 57 | - [x] torch.utils.ffi(*ycszen*) 58 | - [x] torch.utils.data(*ycszen*) 59 | - [x] torch.utils.model_zoo(*ycszen*) 60 | 61 | ### torchvision Reference 62 | - [x] torchvision (*KeithYin*) 63 | - [x] torchvision.datasets (*KeithYin*)(loop) 64 | - [x] torchvision.models (*KeithYin*) 65 | - [x] torchvision.transforms (*KeithYin*)(loop) 66 | - [x] torchvision.utils (*KeithYin*) 67 | -------------------------------------------------------------------------------- /docs/torchvision/torchvision-transform.md: -------------------------------------------------------------------------------- 1 | # pytorch torchvision transform 2 | 3 | ## 对PIL.Image进行变换 4 | ### class torchvision.transforms.Compose(transforms) 5 | 将多个`transform`组合起来使用。 6 | 7 | `transforms`：由`transform`构成的列表. 8 | 例子： 9 | ```python 10 | transforms.Compose([ 11 | transforms.CenterCrop(10), 12 | transforms.ToTensor(), 13 | ]) 14 | ``` 15 | 16 | 17 | ### class torchvision.transforms.Scale(size, interpolation=2) 18 | 19 | 将输入的`PIL.Image`重新改变大小成给定的`size`，`size`是最小边的边长。举个例子，如果原图的`height>width`,那么改变大小后的图片大小是`(size*height/width, size)`。 20 | **用例:** 21 | ```python 22 | from torchvision import transforms 23 | from PIL import Image 24 | crop = transforms.Scale(12) 25 | img = Image.open('test.jpg') 26 | 27 | print(type(img)) 28 | print(img.size) 29 | 30 | croped_img=crop(img) 31 | print(type(croped_img)) 32 | print(croped_img.size) 33 | ``` 34 | ``` 35 | 36 | (10, 10) 37 | 38 | (12, 12) 39 | ``` 40 | 41 | ### class torchvision.transforms.CenterCrop(size) 42 | 将给定的`PIL.Image`进行中心切割，得到给定的`size`，`size`可以是`tuple`，`(target_height, target_width)`。`size`也可以是一个`Integer`，在这种情况下，切出来的图片的形状是正方形。 43 | 44 | ### class torchvision.transforms.RandomCrop(size, padding=0) 45 | 切割中心点的位置随机选取。`size`可以是`tuple`也可以是`Integer`。 46 | 47 | ### class torchvision.transforms.RandomHorizontalFlip 48 | 随机水平翻转给定的`PIL.Image`,概率为`0.5`。即：一半的概率翻转，一半的概率不翻转。 49 | 50 | ### class torchvision.transforms.RandomSizedCrop(size, interpolation=2) 51 | 先将给定的`PIL.Image`随机切，然后再`resize`成给定的`size`大小。 52 | ### class torchvision.transforms.Pad(padding, fill=0) 53 | 将给定的`PIL.Image`的所有边用给定的`pad value`填充。 54 | `padding：`要填充多少像素 55 | `fill：`用什么值填充 56 | 例子： 57 | ```python 58 | from torchvision import transforms 59 | from PIL import Image 60 | padding_img = transforms.Pad(padding=10, fill=0) 61 | img = Image.open('test.jpg') 62 | 63 | print(type(img)) 64 | print(img.size) 65 | 66 | padded_img=padding(img) 67 | print(type(padded_img)) 68 | print(padded_img.size) 69 | ``` 70 | ``` 71 | 72 | (10, 10) 73 | 74 | (30, 30) #由于上下左右都要填充10个像素，所以填充后的size是(30,30) 75 | ``` 76 | 77 | ## 对Tensor进行变换 78 | ### class torchvision.transforms.Normalize(mean, std) 79 | 给定均值：`(R,G,B)` 方差：`（R，G，B）`，将会把`Tensor`正则化。即：`Normalized_image=(image-mean)/std`。 80 | 81 | ## Conversion Transforms 82 | 83 | ### class torchvision.transforms.ToTensor 84 | 把一个取值范围是`[0,255]`的`PIL.Image`或者`shape`为`(H,W,C)`的`numpy.ndarray`，转换成形状为`[C,H,W]`，取值范围是`[0,1.0]`的`torch.FloadTensor` 85 | ```python 86 | data = np.random.randint(0, 255, size=300) 87 | img = data.reshape(10,10,3) 88 | print(img.shape) 89 | img_tensor = transforms.ToTensor()(img) # 转换成tensor 90 | print(img_tensor) 91 | ``` 92 | 93 | ### class torchvision.transforms.ToPILImage 94 | 将`shape`为`(C,H,W)`的`Tensor`或`shape`为`(H,W,C)`的`numpy.ndarray`转换成`PIL.Image`，值不变。 95 | 96 | ## 通用变换 97 | ### class torchvision.transforms.Lambda(lambd) 98 | 使用`lambd`作为转换器。 99 | -------------------------------------------------------------------------------- /docs/notes/autograd.md: -------------------------------------------------------------------------------- 1 | # 自动求导机制 2 | 3 | 本说明将概述Autograd如何工作并记录操作。了解这些并不是绝对必要的，但我们建议您熟悉它，因为它将帮助您编写更高效，更简洁的程序，并可帮助您进行调试。 4 | 5 | ## 从后向中排除子图 6 | 每个变量都有两个标志：`requires_grad`和`volatile`。它们都允许从梯度计算中精细地排除子图，并可以提高效率。 7 | 8 | ### `requires_grad` 9 | 如果有一个单一的输入操作需要梯度，它的输出也需要梯度。相反，只有所有输入都不需要梯度，输出才不需要。如果其中所有的变量都不需要梯度进行，后向计算不会在子图中执行。 10 | 11 | ```python 12 | >>> x = Variable(torch.randn(5, 5)) 13 | >>> y = Variable(torch.randn(5, 5)) 14 | >>> z = Variable(torch.randn(5, 5), requires_grad=True) 15 | >>> a = x + y 16 | >>> a.requires_grad 17 | False 18 | >>> b = a + z 19 | >>> b.requires_grad 20 | True 21 | ``` 22 | 这个标志特别有用，当您想要冻结部分模型时，或者您事先知道不会使用某些参数的梯度。例如，如果要对预先训练的CNN进行优化，只要切换冻结模型中的`requires_grad`标志就足够了，直到计算到最后一层才会保存中间缓冲区，其中的仿射变换将使用需要梯度的权重并且网络的输出也将需要它们。 23 | 24 | ```python 25 | model = torchvision.models.resnet18(pretrained=True) 26 | for param in model.parameters(): 27 | param.requires_grad = False 28 | # Replace the last fully-connected layer 29 | # Parameters of newly constructed modules have requires_grad=True by default 30 | model.fc = nn.Linear(512, 100) 31 | 32 | # Optimize only the classifier 33 | optimizer = optim.SGD(model.fc.parameters(), lr=1e-2, momentum=0.9) 34 | ``` 35 | 36 | ### `volatile` 37 | 纯粹的inference模式下推荐使用`volatile`，当你确定你甚至不会调用`.backward()`时。它比任何其他自动求导的设置更有效——它将使用绝对最小的内存来评估模型。`volatile`也决定了`require_grad is False`。 38 | 39 | `volatile`不同于`require_grad`的传递。如果一个操作甚至只有有一个`volatile`的输入，它的输出也将是`volatile`。`Volatility`比“不需要梯度”更容易传递——只需要一个`volatile`的输入即可得到一个`volatile`的输出，相对的，需要所有的输入“不需要梯度”才能得到不需要梯度的输出。使用volatile标志，您不需要更改模型参数的任何设置来用于inference。创建一个`volatile`的输入就够了，这将保证不会保存中间状态。 40 | ```python 41 | >>> regular_input = Variable(torch.randn(5, 5)) 42 | >>> volatile_input = Variable(torch.randn(5, 5), volatile=True) 43 | >>> model = torchvision.models.resnet18(pretrained=True) 44 | >>> model(regular_input).requires_grad 45 | True 46 | >>> model(volatile_input).requires_grad 47 | False 48 | >>> model(volatile_input).volatile 49 | True 50 | >>> model(volatile_input).creator is None 51 | True 52 | ``` 53 | 54 | ## 自动求导如何编码历史信息 55 | 每个变量都有一个`.creator`属性，它指向把它作为输出的函数。这是一个由`Function`对象作为节点组成的有向无环图（DAG）的入口点，它们之间的引用就是图的边。每次执行一个操作时，一个表示它的新`Function`就被实例化，它的`forward()`方法被调用，并且它输出的`Variable`的创建者被设置为这个`Function`。然后，通过跟踪从任何变量到叶节点的路径，可以重建创建数据的操作序列，并自动计算梯度。 56 | 57 | 需要注意的一点是，整个图在每次迭代时都是从头开始重新创建的，这就允许使用任意的Python控制流语句，这样可以在每次迭代时改变图的整体形状和大小。在启动训练之前不必对所有可能的路径进行编码—— what you run is what you differentiate. 58 | 59 | ## Variable上的In-place操作 60 | 在自动求导中支持in-place操作是一件很困难的事情，我们在大多数情况下都不鼓励使用它们。Autograd的缓冲区释放和重用非常高效，并且很少场合下in-place操作能实际上明显降低内存的使用量。除非您在内存压力很大的情况下，否则您可能永远不需要使用它们。 61 | 62 | 限制in-place操作适用性主要有两个原因： 63 | 64 | １．覆盖梯度计算所需的值。这就是为什么变量不支持`log_`。它的梯度公式需要原始输入，而虽然通过计算反向操作可以重新创建它，但在数值上是不稳定的，并且需要额外的工作，这往往会与使用这些功能的目的相悖。 65 | 66 | ２．每个in-place操作实际上需要实现重写计算图。不合适的版本只需分配新对象并保留对旧图的引用，而in-place操作则需要将所有输入的`creator`更改为表示此操作的`Function`。这就比较棘手，特别是如果有许多变量引用相同的存储（例如通过索引或转置创建的），并且如果被修改输入的存储被任何其他`Variable`引用，则in-place函数实际上会抛出错误。 67 | 68 | ## In-place正确性检查 69 | 每个变量保留有version counter，它每次都会递增，当在任何操作中被使用时。当`Function`保存任何用于后向的tensor时，还会保存其包含变量的version counter。一旦访问`self.saved_tensors`，它将被检查，如果它大于保存的值，则会引起错误。 70 | -------------------------------------------------------------------------------- /docs/torchvision/torchvision-models.md: -------------------------------------------------------------------------------- 1 | # torchvision.models 2 | `torchvision.models`模块的子模块中包含以下模型结构。 3 | 4 | - AlexNet 5 | - VGG 6 | - ResNet 7 | - SqueezeNet 8 | - DenseNet 9 | You can construct a model with random weights by calling its constructor: 10 | 11 | 你可以使用随机初始化的权重来创建这些模型。 12 | ```python 13 | import torchvision.models as models 14 | resnet18 = models.resnet18() 15 | alexnet = models.alexnet() 16 | squeezenet = models.squeezenet1_0() 17 | densenet = models.densenet_161() 18 | ``` 19 | We provide pre-trained models for the ResNet variants and AlexNet, using the PyTorch torch.utils.model_zoo. These can constructed by passing pretrained=True: 20 | 对于`ResNet variants`和`AlexNet`，我们也提供了预训练(`pre-trained`)的模型。 21 | ```python 22 | import torchvision.models as models 23 | #pretrained=True就可以使用预训练的模型 24 | resnet18 = models.resnet18(pretrained=True) 25 | alexnet = models.alexnet(pretrained=True) 26 | ``` 27 | ImageNet 1-crop error rates (224x224) 28 | 29 | |Network |Top-1 error |Top-5 error| 30 | |------|------|------| 31 | |ResNet-18| 30.24| 10.92| 32 | |ResNet-34| 26.70| 8.58| 33 | |ResNet-50 |23.85 |7.13| 34 | |ResNet-101| 22.63| 6.44| 35 | |ResNet-152 |21.69 |5.94| 36 | |Inception v3| 22.55| 6.44| 37 | |AlexNet |43.45 |20.91| 38 | |VGG-11| 30.98| 11.37| 39 | |VGG-13 |30.07 |10.75| 40 | |VGG-16| 28.41| 9.62| 41 | |VGG-19 |27.62 |9.12| 42 | |SqueezeNet 1.0| 41.90| 19.58| 43 | |SqueezeNet 1.1 |41.81 |19.38| 44 | |Densenet-121| 25.35| 7.83| 45 | |Densenet-169 |24.00 |7.00| 46 | |Densenet-201| 22.80| 6.43| 47 | |Densenet-161| 22.35 |6.20| 48 | 49 | ## torchvision.models.alexnet(pretrained=False, ** kwargs) 50 | `AlexNet` 模型结构 [paper地址](https://arxiv.org/abs/1404.5997) 51 | 52 | - pretrained (bool) – `True`, 返回在ImageNet上训练好的模型。 53 | 54 | ## torchvision.models.resnet18(pretrained=False, ** kwargs) 55 | 构建一个`resnet18`模型 56 | 57 | - pretrained (bool) – `True`, 返回在ImageNet上训练好的模型。 58 | 59 | ## torchvision.models.resnet34(pretrained=False, ** kwargs) 60 | 构建一个`ResNet-34` 模型. 61 | 62 | Parameters: pretrained (bool) – `True`, 返回在ImageNet上训练好的模型。 63 | 64 | ## torchvision.models.resnet50(pretrained=False, ** kwargs) 65 | 构建一个`ResNet-50`模型 66 | 67 | - pretrained (bool) – `True`, 返回在ImageNet上训练好的模型。 68 | 69 | ## torchvision.models.resnet101(pretrained=False, ** kwargs) 70 | Constructs a ResNet-101 model. 71 | 72 | - pretrained (bool) – `True`, 返回在ImageNet上训练好的模型。 73 | 74 | ## torchvision.models.resnet152(pretrained=False, ** kwargs) 75 | Constructs a ResNet-152 model. 76 | 77 | - pretrained (bool) – `True`, 返回在ImageNet上训练好的模型。 78 | 79 | ## torchvision.models.vgg11(pretrained=False, ** kwargs) 80 | VGG 11-layer model (configuration “A”) 81 | - pretrained (bool) – `True`, 返回在ImageNet上训练好的模型。 82 | 83 | ## torchvision.models.vgg11_bn(** kwargs) 84 | VGG 11-layer model (configuration “A”) with batch normalization 85 | 86 | ## torchvision.models.vgg13(pretrained=False, ** kwargs) 87 | VGG 13-layer model (configuration “B”) 88 | 89 | - pretrained (bool) – `True`, 返回在ImageNet上训练好的模型。 90 | 91 | ## torchvision.models.vgg13_bn(** kwargs) 92 | VGG 13-layer model (configuration “B”) with batch normalization 93 | 94 | ## torchvision.models.vgg16(pretrained=False, ** kwargs) 95 | VGG 16-layer model (configuration “D”) 96 | 97 | Parameters: pretrained (bool) – If True, returns a model pre-trained on ImageNet 98 | ## torchvision.models.vgg16_bn(** kwargs) 99 | VGG 16-layer model (configuration “D”) with batch normalization 100 | 101 | ## torchvision.models.vgg19(pretrained=False, ** kwargs) 102 | VGG 19-layer model (configuration “E”) 103 | 104 | - pretrained (bool) – `True`, 返回在ImageNet上训练好的模型。 105 | ## torchvision.models.vgg19_bn(** kwargs) 106 | VGG 19-layer model (configuration ‘E’) with batch normalization 107 | -------------------------------------------------------------------------------- /docs/torchvision/torchvision-datasets.md: -------------------------------------------------------------------------------- 1 | # torchvision.datasets 2 | `torchvision.datasets`中包含了以下数据集 3 | 4 | - MNIST 5 | - COCO（用于图像标注和目标检测）(Captioning and Detection) 6 | - LSUN Classification 7 | - ImageFolder 8 | - Imagenet-12 9 | - CIFAR10 and CIFAR100 10 | - STL10 11 | 12 | `Datasets` 拥有以下`API`: 13 | 14 | `__getitem__` 15 | `__len__` 16 | 17 | 由于以上`Datasets`都是 `torch.utils.data.Dataset`的子类，所以，他们也可以通过`torch.utils.data.DataLoader`使用多线程（python的多进程）。 18 | 19 | 举例说明： 20 | `torch.utils.data.DataLoader(coco_cap, batch_size=args.batchSize, shuffle=True, num_workers=args.nThreads)` 21 | 22 | 在构造函数中，不同的数据集直接的构造函数会有些许不同，但是他们共同拥有 `keyword` 参数。 23 | In the constructor, each dataset has a slightly different API as needed, but they all take the keyword args: 24 | - `transform`：一个函数，原始图片作为输入，返回一个转换后的图片。（详情请看下面关于`torchvision-tranform`的部分） 25 | 26 | - `target_transform` - 一个函数，输入为`target`，输出对其的转换。例子，输入的是图片标注的`string`，输出为`word`的索引。 27 | ## MNIST 28 | ```python 29 | dset.MNIST(root, train=True, transform=None, target_transform=None, download=False) 30 | ``` 31 | 参数说明： 32 | - root : `processed/training.pt` 和 `processed/test.pt` 的主目录 33 | - train : `True` = 训练集, `False` = 测试集 34 | - download : `True` = 从互联网上下载数据集，并把数据集放在`root`目录下. 如果数据集之前下载过，将处理过的数据（minist.py中有相关函数）放在`processed`文件夹下。 35 | 36 | ## COCO 37 | 需要安装[COCO API](https://github.com/pdollar/coco/tree/master/PythonAPI) 38 | 39 | ### 图像标注: 40 | ```python 41 | dset.CocoCaptions(root="dir where images are", annFile="json annotation file", [transform, target_transform]) 42 | ``` 43 | 例子: 44 | ```python 45 | import torchvision.datasets as dset 46 | import torchvision.transforms as transforms 47 | cap = dset.CocoCaptions(root = 'dir where images are', 48 | annFile = 'json annotation file', 49 | transform=transforms.ToTensor()) 50 | 51 | print('Number of samples: ', len(cap)) 52 | img, target = cap[3] # load 4th sample 53 | 54 | print("Image Size: ", img.size()) 55 | print(target) 56 | ``` 57 | 输出: 58 | ``` 59 | Number of samples: 82783 60 | Image Size: (3L, 427L, 640L) 61 | [u'A plane emitting smoke stream flying over a mountain.', 62 | u'A plane darts across a bright blue sky behind a mountain covered in snow', 63 | u'A plane leaves a contrail above the snowy mountain top.', 64 | u'A mountain that has a plane flying overheard in the distance.', 65 | u'A mountain view with a plume of smoke in the background'] 66 | ``` 67 | ### 检测: 68 | ``` 69 | dset.CocoDetection(root="dir where images are", annFile="json annotation file", [transform, target_transform]) 70 | ``` 71 | ## LSUN 72 | ```python 73 | dset.LSUN(db_path, classes='train', [transform, target_transform]) 74 | ``` 75 | 参数说明： 76 | - db_path = 数据集文件的根目录 77 | - classes = ‘train’ (所有类别, 训练集), ‘val’ (所有类别, 验证集), ‘test’ (所有类别, 测试集) 78 | [‘bedroom\_train’, ‘church\_train’, …] : a list of categories to load 79 | ## ImageFolder 80 | 一个通用的数据加载器，数据集中的数据以以下方式组织 81 | ``` 82 | root/dog/xxx.png 83 | root/dog/xxy.png 84 | root/dog/xxz.png 85 | 86 | root/cat/123.png 87 | root/cat/nsdf3.png 88 | root/cat/asd932_.png 89 | ``` 90 | ```python 91 | dset.ImageFolder(root="root folder path", [transform, target_transform]) 92 | ``` 93 | 他有以下成员变量: 94 | 95 | - self.classes - 用一个list保存类名 96 | - self.class_to_idx - 类名对应的索引 97 | - self.imgs - 保存(img-path, class) tuple的list 98 | 99 | ## Imagenet-12 100 | This is simply implemented with an ImageFolder dataset. 101 | 102 | The data is preprocessed [as described here](https://github.com/facebook/fb.resnet.torch/blob/master/INSTALL.md#download-the-imagenet-dataset) 103 | 104 | [Here is an example](https://github.com/pytorch/examples/blob/27e2a46c1d1505324032b1d94fc6ce24d5b67e97/imagenet/main.py#L48-L62) 105 | 106 | ## CIFAR 107 | ```python 108 | dset.CIFAR10(root, train=True, transform=None, target_transform=None, download=False) 109 | 110 | dset.CIFAR100(root, train=True, transform=None, target_transform=None, download=False) 111 | ``` 112 | 参数说明： 113 | - root : `cifar-10-batches-py` 的根目录 114 | - train : `True` = 训练集, `False` = 测试集 115 | - download : `True` = 从互联上下载数据，并将其放在`root`目录下。如果数据集已经下载，什么都不干。 116 | ## STL10 117 | ```python 118 | dset.STL10(root, split='train', transform=None, target_transform=None, download=False) 119 | ``` 120 | 参数说明： 121 | - root : `stl10_binary`的根目录 122 | - split : 'train' = 训练集, 'test' = 测试集, 'unlabeled' = 无标签数据集, 'train+unlabeled' = 训练 + 无标签数据集 (没有标签的标记为-1) 123 | - download : `True` = 从互联上下载数据，并将其放在`root`目录下。如果数据集已经下载，什么都不干。 124 | -------------------------------------------------------------------------------- /docs/package_references/torch-cuda.md: -------------------------------------------------------------------------------- 1 | # torch.cuda 2 | 该包增加了对CUDA张量类型的支持，实现了与CPU张量相同的功能，但使用GPU进行计算。 3 | 4 | 它是懒惰的初始化，所以你可以随时导入它，并使用`is_available()`来确定系统是否支持CUDA。 5 | 6 | [CUDA语义](../notes/cuda.md)中有关于使用CUDA的更多细节。 7 | 8 | ```python 9 | torch.cuda.current_blas_handle() 10 | ``` 11 | 返回cublasHandle_t指针，指向当前cuBLAS句柄 12 | 13 | ```python 14 | torch.cuda.current_device() 15 | ``` 16 | 返回当前所选设备的索引。 17 | 18 | ```python 19 | torch.cuda.current_stream() 20 | ``` 21 | 返回一个当前所选的`Stream` 22 | 23 | ```python 24 | class torch.cuda.device(idx) 25 | ``` 26 | 上下文管理器，可以更改所选设备。 27 | 28 | **参数：** 29 | - **idx** (*int*) – 设备索引选择。如果这个参数是负的，则是无效操作。 30 | 31 | ```python 32 | torch.cuda.device_count() 33 | ``` 34 | 返回可得到的GPU数量。 35 | 36 | ```python 37 | class torch.cuda.device_of(obj) 38 | ``` 39 | 40 | 将当前设备更改为给定对象的上下文管理器。 41 | 42 | 可以使用张量和存储作为参数。如果给定的对象不是在GPU上分配的，这是一个无效操作。 43 | 44 | **参数：** 45 | - **obj** (*Tensor* or *Storage*) – 在选定设备上分配的对象。 46 | 47 | ```python 48 | torch.cuda.is_available() 49 | ``` 50 | 返回一个bool值，指示CUDA当前是否可用。 51 | 52 | ```python 53 | torch.cuda.set_device(device) 54 | ``` 55 | 设置当前设备。 56 | 57 | 不鼓励使用此函数来设置。在大多数情况下，最好使用`CUDA_VISIBLE_DEVICES`环境变量。 58 | 59 | **参数：** 60 | - **device** (*int*) – 所选设备。如果此参数为负，则此函数是无效操作。 61 | 62 | ```python 63 | torch.cuda.stream(stream) 64 | ``` 65 | 选择给定流的上下文管理器。 66 | 67 | 在其上下文中排队的所有CUDA核心将在所选流上入队。 68 | 69 | **参数：** 70 | - **stream** (*Stream*) – 所选流。如果是`None`，则这个管理器是无效的。 71 | 72 | ```python 73 | torch.cuda.synchronize() 74 | ``` 75 | 等待当前设备上所有流中的所有核心完成。 76 | 77 | ## 交流集 78 | ```python 79 | torch.cuda.comm.broadcast(tensor, devices) 80 | ``` 81 | 向一些GPU广播张量。 82 | 83 | **参数：** 84 | - **tensor** (*Tensor*) – 将要广播的张量 85 | - **devices** (*Iterable*) – 一个可以广播的设备的迭代。注意，它的形式应该像（src，dst1，dst2，...），其第一个元素是广播来源的设备。 86 | 87 | **返回：** 一个包含张量副本的元组，放置在与设备的索引相对应的设备上。 88 | 89 | ```python 90 | torch.cuda.comm.reduce_add(inputs, destination=None) 91 | ``` 92 | 将来自多个GPU的张量相加。 93 | 94 | 所有输入应具有匹配的形状。 95 | 96 | **参数：** 97 | - **inputs** (*Iterable[Tensor]*) – 要相加张量的迭代 98 | - **destination** (*int*, optional) – 将放置输出的设备（默认值：当前设备）。 99 | 100 | **返回：** 一个包含放置在`destination`设备上的所有输入的元素总和的张量。 101 | 102 | ```python 103 | torch.cuda.comm.scatter(tensor, devices, chunk_sizes=None, dim=0, streams=None) 104 | ``` 105 | 打散横跨多个GPU的张量。 106 | 107 | **参数：** 108 | - **tensor** (*Tensor*) – 要分散的张量 109 | - **devices** (*Iterable[int]*) – int的迭代，指定哪些设备应该分散张量。 110 | - **chunk_sizes** (*Iterable[int]*, optional) – 要放置在每个设备上的块大小。它应该匹配`devices`的长度并且总和为`tensor.size(dim)`。如果没有指定，张量将被分成相等的块。 111 | - **dim** (*int*, optional) – 沿着这个维度来chunk张量 112 | 113 | **返回：** 包含`tensor`块的元组，分布在给定的`devices`上。 114 | 115 | ```python 116 | torch.cuda.comm.gather(tensors, dim=0, destination=None) 117 | ``` 118 | 从多个GPU收集张量。 119 | 120 | 张量尺寸在不同于`dim`的所有维度上都应该匹配。 121 | 122 | **参数：** 123 | - **tensors** (*Iterable[Tensor]*) – 要收集的张量的迭代。 124 | - **dim** (*int*) – 沿着此维度张量将被连接。 125 | - **destination** (*int*, optional) – 输出设备（-1表示CPU，默认值：当前设备）。 126 | 127 | **返回：** 一个张量位于`destination`设备上，这是沿着`dim`连接`tensors`的结果。 128 | 129 | ## 流和事件 130 | ```python 131 | class torch.cuda.Stream 132 | ``` 133 | CUDA流的包装。 134 | 135 | **参数：** 136 | - **device** (*int*, optional) – 分配流的设备。 137 | - **priority** (*int*, optional) – 流的优先级。较低的数字代表较高的优先级。 138 | 139 | > query() 140 | 141 | 检查所有提交的工作是否已经完成。 142 | 143 | **返回：** 一个布尔值，表示此流中的所有核心是否完成。 144 | 145 | > record_event(event=None) 146 | 147 | 记录一个事件。 148 | 149 | **参数：** **event** (*Event*, optional) – 要记录的事件。如果没有给出，将分配一个新的。 150 | **返回：** 记录的事件。 151 | 152 | > synchronize() 153 | 154 | 等待此流中的所有核心完成。 155 | 156 | > wait_event(event) 157 | 158 | 将所有未来的工作提交到流等待事件。 159 | 160 | **参数：** **event** (*Event*) – 等待的事件 161 | 162 | > wait_stream(stream) 163 | 164 | 与另一个流同步。 165 | 166 | 提交到此流的所有未来工作将等待直到所有核心在调用完成时提交给给定的流。 167 | 168 | ```python 169 | class torch.cuda.Event(enable_timing=False, blocking=False, interprocess=False, _handle=None) 170 | ``` 171 | 172 | CUDA事件的包装。 173 | 174 | **参数：** 175 | - **enable_timing** (*bool*) – 指示事件是否应该测量时间（默认值：False） 176 | - **blocking** (*bool*) – 如果为true，`wait()`将被阻塞（默认值：False） 177 | - **interprocess** (*bool*) – 如果为true，则可以在进程之间共享事件（默认值：False） 178 | 179 | > elapsed_time(end_event) 180 | 181 | 返回事件记录之前经过的时间。 182 | 183 | > ipc_handle() 184 | 185 | 返回此事件的IPC句柄。 186 | 187 | > query() 188 | 189 | 检查事件是否已被记录。 190 | 191 | **返回：** 一个布尔值，指示事件是否已被记录。 192 | 193 | > record(stream=None) 194 | 195 | 记录给定流的事件。 196 | 197 | > synchronize() 198 | 199 | 与事件同步。 200 | 201 | > wait(stream=None) 202 | 203 | 使给定的流等待事件。 204 | -------------------------------------------------------------------------------- /docs/package_references/nn_init.md: -------------------------------------------------------------------------------- 1 | # torch.nn.init 2 | 3 | ```python 4 | torch.nn.init.calculate_gain(nonlinearity,param=None) 5 | ``` 6 | 7 | 对于给定的非线性函数，返回推荐的增益值。这些值如下所示： 8 | 9 | 10 | | nonlinearity | gain | 11 | | ------------ | ---------------------------- | 12 | | linear | 1 | 13 | | conv{1,2,3}d | 1 | 14 | | sigmoid | 1 | 15 | | tanh | 5/3 | 16 | | relu | sqrt(2) | 17 | | leaky_relu | sqrt(2/(1+negative_slope^2)) | 18 | 19 | **参数：** 20 | 21 | - **nonlinearity** - 非线性函数（`nn.functional`名称） 22 | - **param** - 非线性函数的可选参数 23 | 24 | **例子：** 25 | 26 | ```python 27 | >>> gain = nn.init.gain('leaky_relu') 28 | ``` 29 | 30 | ```python 31 | torch.nn.init.uniform(tensor, a=0, b=1) 32 | ``` 33 | 34 | 从均匀分布U(a, b)中生成值，填充输入的张量或变量 35 | 36 | **参数：** 37 | 38 | - **tensor** - n维的torch.Tensor 39 | - **a** - 均匀分布的下界 40 | - **b** - 均匀分布的上界 41 | 42 | **例子** 43 | 44 | ```python 45 | >>> w = torch.Tensor(3, 5) 46 | >>> nn.init.uniform(w) 47 | ``` 48 | 49 | ```python 50 | torch.nn.init.normal(tensor, mean=0, std=1) 51 | ``` 52 | 53 | 从给定均值和标准差的正态分布N(mean, std)中生成值，填充输入的张量或变量 54 | 55 | **参数：** 56 | 57 | - **tensor** – n维的torch.Tensor 58 | - **mean** – 正态分布的均值 59 | - **std** – 正态分布的标准差 60 | 61 | **例子** 62 | 63 | ```python 64 | >>> w = torch.Tensor(3, 5) 65 | >>> nn.init.normal(w) 66 | ``` 67 | 68 | ```python 69 | torch.nn.init.constant(tensor, val) 70 | ``` 71 | 72 | 用*val*的值填充输入的张量或变量 73 | 74 | **参数：** 75 | 76 | - **tensor** – n维的torch.Tensor或autograd.Variable 77 | - **val** – 用来填充张量的值 78 | 79 | **例子：** 80 | 81 | ```python 82 | >>> w = torch.Tensor(3, 5) 83 | >>> nn.init.constant(w) 84 | ``` 85 | 86 | ```python 87 | torch.nn.init.eye(tensor) 88 | ``` 89 | 90 | 用单位矩阵来填充2维输入张量或变量。在线性层尽可能多的保存输入特性。 91 | 92 | **参数：** 93 | 94 | - **tensor** – 2维的torch.Tensor或autograd.Variable 95 | 96 | **例子：** 97 | 98 | ```python 99 | >>> w = torch.Tensor(3, 5) 100 | >>> nn.init.eye(w) 101 | ``` 102 | 103 | ```python 104 | torch.nn.init.dirac(tensor) 105 | ``` 106 | 107 | 用Dirac $\delta$ 函数来填充{3, 4, 5}维输入张量或变量。在卷积层尽可能多的保存输入通道特性。 108 | 109 | **参数：** 110 | 111 | - **tensor** – {3, 4, 5}维的torch.Tensor或autograd.Variable 112 | 113 | **例子：** 114 | 115 | ```python 116 | >>> w = torch.Tensor(3, 16, 5, 5) 117 | >>> nn.init.dirac(w) 118 | ``` 119 | 120 | ```python 121 | torch.nn.init.xavier_uniform(tensor, gain=1) 122 | ``` 123 | 124 | 根据Glorot, X.和Bengio, Y.在“Understanding the difficulty of training deep feedforward neural networks”中描述的方法，用一个均匀分布生成值，填充输入的张量或变量。结果张量中的值采样自U(-a, a)，其中a= gain * sqrt( 2/(fan_in + fan_out))* sqrt(3). 该方法也被称为Glorot initialisation 125 | 126 | **参数：** 127 | 128 | - **tensor** – n维的torch.Tensor 129 | - **gain** - 可选的缩放因子 130 | 131 | **例子：** 132 | 133 | ```python 134 | >>> w = torch.Tensor(3, 5) 135 | >>> nn.init.xavier_uniform(w, gain=math.sqrt(2.0)) 136 | ``` 137 | 138 | ```python 139 | torch.nn.init.xavier_normal(tensor, gain=1) 140 | ``` 141 | 142 | 根据Glorot, X.和Bengio, Y. 于2010年在“Understanding the difficulty of training deep feedforward neural networks”中描述的方法，用一个正态分布生成值，填充输入的张量或变量。结果张量中的值采样自均值为0，标准差为gain * sqrt(2/(fan_in + fan_out))的正态分布。也被称为Glorot initialisation. 143 | 144 | **参数：** 145 | 146 | - **tensor** – n维的torch.Tensor 147 | - **gain** - 可选的缩放因子 148 | 149 | **例子：** 150 | 151 | ```python 152 | >>> w = torch.Tensor(3, 5) 153 | >>> nn.init.xavier_normal(w) 154 | ``` 155 | 156 | ```python 157 | torch.nn.init.kaiming_uniform(tensor, a=0, mode='fan_in') 158 | ``` 159 | 160 | 根据He, K等人于2015年在“Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification”中描述的方法，用一个均匀分布生成值，填充输入的张量或变量。结果张量中的值采样自U(-bound, bound)，其中bound = sqrt(2/((1 + a^2) * fan_in)) * sqrt(3)。也被称为He initialisation. 161 | 162 | **参数：** 163 | 164 | - **tensor** – n维的torch.Tensor或autograd.Variable 165 | - **a** -这层之后使用的rectifier的斜率系数（ReLU的默认值为0） 166 | - **mode** -可以为“fan_in”（默认）或“fan_out”。“fan_in”保留前向传播时权值方差的量级，“fan_out”保留反向传播时的量级。 167 | 168 | **例子：** 169 | 170 | ```python 171 | >>> w = torch.Tensor(3, 5) 172 | >>> nn.init.kaiming_uniform(w, mode='fan_in') 173 | ``` 174 | 175 | ```python 176 | torch.nn.init.kaiming_normal(tensor, a=0, mode='fan_in') 177 | ``` 178 | 179 | 根据He, K等人在“Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification”中描述的方法，用一个正态分布生成值，填充输入的张量或变量。结果张量中的值采样自均值为0，标准差为sqrt(2/((1 + a^2) * fan_in))的正态分布。 180 | 181 | **参数：** 182 | 183 | - **tensor** – n维的torch.Tensor或 autograd.Variable 184 | - **a** -这层之后使用的rectifier的斜率系数（ReLU的默认值为0） 185 | - **mode** -可以为“fan_in”（默认）或“fan_out”。“fan_in”保留前向传播时权值方差的量级，“fan_out”保留反向传播时的量级。 186 | 187 | **例子：** 188 | 189 | ```python 190 | >>> w = torch.Tensor(3, 5) 191 | >>> nn.init.kaiming_normal(w, mode='fan_out') 192 | ``` 193 | 194 | ```python 195 | torch.nn.init.orthogonal(tensor, gain=1) 196 | ``` 197 | 198 | 用（半）正交矩阵填充输入的张量或变量。输入张量必须至少是2维的，对于更高维度的张量，超出的维度会被展平，视作行等于第一个维度，列等于稀疏矩阵乘积的2维表示。其中非零元素生成自均值为0，标准差为std的正态分布。 199 | 200 | 参考：Saxe, A等人(2013)的“Exact solutions to the nonlinear dynamics of learning in deep linear neural networks” 201 | 202 | **参数：** 203 | 204 | - **tensor** – n维的torch.Tensor或 autograd.Variable，其中n>=2 205 | - **gain** -可选 206 | 207 | **例子：** 208 | 209 | ```python 210 | >>> w = torch.Tensor(3, 5) 211 | >>> nn.init.orthogonal(w) 212 | ``` 213 | 214 | ```python 215 | torch.nn.init.sparse(tensor, sparsity, std=0.01) 216 | ``` 217 | 218 | 将2维的输入张量或变量当做稀疏矩阵填充，其中非零元素根据一个均值为0，标准差为std的正态分布生成。 219 | 参考Martens, J.(2010)的 “Deep learning via Hessian-free optimization”. 220 | 221 | **参数：** 222 | 223 | - **tensor** – n维的torch.Tensor或autograd.Variable 224 | - **sparsity** - 每列中需要被设置成零的元素比例 225 | - **std** - 用于生成非零值的正态分布的标准差 226 | 227 | **例子：** 228 | ```python 229 | >>> w = torch.Tensor(3, 5) 230 | >>> nn.init.sparse(w, sparsity=0.1) 231 | ``` -------------------------------------------------------------------------------- /docs/notes/extending.md: -------------------------------------------------------------------------------- 1 | # 扩展PyTorch 2 | 本篇文章中包含如何扩展 `torch.nn`, `torch.autograd`和使用我们的 `C 库`编写自定义的`C`扩展。 3 | 4 | 5 | ## 扩展 torch.autograd 6 | 如果你想要添加一个新的 `Operation` 到`autograd`的话，你的`Operation`需要继承 `class Function`。`autograd`使用`Function`计算结果和梯度，同时编码 `operation`的历史。每个新的 `operation(function)` 都需要实现三个方法： 7 | 8 | - `__init__ (optional)` - 如果你的`operation`包含非`Variable`参数，那么就将其作为`__init__`的参数传入到`operation`中。例如：`AddConstant Function`加一个常数，`Transpose Function`需要指定哪两个维度需要交换。如果你的`operation`不需要额外的参数，你可以忽略`__init__`。 9 | 10 | - `forward()` - 在里面写执行此`operation`的代码。可以有任意数量的参数。如果你对某些参数指定了默认值，则这些参数是可传可不传的。记住：`forward()`的参数只能是`Variable`。函数的返回值既可以是 `Variable`也可以是`Variables`的`tuple`。同时，请参考 `Function`[function]的 `doc`，查阅有哪些方法是只能在`forward`中调用的。 11 | - `backward()` - 梯度计算公式。参数的个数和`forward`返回值的个数一样，每个参数代表传回到此`operation`的梯度. `backward()`的返回值的个数应该和此`operation`输入的个数一样，每个返回值对应了输入值的梯度。如果`operation`的输入不需要梯度，或者不可导，你可以返回`None`。如果`forward()`存在可选参数，你可以返回比输入更多的梯度，只是返回的是`None`。 12 | 13 | 下面是 `Linear` 的实现代码： 14 | 15 | ```python 16 | # Inherit from Function 17 | class Linear(Function): 18 | 19 | # bias is an optional argument 20 | def forward(self, input, weight, bias=None): 21 | self.save_for_backward(input, weight, bias) 22 | output = input.mm(weight.t()) 23 | if bias is not None: 24 | output += bias.unsqueeze(0).expand_as(output) 25 | return output 26 | 27 | # This function has only a single output, so it gets only one gradient 28 | def backward(self, grad_output): 29 | # This is a pattern that is very convenient - at the top of backward 30 | # unpack saved_tensors and initialize all gradients w.r.t. inputs to 31 | # None. Thanks to the fact that additional trailing Nones are 32 | # ignored, the return statement is simple even when the function has 33 | # optional inputs. 34 | input, weight, bias = self.saved_tensors 35 | grad_input = grad_weight = grad_bias = None 36 | 37 | # These needs_input_grad checks are optional and there only to 38 | # improve efficiency. If you want to make your code simpler, you can 39 | # skip them. Returning gradients for inputs that don't require it is 40 | # not an error. 41 | if self.needs_input_grad[0]: 42 | grad_input = grad_output.mm(weight) 43 | if self.needs_input_grad[1]: 44 | grad_weight = grad_output.t().mm(input) 45 | if bias is not None and self.needs_input_grad[2]: 46 | grad_bias = grad_output.sum(0).squeeze(0) 47 | 48 | return grad_input, grad_weight, grad_bias 49 | ``` 50 | 现在，为了可以更简单的使用自定义的`operation`，我们建议将其用一个简单的 `helper function` 包装起来。 functions: 51 | 52 | ```python 53 | def linear(input, weight, bias=None): 54 | # First braces create a Function object. Any arguments given here 55 | # will be passed to __init__. Second braces will invoke the __call__ 56 | # operator, that will then use forward() to compute the result and 57 | # return it. 58 | return Linear()(input, weight, bias) 59 | ``` 60 | 61 | 你可能想知道你刚刚实现的 `backward`方法是否正确的计算了梯度。你可以使用小的有限的差分进行数值估计。 62 | 63 | ```python 64 | from torch.autograd import gradcheck 65 | 66 | # gradchek takes a tuple of tensor as input, check if your gradient 67 | # evaluated with these tensors are close enough to numerical 68 | # approximations and returns True if they all verify this condition. 69 | input = (Variable(torch.randn(20,20).double(), requires_grad=True),) 70 | test = gradcheck.gradcheck(Linear(), input, eps=1e-6, atol=1e-4) 71 | print(test) 72 | ``` 73 | 74 | ## 扩展 torch.nn 75 | 76 | `nn` 包含两种接口 - `modules`和他们的`functional`版本。通过这两个接口，你都可以扩展`nn`。但是我们建议，在扩展`layer`的时候，使用`modules`，因为`modules`保存着参数和`buffer`。如果不需要参数的话，那么建议使用`functional`(激活函数，pooling，这些都不需要参数)。 77 | 78 | 增加一个`operation`的 `functional`版本已经在上面一节介绍完毕。 79 | 80 | 增加一个模块(`module`)。 81 | 由于`nn`重度使用`autograd`。所以，添加一个新`module`需要实现一个用来执行计算和计算梯度的`Function`。从现在开始，假定我们想要实现一个`Linear module`，记得之前我们已经实现了一个`Linear Funciton`。只需要很少的代码就可以完成这个工作。现在，我们需要实现两个方法： 82 | 83 | - `__init__ (optional)` - 输入参数，例如`kernel sizes`, `numbers of features`, 等等。同时初始化 `parameters`和`buffers`。 84 | 85 | - `forward()` - 实例化一个执行`operation`的`Function`，使用它执行`operation`。和`functional wrapper(上面实现的那个简单的wrapper)`十分类似。 86 | 87 | `Linear module`实现代码: 88 | ```python 89 | class Linear(nn.Module): 90 | def __init__(self, input_features, output_features, bias=True): 91 | self.input_features = input_features 92 | self.output_features = output_features 93 | 94 | # nn.Parameter is a special kind of Variable, that will get 95 | # automatically registered as Module's parameter once it's assigned 96 | # as an attribute. Parameters and buffers need to be registered, or 97 | # they won't appear in .parameters() (doesn't apply to buffers), and 98 | # won't be converted when e.g. .cuda() is called. You can use 99 | # .register_buffer() to register buffers. 100 | # nn.Parameters can never be volatile and, different than Variables, 101 | # they require gradients by default. 102 | self.weight = nn.Parameter(torch.Tensor(input_features, output_features)) 103 | if bias: 104 | self.bias = nn.Parameter(torch.Tensor(output_features)) 105 | else: 106 | # You should always register all possible parameters, but the 107 | # optional ones can be None if you want. 108 | self.register_parameter('bias', None) 109 | 110 | # Not a very smart way to initialize weights 111 | self.weight.data.uniform_(-0.1, 0.1) 112 | if bias is not None: 113 | self.bias.data.uniform_(-0.1, 0.1) 114 | 115 | def forward(self, input): 116 | # See the autograd section for explanation of what happens here. 117 | return Linear()(input, self.weight, self.bias) 118 | #注意这个Linear是之前实现过的Linear 119 | ``` 120 | ## 编写自定义`C`扩展 121 | 122 | Coming soon. For now you can find an example at [GitHub](https://github.com/pytorch/extension-ffi). 123 | -------------------------------------------------------------------------------- /docs/package_references/torch-autograd.md: -------------------------------------------------------------------------------- 1 | # Automatic differentiation package - torch.autograd 2 | 3 | `torch.autograd`提供了类和函数用来对任意标量函数进行求导。要想使用自动求导，只需要对已有的代码进行微小的改变。只需要将所有的`tensor`包含进`Variable`对象中即可。 4 | 5 | ### torch.autograd.backward(variables, grad_variables, retain_variables=False) 6 | Computes the sum of gradients of given variables w.r.t. graph leaves. 7 | 给定图的叶子节点`variables`, 计算图中变量的梯度和。 8 | 计算图可以通过链式法则求导。如果`variables`中的任何一个`variable`是非标量(`non-scalar`)的，且`requires_grad=True`。那么此函数需要指定`grad_variables`，它的长度应该和`variables`的长度匹配，里面保存了相关`variable`的梯度(对于不需要`gradient tensor`的`variable`，`None`是可取的)。 9 | 10 | 此函数累积`leaf variables`计算的梯度。你可能需要在调用此函数之前将`leaf variable`的梯度置零。 11 | 12 | 参数说明: 13 | 14 | - variables (variable 列表) – 被求微分的叶子节点，即 `ys` 。 15 | 16 | - grad_variables (`Tensor` 列表) – 对应`variable`的梯度。仅当`variable`不是标量且需要求梯度的时候使用。 17 | 18 | - retain_variables (bool) – `True`,计算梯度时所需要的`buffer`在计算完梯度后不会被释放。如果想对一个子图多次求微分的话，需要设置为`True`。 19 | 20 | ## Variable 21 | ### API 兼容性 22 | 23 | `Variable API` 几乎和 `Tensor API`一致 (除了一些`in-place`方法，这些`in-place`方法会修改 `required_grad=True`的 `input` 的值)。多数情况下，将`Tensor`替换为`Variable`，代码一样会正常的工作。由于这个原因，我们不会列出`Variable`的所有方法，你可以通过`torch.Tensor`的文档来获取相关知识。 24 | 25 | ### In-place operations on Variables 26 | 在`autograd`中支持`in-place operations`是非常困难的。同时在很多情况下，我们阻止使用`in-place operations`。`Autograd`的贪婪的释放`buffer`和复用使得它效率非常高。只有在非常少的情况下，使用`in-place operations`可以降低内存的使用。除非你面临很大的内存压力，否则不要使用`in-place operations`。 27 | 28 | ### In-place 正确性检查 29 | 所有的`Variable`都会记录用在他们身上的 `in-place operations`。如果`pytorch`检测到`variable`在一个`Function`中已经被保存用来`backward`，但是之后它又被`in-place operations`修改。当这种情况发生时，在`backward`的时候，`pytorch`就会报错。这种机制保证了，如果你用了`in-place operations`，但是在`backward`过程中没有报错，那么梯度的计算就是正确的。 30 | 31 | ### class torch.autograd.Variable [source] 32 | 33 | 包装一个`Tensor`,并记录用在它身上的`operations`。 34 | 35 | `Variable`是`Tensor`对象的一个`thin wrapper`，它同时保存着`Variable`的梯度和创建这个`Variable`的`Function`的引用。这个引用可以用来追溯创建这个`Variable`的整条链。如果`Variable`是被用户所创建的，那么它的`creator`是`None`，我们称这种对象为 `leaf Variables`。 36 | 37 | 由于`autograd`只支持标量值的反向求导(即：`y`是标量)，梯度的大小总是和数据的大小匹配。同时，仅仅给`leaf variables`分配梯度，其他`Variable`的梯度总是为0. 38 | 39 | **`变量：`** 40 | 41 | - data – 包含的`Tensor` 42 | 43 | - grad – 保存着`Variable`的梯度。这个属性是懒分配的，且不能被重新分配。 44 | 45 | - requires_grad – 布尔值，指示这个`Variable`是否是被一个包含`Variable`的子图创建的。更多细节请看`Excluding subgraphs from backward`。只能改变`leaf variable`的这个标签。 46 | 47 | - volatile – 布尔值，指示这个`Variable`是否被用于推断模式(即，不保存历史信息)。更多细节请看`Excluding subgraphs from backward`。只能改变`leaf variable`的这个标签。 48 | 49 | - creator – 创建这个`Variable`的`Function`，对于`leaf variable`，这个属性为`None`。只读属性。 50 | 51 | **`属性:`** 52 | 53 | - data (any tensor class) – 被包含的`Tensor` 54 | 55 | - requires_grad (bool) – `requires_grad`标记. 只能通过`keyword`传入. 56 | 57 | - volatile (bool) – `volatile`标记. 只能通过`keyword`传入. 58 | 59 | #### backward(gradient=None, retain_variables=False)[source] 60 | 61 | 当前`Variable`对`leaf variable`求偏导。 62 | 63 | 计算图可以通过链式法则求导。如果`Variable`是非标量(`non-scalar`)的，且`requires_grad=True`。那么此函数需要指定`gradient`，它的形状应该和`Variable`的长度匹配，里面保存了`Variable`的梯度。 64 | 65 | 此函数累积`leaf variable`的梯度。你可能需要在调用此函数之前将`Variable`的梯度置零。 66 | 67 | **`参数:`** 68 | 69 | - gradient (Tensor) – 其他函数对于此`Variable`的导数。仅当`Variable`不是标量的时候使用，类型和位形状应该和`self.data`一致。 70 | - retain_variables (bool) – `True`, 计算梯度所必要的`buffer`在经历过一次`backward`过程后不会被释放。如果你想多次计算某个子图的梯度的时候，设置为`True`。在某些情况下，使用`autograd.backward()`效率更高。 71 | 72 | #### detach()[source] 73 | Returns a new Variable, detached from the current graph. 74 | 返回一个新的`Variable`，从当前图中分离下来的。 75 | 76 | 返回的`Variable` `requires_grad=False`，如果输入 `volatile=True`，那么返回的`Variable` `volatile=True`。 77 | 78 | **`注意：`** 79 | 80 | 返回的`Variable`和原始的`Variable`公用同一个`data tensor`。`in-place`修改会在两个`Variable`上同时体现(因为它们共享`data tensor`)，可能会导致错误。 81 | 82 | #### detach_()[source] 83 | 84 | 将一个`Variable`从创建它的图中分离，并把它设置成`leaf variable`。 85 | 86 | #### register_hook(hook)[source] 87 | 88 | 注册一个`backward`钩子。 89 | 90 | 每次`gradients`被计算的时候，这个`hook`都被调用。`hook`应该拥有以下签名： 91 | 92 | `hook(grad) -> Variable or None` 93 | 94 | `hook`不应该修改它的输入，但是它可以选择性的返回一个替代当前梯度的新梯度。 95 | 96 | 这个函数返回一个句柄(`handle`)。它有一个方法 `handle.remove()`，可以用这个方法将`hook`从`module`移除。 97 | 98 | Example 99 | ```python 100 | v = Variable(torch.Tensor([0, 0, 0]), requires_grad=True) 101 | h = v.register_hook(lambda grad: grad * 2) # double the gradient 102 | v.backward(torch.Tensor([1, 1, 1])) 103 | #先计算原始梯度，再进hook，获得一个新梯度。 104 | print(v.grad.data) 105 | 106 | 2 107 | 2 108 | 2 109 | [torch.FloatTensor of size 3] 110 | >>> h.remove() # removes the hook 111 | ``` 112 | ```python 113 | def w_hook(grad): 114 | print("hello") 115 | return None 116 | w1 = Variable(torch.FloatTensor([1, 1, 1]),requires_grad=True) 117 | 118 | w1.register_hook(w_hook) # 如果hook返回的是None的话，那么梯度还是原来计算的梯度。 119 | 120 | w1.backward(gradient=torch.FloatTensor([1, 1, 1])) 121 | print(w1.grad) 122 | ``` 123 | ``` 124 | hello 125 | Variable containing: 126 | 1 127 | 1 128 | 1 129 | [torch.FloatTensor of size 3] 130 | ``` 131 | 132 | #### reinforce(reward)[source] 133 | 134 | 注册一个奖励，这个奖励是由一个随机过程得到的。 135 | 136 | 微分一个随机节点需要提供一个奖励值。如果你的计算图中包含随机 `operations`，你需要在他们的输出上调用这个函数。否则的话，会报错。 137 | 138 | **`参数:`** 139 | 140 | - reward (Tensor) – 每个元素的reward。必须和`Varaible`形状相同，并在同一个设备上。 141 | 142 | ### class torch.autograd.Function[source] 143 | Records operation history and defines formulas for differentiating ops. 144 | 记录`operation`的历史，定义微分公式。 145 | 每个执行在`Varaibles`上的`operation`都会创建一个`Function`对象，这个`Function`对象执行计算工作，同时记录下来。这个历史以有向无环图的形式保存下来，有向图的节点为`functions`，有向图的边代表数据依赖关系(`input<-output`)。之后，当`backward`被调用的时候，计算图以拓扑顺序处理，通过调用每个`Function`对象的`backward()`，同时将返回的梯度传递给下一个`Function`。 146 | 147 | 通常情况下，用户能和`Functions`交互的唯一方法就是创建`Function`的子类，定义新的`operation`。这是扩展`torch.autograd`的推荐方法。 148 | 149 | 由于`Function`逻辑在很多脚本上都是热点，所有我们把几乎所有的`Function`都使用`C`实现，通过这种策略保证框架的开销是最小的。 150 | 151 | 每个`Function`只被使用一次(在forward过程中)。 152 | 153 | **`变量:`** 154 | 155 | - saved_tensors – 调用`forward()`时需要被保存的 `Tensors`的 `tuple`。 156 | 157 | - needs_input_grad – 长度为输入数量的布尔值组成的 `tuple`。指示给定的`input`是否需要梯度。这个被用来优化用于`backward`过程中的`buffer`，忽略`backward`中的梯度计算。 158 | 159 | - num_inputs – `forward` 的输入参数数量。 160 | 161 | - num_outputs – `forward`返回的`Tensor`数量。 162 | 163 | - requires_grad – 布尔值。指示`backward`以后会不会被调用。 164 | 165 | - previous_functions – 长度为 `num_inputs`的 Tuple of (int, Function) pairs。`Tuple`中的每单元保存着创建 `input`的`Function`的引用，和索引。 166 | #### backward(* grad_output)[source] 167 | 168 | 定义了`operation`的微分公式。 169 | 170 | 所有的`Function`子类都应该重写这个方法。 171 | 172 | 所有的参数都是`Tensor`。他必须接收和`forward`的输出相同个数的参数。而且它需要返回和`forward`的输入参数相同个数的`Tensor`。 173 | 即：`backward`的输入参数是此`operation`的输出的值的梯度。`backward`的返回值是此`operation`输入值的梯度。 174 | 175 | #### forward(* input)[source] 176 | 177 | 执行`operation`。 178 | 179 | 所有的`Function`子类都需要重写这个方法。 180 | 181 | 可以接收和返回任意个数 `tensors` 182 | 183 | #### mark_dirty(* args)[source] 184 | 185 | 将输入的 `tensors` 标记为被`in-place operation`修改过。 186 | 187 | 这个方法应当至多调用一次，仅仅用在 `forward`方法里，而且`mark_dirty`的实参只能是`forward`的实参。 188 | 189 | 每个在`forward`方法中被`in-place operations`修改的`tensor`都应该传递给这个方法。这样，可以保证检查的正确性。这个方法在`tensor`修改前后调用都可以。 190 | 191 | #### mark_non_differentiable(* args)[source] 192 | 将输出标记为不可微。 193 | 194 | 这个方法至多只能被调用一次，只能在`forward`中调用，而且实参只能是`forward`的返回值。 195 | 196 | 这个方法会将输出标记成不可微，会增加`backward`过程中的效率。在`backward`中，你依旧需要接收`forward`输出值的梯度，但是这些梯度一直是`None`。 197 | 198 | This is used e.g. for indices returned from a max Function. 199 | 200 | #### mark_shared_storage(* pairs)[source] 201 | 将给定的`tensors pairs`标记为共享存储空间。 202 | 203 | 这个方法至多只能被调用一次，只能在`forward`中调用，而且所有的实参必须是`(input, output)`对。 204 | 205 | 如果一些 `inputs` 和 `outputs` 是共享存储空间的，所有的这样的 `(input, output)`对都应该传给这个函数，保证 `in-place operations` 检查的正确性。唯一的特例就是，当 `output`和`input`是同一个`tensor`(`in-place operations`的输入和输出)。这种情况下，就没必要指定它们之间的依赖关系，因为这个很容易就能推断出来。 206 | 207 | 这个函数在很多时候都用不到。主要是用在索引和转置这类的 `op` 中。 208 | 209 | #### save_for_backward(* tensors)[source] 210 | 211 | 将传入的 `tensor` 保存起来，留着`backward`的时候用。 212 | 213 | 这个方法至多只能被调用一次，只能在`forward`中调用。 214 | 215 | 之后，被保存的`tensors`可以通过 `saved_tensors`属性获取。在返回这些`tensors`之前，`pytorch`做了一些检查，保证这些`tensor`没有被`in-place operations`修改过。 216 | 217 | 实参可以是`None`。 218 | -------------------------------------------------------------------------------- /docs/package_references/torch-optim.md: -------------------------------------------------------------------------------- 1 | # torch.optim 2 | 3 | `torch.optim`是一个实现了各种优化算法的库。大部分常用的方法得到支持，并且接口具备足够的通用性，使得未来能够集成更加复杂的方法。 4 | 5 | ## 如何使用optimizer 6 | 为了使用`torch.optim`，你需要构建一个optimizer对象。这个对象能够保持当前参数状态并基于计算得到的梯度进行参数更新。 7 | 8 | ### 构建 9 | 为了构建一个`Optimizer`，你需要给它一个包含了需要优化的参数（必须都是`Variable`对象）的iterable。然后，你可以设置optimizer的参 10 | 数选项，比如学习率，权重衰减，等等。 11 | 12 | 例子： 13 | ```python 14 | optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9) 15 | optimizer = optim.Adam([var1, var2], lr = 0.0001) 16 | ``` 17 | 18 | ### 为每个参数单独设置选项 19 | `Optimizer`也支持为每个参数单独设置选项。若想这么做，不要直接传入`Variable`的iterable，而是传入`dict`的iterable。每一个dict都分别定 20 | 义了一组参数，并且包含一个`param`键，这个键对应参数的列表。其他的键应该optimizer所接受的其他参数的关键字相匹配，并且会被用于对这组参数的 21 | 优化。 22 | 23 | **`注意：`** 24 | 25 | 你仍然能够传递选项作为关键字参数。在未重写这些选项的组中，它们会被用作默认值。当你只想改动一个参数组的选项，但其他参数组的选项不变时，这是 26 | 非常有用的。 27 | 28 | 例如，当我们想指定每一层的学习率时，这是非常有用的： 29 | 30 | ```python 31 | optim.SGD([ 32 | {'params': model.base.parameters()}, 33 | {'params': model.classifier.parameters(), 'lr': 1e-3} 34 | ], lr=1e-2, momentum=0.9) 35 | ``` 36 | 37 | 这意味着`model.base`的参数将会使用`1e-2`的学习率，`model.classifier`的参数将会使用`1e-3`的学习率，并且`0.9`的momentum将会被用于所 38 | 有的参数。 39 | 40 | ### 进行单次优化 41 | 所有的optimizer都实现了`step()`方法，这个方法会更新所有的参数。它能按两种方式来使用： 42 | 43 | **`optimizer.step()`** 44 | 45 | 这是大多数optimizer所支持的简化版本。一旦梯度被如`backward()`之类的函数计算好后，我们就可以调用这个函数。 46 | 47 | 例子 48 | 49 | ```python 50 | for input, target in dataset: 51 | optimizer.zero_grad() 52 | output = model(input) 53 | loss = loss_fn(output, target) 54 | loss.backward() 55 | optimizer.step() 56 | ``` 57 | 58 | **`optimizer.step(closure)`** 59 | 60 | 一些优化算法例如Conjugate Gradient和LBFGS需要重复多次计算函数，因此你需要传入一个闭包去允许它们重新计算你的模型。这个闭包应当清空梯度， 61 | 计算损失，然后返回。 62 | 63 | 例子： 64 | 65 | ```python 66 | for input, target in dataset: 67 | def closure(): 68 | optimizer.zero_grad() 69 | output = model(input) 70 | loss = loss_fn(output, target) 71 | loss.backward() 72 | return loss 73 | optimizer.step(closure) 74 | ``` 75 | 76 | ## 算法 77 | 78 | ### class torch.optim.Optimizer(params, defaults) [source] 79 | Base class for all optimizers. 80 | 81 | **参数：** 82 | 83 | * params (iterable) —— `Variable` 或者 `dict`的iterable。指定了什么参数应当被优化。 84 | * defaults —— (dict)：包含了优化选项默认值的字典（一个参数组没有指定的参数选项将会使用默认值）。 85 | 86 | #### load_state_dict(state_dict) [source] 87 | 加载optimizer状态 88 | 89 | **参数：** 90 | 91 | state_dict (`dict`) —— optimizer的状态。应当是一个调用`state_dict()`所返回的对象。 92 | 93 | #### state_dict() [source] 94 | 以`dict`返回optimizer的状态。 95 | 96 | 它包含两项。 97 | 98 | * state - 一个保存了当前优化状态的dict。optimizer的类别不同，state的内容也会不同。 99 | * param_groups - 一个包含了全部参数组的dict。 100 | 101 | #### step(closure) [source] 102 | 进行单次优化 (参数更新). 103 | 104 | **参数：** 105 | 106 | * closure (`callable`) – 一个重新评价模型并返回loss的闭包，对于大多数参数来说是可选的。 107 | 108 | #### zero_grad() [source] 109 | 清空所有被优化过的Variable的梯度. 110 | 111 | ### class torch.optim.Adadelta(params, lr=1.0, rho=0.9, eps=1e-06, weight_decay=0)[source] 112 | 实现Adadelta算法。 113 | 114 | 它在[ADADELTA: An Adaptive Learning Rate Method.](https://arxiv.org/abs/1212.5701)中被提出。 115 | 116 | **参数：** 117 | 118 | * params (iterable) – 待优化参数的iterable或者是定义了参数组的dict 119 | * rho (`float`, 可选) – 用于计算平方梯度的运行平均值的系数（默认：0.9） 120 | * eps (`float`, 可选) – 为了增加数值计算的稳定性而加到分母里的项（默认：1e-6） 121 | * lr (`float`, 可选) – 在delta被应用到参数更新之前对它缩放的系数（默认：1.0） 122 | * weight_decay (`float`, 可选) – 权重衰减（L2惩罚）（默认: 0） 123 | 124 | #### step(closure) [source] 125 | 进行单次优化 (参数更新). 126 | 127 | **参数：** 128 | 129 | * closure (`callable`) – 一个重新评价模型并返回loss的闭包，对于大多数参数来说是可选的。 130 | 131 | ### class torch.optim.Adagrad(params, lr=0.01, lr_decay=0, weight_decay=0)[source] 132 | 实现Adagrad算法。 133 | 134 | 它在 [Adaptive Subgradient Methods for Online Learning and Stochastic Optimization]( 135 | http://jmlr.org/papers/v12/duchi11a.html)中被提出。 136 | 137 | **参数：** 138 | 139 | * params (iterable) – 待优化参数的iterable或者是定义了参数组的dict 140 | * lr (`float`, 可选) – 学习率（默认: 1e-2） 141 | * lr_decay (`float`, 可选) – 学习率衰减（默认: 0） 142 | * weight_decay (`float`, 可选) – 权重衰减（L2惩罚）（默认: 0） 143 | 144 | #### step(closure) [source] 145 | 进行单次优化 (参数更新). 146 | 147 | **参数：** 148 | 149 | * closure (`callable`) – 一个重新评价模型并返回loss的闭包，对于大多数参数来说是可选的。 150 | 151 | ### class torch.optim.Adam(params, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)[source] 152 | 实现Adam算法。 153 | 154 | 它在[Adam: A Method for Stochastic Optimization](https://arxiv.org/abs/1412.6980)中被提出。 155 | 156 | **参数：** 157 | 158 | * params (iterable) – 待优化参数的iterable或者是定义了参数组的dict 159 | * lr (`float`, 可选) – 学习率（默认：1e-3） 160 | * betas (Tuple[`float`, `float`], 可选) – 用于计算梯度以及梯度平方的运行平均值的系数（默认：0.9，0.999） 161 | * eps (`float`, 可选) – 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8） 162 | * weight_decay (`float`, 可选) – 权重衰减（L2惩罚）（默认: 0） 163 | 164 | #### step(closure) [source] 165 | 进行单次优化 (参数更新). 166 | 167 | **参数：** 168 | 169 | * closure (`callable`) – 一个重新评价模型并返回loss的闭包，对于大多数参数来说是可选的。 170 | 171 | ### class torch.optim.Adamax(params, lr=0.002, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)[source] 172 | 实现Adamax算法（Adam的一种基于无穷范数的变种）。 173 | 174 | 它在[Adam: A Method for Stochastic Optimization](https://arxiv.org/abs/1412.6980)中被提出。 175 | 176 | **参数：** 177 | 178 | * params (iterable) – 待优化参数的iterable或者是定义了参数组的dict 179 | * lr (`float`, 可选) – 学习率（默认：2e-3） 180 | * betas (Tuple[`float`, `float`], 可选) – 用于计算梯度以及梯度平方的运行平均值的系数 181 | * eps (`float`, 可选) – 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8） 182 | * weight_decay (`float`, 可选) – 权重衰减（L2惩罚）（默认: 0） 183 | 184 | #### step(closure) [source] 185 | 进行单次优化 (参数更新). 186 | 187 | **参数：** 188 | 189 | * closure (`callable`) – 一个重新评价模型并返回loss的闭包，对于大多数参数来说是可选的。 190 | 191 | ### class torch.optim.ASGD(params, lr=0.01, lambd=0.0001, alpha=0.75, t0=1000000.0, weight_decay=0)[source] 192 | 实现平均随机梯度下降算法。 193 | 194 | 它在[Acceleration of stochastic approximation by averaging](http://dl.acm.org/citation.cfm?id=131098)中被提出。 195 | 196 | **参数：** 197 | 198 | * params (iterable) – 待优化参数的iterable或者是定义了参数组的dict 199 | * lr (`float`, 可选) – 学习率（默认：1e-2） 200 | * lambd (`float`, 可选) – 衰减项（默认：1e-4） 201 | * alpha (`float`, 可选) – eta更新的指数（默认：0.75） 202 | * t0 (`float`, 可选) – 指明在哪一次开始平均化（默认：1e6） 203 | * weight_decay (`float`, 可选) – 权重衰减（L2惩罚）（默认: 0） 204 | 205 | #### step(closure) [source] 206 | 进行单次优化 (参数更新). 207 | 208 | **参数：** 209 | 210 | * closure (`callable`) – 一个重新评价模型并返回loss的闭包，对于大多数参数来说是可选的。 211 | 212 | ### class torch.optim.LBFGS(params, lr=1, max_iter=20, max_eval=None, tolerance_grad=1e-05, tolerance_change=1e-09, history_size=100, line_search_fn=None)[source] 213 | 实现L-BFGS算法。 214 | 215 | #### 警告 216 | 这个optimizer不支持为每个参数单独设置选项以及不支持参数组（只能有一个） 217 | 218 | #### 警告 219 | 目前所有的参数不得不都在同一设备上。在将来这会得到改进。 220 | 221 | #### 注意 222 | 这是一个内存高度密集的optimizer（它要求额外的`param_bytes * (history_size + 1)` 个字节）。如果它不适应内存，尝试减小history size，或者使用不同的算法。 223 | 224 | **参数：** 225 | 226 | * lr (`float`) – 学习率（默认：1） 227 | * max_iter (`int`) – 每一步优化的最大迭代次数（默认：20）) 228 | * max_eval (`int`) – 每一步优化的最大函数评价次数（默认：max * 1.25） 229 | * tolerance_grad (`float`) – 一阶最优的终止容忍度（默认：1e-5） 230 | * tolerance_change (`float`) – 在函数值/参数变化量上的终止容忍度（默认：1e-9） 231 | * history_size (`int`) – 更新历史的大小（默认：100） 232 | 233 | #### step(closure) [source] 234 | 进行单次优化 (参数更新). 235 | 236 | **参数：** 237 | 238 | * closure (`callable`) – 一个重新评价模型并返回loss的闭包，对于大多数参数来说是可选的。 239 | 240 | ### class torch.optim.RMSprop(params, lr=0.01, alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)[source] 241 | 实现RMSprop算法。 242 | 243 | 由G. H`int`on在他的[课程](http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf)中提出. 244 | 245 | 中心版本首次出现在[Generating Sequences With Recurrent Neural Networks]( 246 | https://arxiv.org/pdf/1308.0850v5.pdf). 247 | 248 | **参数：** 249 | 250 | * params (iterable) – 待优化参数的iterable或者是定义了参数组的dict 251 | * lr (`float`, 可选) – 学习率（默认：1e-2） 252 | * momentum (`float`, 可选) – 动量因子（默认：0） 253 | * alpha (`float`, 可选) – 平滑常数（默认：0.99） 254 | * eps (`float`, 可选) – 为了增加数值计算的稳定性而加到分母里的项（默认：1e-8） 255 | * centered (`bool`, 可选) – 如果为True，计算中心化的RMSProp，并且用它的方差预测值对梯度进行归一化 256 | * weight_decay (`float`, 可选) – 权重衰减（L2惩罚）（默认: 0） 257 | 258 | #### step(closure) [source] 259 | 进行单次优化 (参数更新). 260 | 261 | **参数：** 262 | 263 | * closure (`callable`) – 一个重新评价模型并返回loss的闭包，对于大多数参数来说是可选的。 264 | 265 | ### class torch.optim.Rprop(params, lr=0.01, etas=(0.5, 1.2), step_sizes=(1e-06, 50))[source] 266 | 实现弹性反向传播算法。 267 | 268 | **参数：** 269 | 270 | * params (iterable) – 待优化参数的iterable或者是定义了参数组的dict 271 | * lr (`float`, 可选) – 学习率（默认：1e-2） 272 | * etas (Tuple[`float`, `float`], 可选) – 一对（etaminus，etaplis）, 它们分别是乘法的增加和减小的因子（默认：0.5，1.2） 273 | * step_sizes (Tuple[`float`, `float`], 可选) – 允许的一对最小和最大的步长（默认：1e-6，50） 274 | 275 | #### step(closure) [source] 276 | 进行单次优化 (参数更新). 277 | 278 | **参数：** 279 | 280 | * closure (`callable`) – 一个重新评价模型并返回loss的闭包，对于大多数参数来说是可选的。 281 | 282 | ### class torch.optim.SGD(params, lr=