neulab/docprompting-conala huggingface dataset:
class torch.nn.intrinsic.qat.ConvReLU2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', qconfig=None) [source]
 
A ConvReLU2d module is a fused module of Conv2d and ReLU, attached with FakeQuantize modules for weight for quantization aware training. We combined the interface of Conv2d and BatchNorm2d.  Variables 
~ConvReLU2d.weight_fake_quant – fake quant module for weight
class torch.nn.intrinsic.qat.LinearReLU(in_features, out_features, bias=True, qconfig=None) [source]
 
A LinearReLU module fused from Linear and ReLU modules, attached with FakeQuantize modules for weight, used in quantization aware training. We adopt the same interface as torch.nn.Linear. Similar to torch.nn.intrinsic.LinearReLU, with FakeQuantize modules initialized to default.  Variables 
~LinearReLU.weight – fake quant module for weight   Examples: >>> m = nn.qat.LinearReLU(20, 30)
>>> input = torch.randn(128, 20)
>>> output = m(input)
>>> print(output.size())
torch.Size([128, 30])
class torch.nn.intrinsic.quantized.ConvReLU2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros') [source]
 
A ConvReLU2d module is a fused module of Conv2d and ReLU We adopt the same interface as torch.nn.quantized.Conv2d.  Variables 
as torch.nn.quantized.Conv2d (Same) –
class torch.nn.intrinsic.quantized.ConvReLU3d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros') [source]
 
A ConvReLU3d module is a fused module of Conv3d and ReLU We adopt the same interface as torch.nn.quantized.Conv3d. Attributes: Same as torch.nn.quantized.Conv3d
class torch.nn.intrinsic.quantized.LinearReLU(in_features, out_features, bias=True, dtype=torch.qint8) [source]
 
A LinearReLU module fused from Linear and ReLU modules We adopt the same interface as torch.nn.quantized.Linear.  Variables 
as torch.nn.quantized.Linear (Same) –    Examples: >>> m = nn.intrinsic.LinearReLU(20, 30)
>>> input = torch.randn(128, 20)
>>> output = m(input)
>>> print(output.size())
torch.Size([128, 30])
class torch.nn.L1Loss(size_average=None, reduce=None, reduction='mean') [source]
 
