Pytorch operations to count the number of parameters in a model

()

Returns the number of elements in param

Number of statistical model parameters

num_params = sum(() for param in ())
print(num_params)

Addendum: Pytorch View model parameters

Pytorch View model parameters

View the parameters of the model built with Pytorch, and see the program directly.

import torch
# Introduce and assign aliases
import  as nn
import  as F

class Net():
    def __init__(self):
        # Functions of subclasses must execute the constructor of the parent class in the constructor function
        super(Net, self).__init__()
        
        # Convolutional layer '1' means input image is single channel, '6' means number of output channels, '3' means convolution kernel is 3*3
        self.conv1 = nn.Conv2d(1, 6, 3) 
        #Linear layer with 1350 input features and 10 output features
        self.fc1   = (1350, 10)  # How is the 1350 calculated here? It depends on the forward function
    # Positive communication
    def forward(self, x): 
        print(()) # Results: [1, 1, 32, 32]
        # Convolution -> Activation -> Pooling
        x = self.conv1(x) # According to the convolution of the size of the formula, the result is 30, the specific formula is described in detail in the second later, Section IV Convolutional Neural Networks.
        x = (x)
        print(()) # Results: [1, 6, 30, 30]
        x = F.max_pool2d(x, (2, 2)) #We use the pooling layer and calculate 15
        x = (x)
        print(()) # Results: [1, 6, 15, 15]
        # reshape, '-1' for adaptive
        #What we're doing here is we're squashing [1, 6, 15, 15] to [1, 1350].
        x = (()[0], -1) 
        print(()) # Here's the input 1350 for the fc1 level #
        x = self.fc1(x)        
        return x

net = Net()

for parameters in ():
    print(parameters)

The output is.

Parameter containing:
tensor([[[[-0.0104, -0.0555, 0.1417],
[-0.3281, -0.0367, 0.0208],
[-0.0894, -0.0511, -0.1253]]],

[[[-0.1724, 0.2141, -0.0895],
[ 0.0116, 0.1661, -0.1853],
[-0.1190, 0.1292, -0.2451]]],

[[[ 0.1827, 0.0117, 0.2880],
[ 0.2412, -0.1699, 0.0620],
[ 0.2853, -0.2794, -0.3050]]],

[[[ 0.1930, 0.2687, -0.0728],
[-0.2812, 0.0301, -0.1130],
[-0.2251, -0.3170, 0.0148]]],

[[[-0.2770, 0.2928, -0.0875],
[ 0.0489, -0.2463, -0.1605],
[ 0.1659, -0.1523, 0.1819]]],

[[[ 0.1068, 0.2441, 0.3160],
[ 0.2945, 0.0897, 0.2978],
[ 0.0419, -0.0739, -0.2609]]]])
Parameter containing:
tensor([ 0.0782, 0.2679, -0.2516, -0.2716, -0.0084, 0.1401])
Parameter containing:
tensor([[ 1.8612e-02, 6.5482e-03, 1.6488e-02, ..., -1.3283e-02,
1.8715e-02, 5.4037e-03],
[ 1.8569e-03, 1.8022e-02, -2.3465e-02, ..., 1.6527e-03,
2.0443e-02, -2.2009e-02],
[ 9.9104e-03, 6.6134e-03, -2.7171e-02, ..., -5.7119e-03,
2.4532e-02, 2.2284e-02],
...,
[ 6.9182e-03, 1.7279e-02, -1.7783e-03, ..., 1.9354e-02,
2.1105e-03, 8.6245e-03],
[ 1.6877e-02, -1.2414e-02, 2.2409e-02, ..., -2.0604e-02,
1.3253e-02, -3.6008e-03],
[-2.1598e-02, 2.5892e-02, 1.9372e-02, ..., 1.4159e-02,
7.0983e-03, -2.3713e-02]])
Parameter containing:
tensor(1.00000e-02 *
[ 1.4703, 1.0289, 2.5069, -2.2603, -1.5218, -1.7019, 1.2569,
0.4617, -2.3082, -0.6282])

for name,parameters in net.named_parameters():
    print(name,':',())

Output.

: ([6, 1, 3, 3])
: ([6])
: ([10, 1350])
: ([10])

The above is a personal experience, I hope it can give you a reference, and I hope you can support me more.