Pytorch में मॉडल सारांश

Question

क्या कोई तरीका है, मैं एक मॉडल के सारांश को प्रिंट कर सकता हूं जैसे कि केरेस में model.summary()विधि क्या है?

Model Summary:
____________________________________________________________________________________________________
Layer (type)                     Output Shape          Param #     Connected to                     
====================================================================================================
input_1 (InputLayer)             (None, 1, 15, 27)     0                                            
____________________________________________________________________________________________________
convolution2d_1 (Convolution2D)  (None, 8, 15, 27)     872         input_1[0][0]                    
____________________________________________________________________________________________________
maxpooling2d_1 (MaxPooling2D)    (None, 8, 7, 27)      0           convolution2d_1[0][0]            
____________________________________________________________________________________________________
flatten_1 (Flatten)              (None, 1512)          0           maxpooling2d_1[0][0]             
____________________________________________________________________________________________________
dense_1 (Dense)                  (None, 1)             1513        flatten_1[0][0]                  
====================================================================================================
Total params: 2,385
Trainable params: 2,385
Non-trainable params: 0

Comments

क्या आपने मॉड्यूल पर State_dict () विधि देखी है ?? यह आपको मॉडल के विभिन्न पैरामीटर देता है। कोई प्रत्यक्ष सारांश विधि नहीं है, लेकिन राज्य_डिक्ट () पद्धति का उपयोग करके कोई भी बना सकता है

— कश्यप

चयनित उत्तर अब पुराना torchsummaryहै, बेहतर समाधान है।

— एम। दोस्ती लखानी

Answer 1

हालांकि आपको मॉडल के बारे में केरस की मॉडल.सुमरी की विस्तृत जानकारी नहीं मिलेगी, बस मॉडल को प्रिंट करने से आपको इसमें शामिल विभिन्न परतों और उनके विनिर्देशों के बारे में कुछ विचार मिलेगा।

उदाहरण के लिए:

from torchvision import models
model = models.vgg16()
print(model)

इस मामले में आउटपुट कुछ इस प्रकार होगा:

VGG (
  (features): Sequential (
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU (inplace)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU (inplace)
    (4): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU (inplace)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU (inplace)
    (9): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU (inplace)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU (inplace)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU (inplace)
    (16): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU (inplace)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU (inplace)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU (inplace)
    (23): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU (inplace)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU (inplace)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU (inplace)
    (30): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
  )
  (classifier): Sequential (
    (0): Dropout (p = 0.5)
    (1): Linear (25088 -> 4096)
    (2): ReLU (inplace)
    (3): Dropout (p = 0.5)
    (4): Linear (4096 -> 4096)
    (5): ReLU (inplace)
    (6): Linear (4096 -> 1000)
  )
)

अब आप कश्यप द्वारा बताए गए state_dictतरीके का उपयोग कर विभिन्न परतों के वजन प्राप्त कर सकते हैं। लेकिन परतों की इस सूची का उपयोग करना शायद अधिक दिशा प्रदान करेगा ताकि मॉडल सारांश की तरह केरस प्राप्त करने के लिए एक सहायक फ़ंक्शन बनाया जा सके! उम्मीद है की यह मदद करेगा!

Comments

हां, "प्रिंट" का उपयोग करें।

— ब्रूस

Answer 2

हां, आप पाइरॉच-सारांश पैकेज का उपयोग करके सटीक केरस प्रतिनिधित्व प्राप्त कर सकते हैं ।

वीजीजी 16 के लिए उदाहरण

from torchvision import models
from torchsummary import summary

