udacity tutorial instalar example español descargar python pytorch

python - tutorial - Resumen del modelo en pytorch



pytorch udacity (7)

¿Hay alguna manera, puedo imprimir el resumen de un modelo en PyTorch como model.summary() método hace en Keras de la siguiente manera?

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

AFAK no hay model.summary () como equivalente en pytorch

Mientras tanto, puede consultar el script de szagoruyko, que ofrece una buena visualización como en resnet18-example

Aclamaciones

Esto mostrará los pesos y parámetros de un modelo (pero no la forma de salida).

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

Editar: isaykatsman tiene un RP de pytorch para agregar un model.summary() que es exactamente como keras https://github.com/pytorch/pytorch/pull/3043/files

Para usar el tipo torchsummary:

from torchsummary import summary

Instálalo primero si no lo tienes.

pip install torchsummary

Y luego puede probarlo, pero tenga en cuenta que por alguna razón no funciona a menos que configure el modelo en cuda 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)

El summary debe tomar el tamaño de entrada y el tamaño del lote se establece en -1, es decir, cualquier tamaño de lote que proporcionemos.

Si establecemos summary(alexnet, (3, 224, 224), 32) esto significa usar bs=32 .

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

Fuera:

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

Sí, puede obtener la representación exacta de Keras, utilizando el paquete pytorch-summary .

Ejemplo para VGG16

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

Si bien no obtendrá información tan detallada sobre el modelo como en el resumen del modelo de Keras, simplemente imprimiendo el modelo le dará una idea de las diferentes capas involucradas y sus especificaciones.

Por ejemplo:

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

La salida en este caso sería algo así:

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

Ahora podría, como lo menciona Kashyap , usar el método state_dict para obtener los pesos de las diferentes capas. Pero el uso de esta lista de capas tal vez proporcione más dirección es crear una función de ayuda para que Keras tenga un resumen del modelo. ¡Espero que esto ayude!

Simplemente imprima el modelo después de definir un objeto para la clase de modelo

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)