পাইটোর্কে মডেল সংক্ষিপ্তসার

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

আপনি কেরাসের মডেল হিসাবে যেমন মডেল সম্পর্কে বিস্তারিত তথ্য পাবেন না.সমনারি, কেবলমাত্র মডেলটি মুদ্রণ করা আপনাকে জড়িত বিভিন্ন স্তর এবং তাদের বৈশিষ্ট্য সম্পর্কে কিছু ধারণা দেবে give

এই ক্ষেত্রে:

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 সবার জন্য সত্য?

— আদিকৃত

@ এডিক্সিট, এটি আপনার নেটওয়ার্কের ইনপুটগুলির মাত্রা, এক্ষেত্রে এটি ইমেজনেট ডেটাসেটের একটি 224x224 আরজিবি চিত্র, সুতরাং (3, 224, 224)। আরও সাধারণভাবে, 2 ডি ইনপুটটির জন্য আকৃতিটি (সি, এইচ, ডাব্লু) যেখানে সি = চ্যানেল, এইচ = উচ্চতা এবং ডাব্লু = প্রস্থ এবং 1 ডি ইনপুট জন্য এটি হবে (সি, এল) যেখানে সি = চ্যানেল এবং এল = দৈর্ঘ্য।

— ফ্লোরেন্ট এফ

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
# )

সম্পাদনা করুন: ইসায়াকটসমানের সাথে পাইরঞ্চ পিআর রয়েছে model.summary()যা ঠিক কেরাসের মতো হয় https://github.com/pytorch/pytorch/pull/3043/files

Comments

ধন্যবাদ, হ্যাঁ :)। আমি টর্চ রিপ্রার থেকে ধার নিয়েছি তবে এটি পুনরাবৃত্ত করে তুলেছে এবং কেরাসের মতো আরও তথ্য দিয়েছি।

— wassname

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")

আপনি একটি নেটওয়ার্ক তৈরি করতে পারেন এবং আপনি যদি এমএনআইএসটি ডেটাসেট ব্যবহার করছেন তবে নিম্নলিখিত কমান্ডগুলি কাজ করবে এবং আপনাকে সংক্ষিপ্তসার প্রদর্শন করবে

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

Answer 7

আফাকের পাইটর্কের সমতুল্য কোনও মডেল নেই s

ইতিমধ্যে আপনি জাজোরুইকো দ্বারা স্ক্রিপ্টটি উল্লেখ করতে পারেন , যা পুনরায় 18-উদাহরণের মতো একটি দুর্দান্ত ভিজ্যুয়াল্যাটন দেয়

চিয়ার্স

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মডেলগুলির ভিজ্যুয়ালাইজেশন এবং সংক্ষিপ্তসার জন্য , টেনসরবোর্ড এক্সও ব্যবহার করা যেতে পারে।