vgg = models.vgg16()
summary(vgg, (3, 224, 224))

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 224, 224]           1,792
              ReLU-2         [-1, 64, 224, 224]               0
            Conv2d-3         [-1, 64, 224, 224]          36,928
              ReLU-4         [-1, 64, 224, 224]               0
         MaxPool2d-5         [-1, 64, 112, 112]               0
            Conv2d-6        [-1, 128, 112, 112]          73,856
              ReLU-7        [-1, 128, 112, 112]               0
            Conv2d-8        [-1, 128, 112, 112]         147,584
              ReLU-9        [-1, 128, 112, 112]               0
        MaxPool2d-10          [-1, 128, 56, 56]               0
           Conv2d-11          [-1, 256, 56, 56]         295,168
             ReLU-12          [-1, 256, 56, 56]               0
           Conv2d-13          [-1, 256, 56, 56]         590,080
             ReLU-14          [-1, 256, 56, 56]               0
           Conv2d-15          [-1, 256, 56, 56]         590,080
             ReLU-16          [-1, 256, 56, 56]               0
        MaxPool2d-17          [-1, 256, 28, 28]               0
           Conv2d-18          [-1, 512, 28, 28]       1,180,160
             ReLU-19          [-1, 512, 28, 28]               0
           Conv2d-20          [-1, 512, 28, 28]       2,359,808
             ReLU-21          [-1, 512, 28, 28]               0
           Conv2d-22          [-1, 512, 28, 28]       2,359,808
             ReLU-23          [-1, 512, 28, 28]               0
        MaxPool2d-24          [-1, 512, 14, 14]               0
           Conv2d-25          [-1, 512, 14, 14]       2,359,808
             ReLU-26          [-1, 512, 14, 14]               0
           Conv2d-27          [-1, 512, 14, 14]       2,359,808
             ReLU-28          [-1, 512, 14, 14]               0
           Conv2d-29          [-1, 512, 14, 14]       2,359,808
             ReLU-30          [-1, 512, 14, 14]               0
        MaxPool2d-31            [-1, 512, 7, 7]               0
           Linear-32                 [-1, 4096]     102,764,544
             ReLU-33                 [-1, 4096]               0
          Dropout-34                 [-1, 4096]               0
           Linear-35                 [-1, 4096]      16,781,312
             ReLU-36                 [-1, 4096]               0
          Dropout-37                 [-1, 4096]               0
           Linear-38                 [-1, 1000]       4,097,000
================================================================
Total params: 138,357,544
Trainable params: 138,357,544
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 218.59
Params size (MB): 527.79
Estimated Total Size (MB): 746.96
----------------------------------------------------------------

Comments

मुझे Expected object of backend CPU but got backend CUDA for argument #4 'mat1'यह कहते हुए एक त्रुटि हुई, और ऐसा लगता है कि कोई दस्तावेज नहीं है।

— डेविड जंग

एक समाधान मिला। summary(model.cuda(), (INPUT_SHAPE))काम करता है।

— डेविड जंग

यह अच्छा है, क्योंकि प्रिंट (मॉडल) आउटपुट आकार नहीं दिखाता है!

— आईबियर

नमस्ते। मैं इसके लिए नया हूं लेकिन मुझे किसी मॉडल के लिए आवश्यक इनपुट आकार कैसे पता चलेगा? क्या यह उन सभी के लिए 3, 224, 224 सही है?

— आदिकाल

@adikshit, यह आपके नेटवर्क के इनपुट का आयाम है, इस मामले में यह इमेजनेट डेटासेट से 224x224 RGB इमेज है, इसलिए (3, 224, 224)। आम तौर पर एक 2D इनपुट के लिए आकार (C, H, W) है जहां C = चैनल, H = ऊंचाई और W = चौड़ाई, और 1D इनपुट के लिए यह (C, L) जहां C = चैनल और L = होगा लंबाई।

— फ्लोरेंट एफ

Answer 3

मशालों के प्रकार का उपयोग करने के लिए:

from torchsummary import summary

यदि आपके पास नहीं है तो पहले इसे स्थापित करें।

pip install torchsummary 

और फिर आप इसे आज़मा सकते हैं, लेकिन किसी कारण से ध्यान दें जब तक मैं मॉडल को क्यूडा में सेट नहीं करता, यह काम नहीं कर रहा है alexnet.cuda:

from torchsummary import summary
help(summary)
import torchvision.models as models
alexnet = models.alexnet(pretrained=False)
alexnet.cuda()
summary(alexnet, (3, 224, 224))
print(alexnet)

summaryइनपुट आकार ले लेना चाहिए और बैच का आकार करने के लिए -1 किसी भी बैच का आकार हम प्रदान अर्थ निर्धारित है।

