import torch
from torch import nn
?
class MLP(nn.Module):
? ? # 聲明帶有模型參數的層，這里聲明了兩個全連接層
? ? def __init__(self, **kwargs):
? ? ? ? # 調用MLP父類Module的構造函數來進行必要的初始化。這樣在構造實例時還可以指定其他函數
? ? ? ? # 參數，如“模型參數的訪問、初始化和共享”一節(jié)將介紹的模型參數params
? ? ? ? super(MLP, self).__init__(**kwargs)
? ? ? ? self.hidden = nn.Linear(784, 256) # 隱藏層
? ? ? ? self.act = nn.ReLU()
? ? ? ? self.output = nn.Linear(256, 10) ?# 輸出層
?
?
? ? # 定義模型的前向計算，即如何根據輸入x計算返回所需要的模型輸出
? ? def forward(self, x):
? ? ? ? a = self.act(self.hidden(x))
? ? ? ? return self.output(a)
??
X = torch.rand(2, 784)
net = MLP()
print(net)
net(X)

# torch._C._VariableFunctions
torch.softmax(x, dim=-1)

# class
softmax = torch.nn.Softmax(dim=-1)
x=softmax(x)

# function
x = torch.nn.functional.softmax(x, dim=-1)

class Softmax(Module):
? ? r"""Applies the Softmax function to an n-dimensional input Tensor
? ? rescaling them so that the elements of the n-dimensional output Tensor
? ? lie in the range [0,1] and sum to 1.

? ? Softmax is defined as:

? ? .. math::
? ? ? ? \text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}

? ? When the input Tensor is a sparse tensor then the unspecifed
? ? values are treated as ``-inf``.

? ? Shape:
? ? ? ? - Input: :math:`(*)` where `*` means, any number of additional
? ? ? ? ? dimensions
? ? ? ? - Output: :math:`(*)`, same shape as the input

? ? Returns:
? ? ? ? a Tensor of the same dimension and shape as the input with
? ? ? ? values in the range [0, 1]

? ? Args:
? ? ? ? dim (int): A dimension along which Softmax will be computed (so every slice
? ? ? ? ? ? along dim will sum to 1).

? ? .. note::
? ? ? ? This module doesn't work directly with NLLLoss,
? ? ? ? which expects the Log to be computed between the Softmax and itself.
? ? ? ? Use `LogSoftmax` instead (it's faster and has better numerical properties).

? ? Examples::

? ? ? ? >>> m = nn.Softmax(dim=1)
? ? ? ? >>> input = torch.randn(2, 3)
? ? ? ? >>> output = m(input)

? ? """
? ? __constants__ = ['dim']
? ? dim: Optional[int]

? ? def __init__(self, dim: Optional[int] = None) -> None:
? ? ? ? super(Softmax, self).__init__()
? ? ? ? self.dim = dim

? ? def __setstate__(self, state):
? ? ? ? self.__dict__.update(state)
? ? ? ? if not hasattr(self, 'dim'):
? ? ? ? ? ? self.dim = None

? ? def forward(self, input: Tensor) -> Tensor:
? ? ? ? return F.softmax(input, self.dim, _stacklevel=5)

? ? def extra_repr(self) -> str:
? ? ? ? return 'dim={dim}'.format(dim=self.dim)

def softmax(input: Tensor, dim: Optional[int] = None, _stacklevel: int = 3, dtype: Optional[DType] = None) -> Tensor:
? ? r"""Applies a softmax function.

? ? Softmax is defined as:

? ? :math:`\text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}`

? ? It is applied to all slices along dim, and will re-scale them so that the elements
? ? lie in the range `[0, 1]` and sum to 1.

? ? See :class:`~torch.nn.Softmax` for more details.

? ? Args:
? ? ? ? input (Tensor): input
? ? ? ? dim (int): A dimension along which softmax will be computed.
? ? ? ? dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
? ? ? ? ? If specified, the input tensor is casted to :attr:`dtype` before the operation
? ? ? ? ? is performed. This is useful for preventing data type overflows. Default: None.

? ? .. note::
? ? ? ? This function doesn't work directly with NLLLoss,
? ? ? ? which expects the Log to be computed between the Softmax and itself.
? ? ? ? Use log_softmax instead (it's faster and has better numerical properties).

? ? """
? ? if has_torch_function_unary(input):
? ? ? ? return handle_torch_function(softmax, (input,), input, dim=dim, _stacklevel=_stacklevel, dtype=dtype)
? ? if dim is None:
? ? ? ? dim = _get_softmax_dim("softmax", input.dim(), _stacklevel)
? ? if dtype is None:
? ? ? ? ret = input.softmax(dim)
? ? else:
? ? ? ? ret = input.softmax(dim, dtype=dtype)
? ? return ret