Creates a criterion that measures the mean absolute error (MAE) between each element in the input xx  and target yy . The unreduced (i.e. with reduction set to 'none') loss can be described as:  ℓ(x,y)=L={l1,…,lN}⊤,ln=∣xn−yn∣,\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad l_n = \left| x_n - y_n \right|,  
where NN  is the batch size. If reduction is not 'none' (default 'mean'), then:  ℓ(x,y)={mean⁡(L),if reduction=‘mean’;sum⁡(L),if reduction=‘sum’.\ell(x, y) = \begin{cases} \operatorname{mean}(L), & \text{if reduction} = \text{`mean';}\\ \operatorname{sum}(L), & \text{if reduction} = \text{`sum'.} \end{cases}  
xx  and yy  are tensors of arbitrary shapes with a total of nn  elements each. The sum operation still operates over all the elements, and divides by nn . The division by nn  can be avoided if one sets reduction = 'sum'. Supports real-valued and complex-valued inputs.  Parameters 
 
size_average (bool, optional) – Deprecated (see reduction). By default, the losses are averaged over each loss element in the batch. Note that for some losses, there are multiple elements per sample. If the field size_average is set to False, the losses are instead summed for each minibatch. Ignored when reduce is False. Default: True
 
reduce (bool, optional) – Deprecated (see reduction). By default, the losses are averaged or summed over observations for each minibatch depending on size_average. When reduce is False, returns a loss per batch element instead and ignores size_average. Default: True
 
reduction (string, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'
     Shape:

 Input: (N,∗)(N, *)  where ∗*  means, any number of additional dimensions Target: (N,∗)(N, *) , same shape as the input Output: scalar. If reduction is 'none', then (N,∗)(N, *) , same shape as the input    Examples: >>> loss = nn.L1Loss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randn(3, 5)
>>> output = loss(input, target)
>>> output.backward()
class torch.nn.LayerNorm(normalized_shape, eps=1e-05, elementwise_affine=True) [source]
 
Applies Layer Normalization over a mini-batch of inputs as described in the paper Layer Normalization  y=x−E[x]Var[x]+ϵ∗γ+βy = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta  
The mean and standard-deviation are calculated separately over the last certain number dimensions which have to be of the shape specified by normalized_shape. γ\gamma  and β\beta  are learnable affine transform parameters of normalized_shape if elementwise_affine is True. The standard-deviation is calculated via the biased estimator, equivalent to torch.var(input, unbiased=False).  Note Unlike Batch Normalization and Instance Normalization, which applies scalar scale and bias for each entire channel/plane with the affine option, Layer Normalization applies per-element scale and bias with elementwise_affine.  This layer uses statistics computed from input data in both training and evaluation modes.  Parameters 
 
normalized_shape (int or list or torch.Size) – 
input shape from an expected input of size  [∗×normalized_shape[0]×normalized_shape[1]×…×normalized_shape[−1]][* \times \text{normalized\_shape}[0] \times \text{normalized\_shape}[1] \times \ldots \times \text{normalized\_shape}[-1]]  
If a single integer is used, it is treated as a singleton list, and this module will normalize over the last dimension which is expected to be of that specific size.  
eps – a value added to the denominator for numerical stability. Default: 1e-5 
elementwise_affine – a boolean value that when set to True, this module has learnable per-element affine parameters initialized to ones (for weights) and zeros (for biases). Default: True.     Shape:

 Input: (N,∗)(N, *) 
 Output: (N,∗)(N, *)  (same shape as input)    Examples: >>> input = torch.randn(20, 5, 10, 10)
>>> # With Learnable Parameters
>>> m = nn.LayerNorm(input.size()[1:])
>>> # Without Learnable Parameters
>>> m = nn.LayerNorm(input.size()[1:], elementwise_affine=False)
>>> # Normalize over last two dimensions
>>> m = nn.LayerNorm([10, 10])
>>> # Normalize over last dimension of size 10
>>> m = nn.LayerNorm(10)
>>> # Activating the module
>>> output = m(input)
class torch.nn.LazyConv1d(out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros') [source]
 
A torch.nn.Conv1d module with lazy initialization of the in_channels argument of the Conv1d that is inferred from the input.size(1).  Parameters 
 
out_channels (int) – Number of channels produced by the convolution 
kernel_size (int or tuple) – Size of the convolving kernel 
stride (int or tuple, optional) – Stride of the convolution. Default: 1 
padding (int or tuple, optional) – Zero-padding added to both sides of the input. Default: 0 
padding_mode (string, optional) – 'zeros', 'reflect', 'replicate' or 'circular'. Default: 'zeros'
 
dilation (int or tuple, optional) – Spacing between kernel elements. Default: 1 
groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1 
bias (bool, optional) – If True, adds a learnable bias to the output. Default: True
     See also torch.nn.Conv1d and torch.nn.modules.lazy.LazyModuleMixin   
cls_to_become  
alias of Conv1d
class torch.nn.LazyConv2d(out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros') [source]
 
A torch.nn.Conv2d module with lazy initialization of the in_channels argument of the Conv2d that is inferred from the input.size(1).  Parameters 
 
out_channels (int) – Number of channels produced by the convolution 
kernel_size (int or tuple) – Size of the convolving kernel 
stride (int or tuple, optional) – Stride of the convolution. Default: 1 
padding (int or tuple, optional) – Zero-padding added to both sides of the input. Default: 0 
padding_mode (string, optional) – 'zeros', 'reflect', 'replicate' or 'circular'. Default: 'zeros'
 
dilation (int or tuple, optional) – Spacing between kernel elements. Default: 1 
groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1 
bias (bool, optional) – If True, adds a learnable bias to the output. Default: True
     See also torch.nn.Conv2d and torch.nn.modules.lazy.LazyModuleMixin   
cls_to_become  
alias of Conv2d
class torch.nn.LazyConv3d(out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros') [source]
 
A torch.nn.Conv3d module with lazy initialization of the in_channels argument of the Conv3d that is inferred from the input.size(1).  Parameters 
 
out_channels (int) – Number of channels produced by the convolution 
kernel_size (int or tuple) – Size of the convolving kernel 
stride (int or tuple, optional) – Stride of the convolution. Default: 1 
padding (int or tuple, optional) – Zero-padding added to both sides of the input. Default: 0 
padding_mode (string, optional) – 'zeros', 'reflect', 'replicate' or 'circular'. Default: 'zeros'
 
dilation (int or tuple, optional) – Spacing between kernel elements. Default: 1 
groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1 
bias (bool, optional) – If True, adds a learnable bias to the output. Default: True
     See also torch.nn.Conv3d and torch.nn.modules.lazy.LazyModuleMixin   
cls_to_become  
alias of Conv3d
class torch.nn.LazyConvTranspose1d(out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros') [source]
 
A torch.nn.ConvTranspose1d module with lazy initialization of the in_channels argument of the ConvTranspose1d that is inferred from the input.size(1).  Parameters 
 
out_channels (int) – Number of channels produced by the convolution 
kernel_size (int or tuple) – Size of the convolving kernel 
stride (int or tuple, optional) – Stride of the convolution. Default: 1 
padding (int or tuple, optional) – dilation * (kernel_size - 1) - padding zero-padding will be added to both sides of the input. Default: 0 
output_padding (int or tuple, optional) – Additional size added to one side of the output shape. Default: 0 
groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1 
bias (bool, optional) – If True, adds a learnable bias to the output. Default: True
 
dilation (int or tuple, optional) – Spacing between kernel elements. Default: 1     See also torch.nn.ConvTranspose1d and torch.nn.modules.lazy.LazyModuleMixin   
cls_to_become  
alias of ConvTranspose1d
class torch.nn.LazyConvTranspose2d(out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros') [source]
 
A torch.nn.ConvTranspose2d module with lazy initialization of the in_channels argument of the ConvTranspose2d that is inferred from the input.size(1).  Parameters 
 
out_channels (int) – Number of channels produced by the convolution 
kernel_size (int or tuple) – Size of the convolving kernel 
stride (int or tuple, optional) – Stride of the convolution. Default: 1 
padding (int or tuple, optional) – dilation * (kernel_size - 1) - padding zero-padding will be added to both sides of each dimension in the input. Default: 0 
output_padding (int or tuple, optional) – Additional size added to one side of each dimension in the output shape. Default: 0 
groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1 
bias (bool, optional) – If True, adds a learnable bias to the output. Default: True
 
dilation (int or tuple, optional) – Spacing between kernel elements. Default: 1     See also torch.nn.ConvTranspose2d and torch.nn.modules.lazy.LazyModuleMixin   
cls_to_become  
alias of ConvTranspose2d
class torch.nn.LazyConvTranspose3d(out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros') [source]
 
A torch.nn.ConvTranspose3d module with lazy initialization of the in_channels argument of the ConvTranspose3d that is inferred from the input.size(1).  Parameters 
 
out_channels (int) – Number of channels produced by the convolution 
kernel_size (int or tuple) – Size of the convolving kernel 
stride (int or tuple, optional) – Stride of the convolution. Default: 1 
padding (int or tuple, optional) – dilation * (kernel_size - 1) - padding zero-padding will be added to both sides of each dimension in the input. Default: 0 
output_padding (int or tuple, optional) – Additional size added to one side of each dimension in the output shape. Default: 0 
groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1 
bias (bool, optional) – If True, adds a learnable bias to the output. Default: True
 
dilation (int or tuple, optional) – Spacing between kernel elements. Default: 1     See also torch.nn.ConvTranspose3d and torch.nn.modules.lazy.LazyModuleMixin   
cls_to_become  
alias of ConvTranspose3d
class torch.nn.LazyLinear(out_features, bias=True) [source]
 
A torch.nn.Linear module with lazy initialization. In this module, the weight and bias are of torch.nn.UninitializedParameter class. They will be initialized after the first call to forward is done and the module will become a regular torch.nn.Linear module. Check the torch.nn.modules.lazy.LazyModuleMixin for further documentation on lazy modules and their limitations.  Parameters 
 
out_features – size of each output sample 
bias – If set to False, the layer will not learn an additive bias. Default: True
   Variables 
 
~LazyLinear.weight – the learnable weights of the module of shape (out_features,in_features)(\text{out\_features}, \text{in\_features}) . The values are initialized from U(−k,k)\mathcal{U}(-\sqrt{k}, \sqrt{k}) , where k=1in_featuresk = \frac{1}{\text{in\_features}} 
 
~LazyLinear.bias – the learnable bias of the module of shape (out_features)(\text{out\_features}) . If bias is True, the values are initialized from U(−k,k)\mathcal{U}(-\sqrt{k}, \sqrt{k})  where k=1in_featuresk = \frac{1}{\text{in\_features}} 
     
cls_to_become  
alias of Linear
class torch.nn.LeakyReLU(negative_slope=0.01, inplace=False) [source]
 
Applies the element-wise function:  LeakyReLU(x)=max⁡(0,x)+negative_slope∗min⁡(0,x)\text{LeakyReLU}(x) = \max(0, x) + \text{negative\_slope} * \min(0, x)  
or  LeakyRELU(x)={x, if x≥0negative_slope×x, otherwise \text{LeakyRELU}(x) = \begin{cases} x, & \text{ if } x \geq 0 \\ \text{negative\_slope} \times x, & \text{ otherwise } \end{cases}  
 Parameters 
 
negative_slope – Controls the angle of the negative slope. Default: 1e-2 
inplace – can optionally do the operation in-place. Default: False
     Shape:

 Input: (N,∗)(N, *)  where * means, any number of additional dimensions Output: (N,∗)(N, *) , same shape as the input     Examples: >>> m = nn.LeakyReLU(0.1)
>>> input = torch.randn(2)
>>> output = m(input)
class torch.nn.Linear(in_features, out_features, bias=True) [source]
 
Applies a linear transformation to the incoming data: y=xAT+by = xA^T + b  This module supports TensorFloat32.  Parameters 
 
in_features – size of each input sample 
out_features – size of each output sample 
bias – If set to False, the layer will not learn an additive bias. Default: True
     Shape:

 Input: (N,∗,Hin)(N, *, H_{in})  where ∗*  means any number of additional dimensions and Hin=in_featuresH_{in} = \text{in\_features} 
 Output: (N,∗,Hout)(N, *, H_{out})  where all but the last dimension are the same shape as the input and Hout=out_featuresH_{out} = \text{out\_features} .     Variables 
 
~Linear.weight – the learnable weights of the module of shape (out_features,in_features)(\text{out\_features}, \text{in\_features}) . The values are initialized from U(−k,k)\mathcal{U}(-\sqrt{k}, \sqrt{k}) , where k=1in_featuresk = \frac{1}{\text{in\_features}} 
 
~Linear.bias – the learnable bias of the module of shape (out_features)(\text{out\_features}) . If bias is True, the values are initialized from U(−k,k)\mathcal{U}(-\sqrt{k}, \sqrt{k})  where k=1in_featuresk = \frac{1}{\text{in\_features}} 
    Examples: >>> m = nn.Linear(20, 30)
>>> input = torch.randn(128, 20)
>>> output = m(input)
>>> print(output.size())
torch.Size([128, 30])
class torch.nn.LocalResponseNorm(size, alpha=0.0001, beta=0.75, k=1.0) [source]
 
Applies local response normalization over an input signal composed of several input planes, where channels occupy the second dimension. Applies normalization across channels.  bc=ac(k+αn∑c′=max⁡(0,c−n/2)min⁡(N−1,c+n/2)ac′2)−βb_{c} = a_{c}\left(k + \frac{\alpha}{n} \sum_{c'=\max(0, c-n/2)}^{\min(N-1,c+n/2)}a_{c'}^2\right)^{-\beta}  
 Parameters 
 
size – amount of neighbouring channels used for normalization 
alpha – multiplicative factor. Default: 0.0001 
beta – exponent. Default: 0.75 
k – additive factor. Default: 1     Shape:

 Input: (N,C,∗)(N, C, *) 
 Output: (N,C,∗)(N, C, *)  (same shape as input)    Examples: >>> lrn = nn.LocalResponseNorm(2)
>>> signal_2d = torch.randn(32, 5, 24, 24)
>>> signal_4d = torch.randn(16, 5, 7, 7, 7, 7)
>>> output_2d = lrn(signal_2d)
>>> output_4d = lrn(signal_4d)
class torch.nn.LogSigmoid [source]
 
Applies the element-wise function:  LogSigmoid(x)=log⁡(11+exp⁡(−x))\text{LogSigmoid}(x) = \log\left(\frac{ 1 }{ 1 + \exp(-x)}\right)  
 Shape:

 Input: (N,∗)(N, *)  where * means, any number of additional dimensions Output: (N,∗)(N, *) , same shape as the input     Examples: >>> m = nn.LogSigmoid()
>>> input = torch.randn(2)
>>> output = m(input)
class torch.nn.LogSoftmax(dim=None) [source]
 
Applies the log⁡(Softmax(x))\log(\text{Softmax}(x))  function to an n-dimensional input Tensor. The LogSoftmax formulation can be simplified as:  LogSoftmax(xi)=log⁡(exp⁡(xi)∑jexp⁡(xj))\text{LogSoftmax}(x_{i}) = \log\left(\frac{\exp(x_i) }{ \sum_j \exp(x_j)} \right)  
 Shape:

 Input: (∗)(*)  where * means, any number of additional dimensions Output: (∗)(*) , same shape as the input     Parameters 
dim (int) – A dimension along which LogSoftmax will be computed.  Returns 
a Tensor of the same dimension and shape as the input with values in the range [-inf, 0)   Examples: >>> m = nn.LogSoftmax()
>>> input = torch.randn(2, 3)
>>> output = m(input)
class torch.nn.LPPool1d(norm_type, kernel_size, stride=None, ceil_mode=False) [source]
 
Applies a 1D power-average pooling over an input signal composed of several input planes. On each window, the function computed is:  f(X)=∑x∈Xxppf(X) = \sqrt[p]{\sum_{x \in X} x^{p}}  
 At p = ∞\infty , one gets Max Pooling At p = 1, one gets Sum Pooling (which is proportional to Average Pooling)   Note If the sum to the power of p is zero, the gradient of this function is not defined. This implementation will set the gradient to zero in this case.   Parameters 
 
kernel_size – a single int, the size of the window 
stride – a single int, the stride of the window. Default value is kernel_size
 
ceil_mode – when True, will use ceil instead of floor to compute the output shape     Shape:

 Input: (N,C,Lin)(N, C, L_{in}) 
 
Output: (N,C,Lout)(N, C, L_{out}) , where  Lout=⌊Lin−kernel_sizestride+1⌋L_{out} = \left\lfloor\frac{L_{in} - \text{kernel\_size}}{\text{stride}} + 1\right\rfloor  
   Examples::

>>> # power-2 pool of window of length 3, with stride 2.
>>> m = nn.LPPool1d(2, 3, stride=2)
>>> input = torch.randn(20, 16, 50)
>>> output = m(input)
class torch.nn.LPPool2d(norm_type, kernel_size, stride=None, ceil_mode=False) [source]
 
Applies a 2D power-average pooling over an input signal composed of several input planes. On each window, the function computed is:  f(X)=∑x∈Xxppf(X) = \sqrt[p]{\sum_{x \in X} x^{p}}  
 At p = ∞\infty , one gets Max Pooling At p = 1, one gets Sum Pooling (which is proportional to average pooling)  The parameters kernel_size, stride can either be:  a single int – in which case the same value is used for the height and width dimension a tuple of two ints – in which case, the first int is used for the height dimension, and the second int for the width dimension   Note If the sum to the power of p is zero, the gradient of this function is not defined. This implementation will set the gradient to zero in this case.   Parameters 
 
kernel_size – the size of the window 
stride – the stride of the window. Default value is kernel_size
 
ceil_mode – when True, will use ceil instead of floor to compute the output shape     Shape:

 Input: (N,C,Hin,Win)(N, C, H_{in}, W_{in}) 
 
Output: (N,C,Hout,Wout)(N, C, H_{out}, W_{out}) , where  Hout=⌊Hin−kernel_size[0]stride[0]+1⌋H_{out} = \left\lfloor\frac{H_{in} - \text{kernel\_size}[0]}{\text{stride}[0]} + 1\right\rfloor  
 Wout=⌊Win−kernel_size[1]stride[1]+1⌋W_{out} = \left\lfloor\frac{W_{in} - \text{kernel\_size}[1]}{\text{stride}[1]} + 1\right\rfloor  
    Examples: >>> # power-2 pool of square window of size=3, stride=2
>>> m = nn.LPPool2d(2, 3, stride=2)
>>> # pool of non-square window of power 1.2
>>> m = nn.LPPool2d(1.2, (3, 2), stride=(2, 1))
>>> input = torch.randn(20, 16, 50, 32)
>>> output = m(input)
class torch.nn.LSTMCell(input_size, hidden_size, bias=True) [source]
 
A long short-term memory (LSTM) cell.  i=σ(Wiix+bii+Whih+bhi)f=σ(Wifx+bif+Whfh+bhf)g=tanh⁡(Wigx+big+Whgh+bhg)o=σ(Wiox+bio+Whoh+bho)c′=f∗c+i∗gh′=o∗tanh⁡(c′)\begin{array}{ll} i = \sigma(W_{ii} x + b_{ii} + W_{hi} h + b_{hi}) \\ f = \sigma(W_{if} x + b_{if} + W_{hf} h + b_{hf}) \\ g = \tanh(W_{ig} x + b_{ig} + W_{hg} h + b_{hg}) \\ o = \sigma(W_{io} x + b_{io} + W_{ho} h + b_{ho}) \\ c' = f * c + i * g \\ h' = o * \tanh(c') \\ \end{array} 
where σ\sigma  is the sigmoid function, and ∗*  is the Hadamard product.  Parameters 
 
input_size – The number of expected features in the input x
 
hidden_size – The number of features in the hidden state h
 
bias – If False, then the layer does not use bias weights b_ih and b_hh. Default: True
     Inputs: input, (h_0, c_0)

 
input of shape (batch, input_size): tensor containing input features 
h_0 of shape (batch, hidden_size): tensor containing the initial hidden state for each element in the batch. 
c_0 of shape (batch, hidden_size): tensor containing the initial cell state for each element in the batch. If (h_0, c_0) is not provided, both h_0 and c_0 default to zero.    Outputs: (h_1, c_1)

 
h_1 of shape (batch, hidden_size): tensor containing the next hidden state for each element in the batch 
c_1 of shape (batch, hidden_size): tensor containing the next cell state for each element in the batch     Variables 
 
~LSTMCell.weight_ih – the learnable input-hidden weights, of shape (4*hidden_size, input_size)
 
~LSTMCell.weight_hh – the learnable hidden-hidden weights, of shape (4*hidden_size, hidden_size)
 
~LSTMCell.bias_ih – the learnable input-hidden bias, of shape (4*hidden_size)
 
~LSTMCell.bias_hh – the learnable hidden-hidden bias, of shape (4*hidden_size)
     Note All the weights and biases are initialized from U(−k,k)\mathcal{U}(-\sqrt{k}, \sqrt{k})  where k=1hidden_sizek = \frac{1}{\text{hidden\_size}}   Examples: >>> rnn = nn.LSTMCell(10, 20)
>>> input = torch.randn(3, 10)
>>> hx = torch.randn(3, 20)
>>> cx = torch.randn(3, 20)
>>> output = []
>>> for i in range(6):
        hx, cx = rnn(input[i], (hx, cx))
        output.append(hx)