यदि हम summary(alexnet, (3, 224, 224), 32)इसका मतलब सेट करते हैं तो इसका उपयोग करें bs=32।

summary(model, input_size, batch_size=-1, device='cuda')

---

बाहर:

Help on function summary in module torchsummary.torchsummary:

summary(model, input_size, batch_size=-1, device='cuda')

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1           [32, 64, 55, 55]          23,296
              ReLU-2           [32, 64, 55, 55]               0
         MaxPool2d-3           [32, 64, 27, 27]               0
            Conv2d-4          [32, 192, 27, 27]         307,392
              ReLU-5          [32, 192, 27, 27]               0
         MaxPool2d-6          [32, 192, 13, 13]               0
            Conv2d-7          [32, 384, 13, 13]         663,936
              ReLU-8          [32, 384, 13, 13]               0
            Conv2d-9          [32, 256, 13, 13]         884,992
             ReLU-10          [32, 256, 13, 13]               0
           Conv2d-11          [32, 256, 13, 13]         590,080
             ReLU-12          [32, 256, 13, 13]               0
        MaxPool2d-13            [32, 256, 6, 6]               0
AdaptiveAvgPool2d-14            [32, 256, 6, 6]               0
          Dropout-15                 [32, 9216]               0
           Linear-16                 [32, 4096]      37,752,832
             ReLU-17                 [32, 4096]               0
          Dropout-18                 [32, 4096]               0
           Linear-19                 [32, 4096]      16,781,312
             ReLU-20                 [32, 4096]               0
           Linear-21                 [32, 1000]       4,097,000
================================================================
Total params: 61,100,840
Trainable params: 61,100,840
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 18.38
Forward/backward pass size (MB): 268.12
Params size (MB): 233.08
Estimated Total Size (MB): 519.58
----------------------------------------------------------------
AlexNet(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
    (1): ReLU(inplace)
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU(inplace)
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU(inplace)
    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU(inplace)
    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace)
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
  (classifier): Sequential(
    (0): Dropout(p=0.5)
    (1): Linear(in_features=9216, out_features=4096, bias=True)
    (2): ReLU(inplace)
    (3): Dropout(p=0.5)
    (4): Linear(in_features=4096, out_features=4096, bias=True)
    (5): ReLU(inplace)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

Answer 4

यह एक मॉडल के वजन और मापदंडों (लेकिन आउटपुट आकार नहीं) दिखाएगा।

from torch.nn.modules.module import _addindent
import torch
import numpy as np
def torch_summarize(model, show_weights=True, show_parameters=True):
    """Summarizes torch model by showing trainable parameters and weights."""
    tmpstr = model.__class__.__name__ + ' (\n'
    for key, module in model._modules.items():
        # if it contains layers let call it recursively to get params and weights
        if type(module) in [
            torch.nn.modules.container.Container,
            torch.nn.modules.container.Sequential
        ]:
            modstr = torch_summarize(module)
        else:
            modstr = module.__repr__()
        modstr = _addindent(modstr, 2)

        params = sum([np.prod(p.size()) for p in module.parameters()])
        weights = tuple([tuple(p.size()) for p in module.parameters()])

        tmpstr += '  (' + key + '): ' + modstr 
        if show_weights:
            tmpstr += ', weights={}'.format(weights)
        if show_parameters:
            tmpstr +=  ', parameters={}'.format(params)
        tmpstr += '\n'   

    tmpstr = tmpstr + ')'
    return tmpstr

# Test
import torchvision.models as models
model = models.alexnet()
print(torch_summarize(model))

# # Output
# AlexNet (
#   (features): Sequential (
#     (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2)), weights=((64, 3, 11, 11), (64,)), parameters=23296
#     (1): ReLU (inplace), weights=(), parameters=0
#     (2): MaxPool2d (size=(3, 3), stride=(2, 2), dilation=(1, 1)), weights=(), parameters=0
#     (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2)), weights=((192, 64, 5, 5), (192,)), parameters=307392
#     (4): ReLU (inplace), weights=(), parameters=0
#     (5): MaxPool2d (size=(3, 3), stride=(2, 2), dilation=(1, 1)), weights=(), parameters=0
#     (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), weights=((384, 192, 3, 3), (384,)), parameters=663936
#     (7): ReLU (inplace), weights=(), parameters=0
#     (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), weights=((256, 384, 3, 3), (256,)), parameters=884992
#     (9): ReLU (inplace), weights=(), parameters=0
#     (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)), weights=((256, 256, 3, 3), (256,)), parameters=590080
#     (11): ReLU (inplace), weights=(), parameters=0
#     (12): MaxPool2d (size=(3, 3), stride=(2, 2), dilation=(1, 1)), weights=(), parameters=0
#   ), weights=((64, 3, 11, 11), (64,), (192, 64, 5, 5), (192,), (384, 192, 3, 3), (384,), (256, 384, 3, 3), (256,), (256, 256, 3, 3), (256,)), parameters=2469696
#   (classifier): Sequential (
#     (0): Dropout (p = 0.5), weights=(), parameters=0
#     (1): Linear (9216 -> 4096), weights=((4096, 9216), (4096,)), parameters=37752832
#     (2): ReLU (inplace), weights=(), parameters=0
#     (3): Dropout (p = 0.5), weights=(), parameters=0
#     (4): Linear (4096 -> 4096), weights=((4096, 4096), (4096,)), parameters=16781312
#     (5): ReLU (inplace), weights=(), parameters=0
#     (6): Linear (4096 -> 1000), weights=((1000, 4096), (1000,)), parameters=4097000
#   ), weights=((4096, 9216), (4096,), (4096, 4096), (4096,), (1000, 4096), (1000,)), parameters=58631144
# )

संपादित करें: isaykatsman के पास एक pytorch PR है model.summary()जिसे जोड़ने के लिए keras https://github.com/pytorch/pytorch/pull/3043/files जैसा है

Comments

धन्यवाद, हाँ :)। मैं उधार मशालों से repr लेकिन यह पुनरावर्ती बना दिया है और keras की तरह अधिक जानकारी दे दी है।

— isname

Answer 5

याद रखने के लिए सबसे सरल (केरस के रूप में सुंदर नहीं):

print(model)

यह भी काम करता है:

repr(model)

यदि आप केवल मापदंडों की संख्या चाहते हैं:

sum([param.nelement() for param in model.parameters()])

से: क्या मॉडल के रूप में समान पाइरॉच फ़ंक्शन है। कोरस के रूप में सौमरी ()? (forum.PyTorch.org)

Answer 6

आप उपयोग कर सकते हैं

from torchsummary import summary

आप डिवाइस निर्दिष्ट कर सकते हैं

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

आप एक नेटवर्क बना सकते हैं, और यदि आप MNIST डेटासेट का उपयोग कर रहे हैं, तो निम्नलिखित कमांड काम करेंगे और आपको सारांश दिखाएंगे

model = Network().to(device)
summary(model,(1,28,28))

Answer 7

AFAK कोई मॉडल नहीं है। pumorch में समतुल्य (जैसे)

इस बीच आप स्क्रिप्ट को szagoruyko द्वारा संदर्भित कर सकते हैं , जो कि resnet18-example की तरह एक अच्छा विज़िज़िटन देता है

चियर्स

Answer 8

मॉडल वर्ग के लिए एक वस्तु को परिभाषित करने के बाद मॉडल को प्रिंट करें

class RNN(nn.Module):
    def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim):
        super().__init__()

        self.embedding = nn.Embedding(input_dim, embedding_dim)
        self.rnn = nn.RNN(embedding_dim, hidden_dim)
        self.fc = nn.Linear(hidden_dim, output_dim)
    def forward():
        ...

model = RNN(input_dim, embedding_dim, hidden_dim, output_dim)
print(model)

Answer 9

आप केवल उपयोग कर सकते हैं x.shape, ताकि दसियों के xआयामों को माप सकें

Answer 10

PyTorchमॉडल के विज़ुअलाइज़ेशन और सारांश के लिए , टेंसरबोर्ड एक्सएक्सएक्स का भी उपयोग किया जा सकता है।