Pytorch visualization

（ One ） Network structure visualization

         Use torchinfo Open Source Toolkit for structured output , Just use torchinfo.summary() Just go . However, it should be noted that the visual network structure needs a forward propagation to obtain the information of a specific layer .

import torchvision
from torchinfo import summary
resnet18=torchvision.models.resnet18()
summary(resnet18,(batchize=64,channels=3,high=224,weight=225))# Carry out a forward communication to obtain information 

（ Two ） Convolution CNN visualization

1.CNN Convolution kernel Visualization

         The purpose of visual convolution kernel is to see what features the model extracts .

conv1 = dict(model.features.named_children())['conv1'] # By the end of 1 Layer convolution as an example , Visualize the corresponding parameters 
kernel_set = conv1.weight.detach()
num = len(conv1.weight.detach())
print(kernel_set.shape)
for i in range(0,num):
    i_kernel = kernel_set[i]
    plt.figure(figsize=(20, 17))
    if (len(i_kernel)) > 1:
        for idx, filer in enumerate(i_kernel):
            plt.subplot(9, 9, idx+1) 
            plt.axis('off')
            plt.imshow(filer[ :, :].detach(),cmap='bwr')

2.CNN Visual feature map

         Characteristics of figure ： The data obtained by each convolution layer of the input original image . Visual feature map is to see what the features extracted by the model look like .

        This usually uses PyTorch Medium hook Interface , It is equivalent to that the characteristic graph in the forward propagation of data will be hook capture , You can view it separately after forward propagation . commonly hook In addition to using what you define , You can also use PyTorch Self contained nn.Module.register_forward_hook() Methods such as .

class Hook(object):
    def __init__(self):
        self.module_name = []
        self.features_in_hook = []
        self.features_out_hook = []

    def __call__(self,module, fea_in, fea_out):    #module To know which layer of data is obtained 
        print("hooker working", self)
        self.module_name.append(module.__class__)
        self.features_in_hook.append(fea_in)
        self.features_out_hook.append(fea_out)
        return None
    

def plot_feature(model, idx, inputs):
    hh = Hook()
    model.features[i].register_forward_hook(hh) # utilize PyTorch Properties of the layer of the built-in model 
                                                 #register_forward_hook（）, Add hooks .
    
    # forward_model(model,False)
    model.eval()
    _ = model(inputs)

# Printed information 
    print(hh.module_name)
    print((hh.features_in_hook[0][0].shape))
    print((hh.features_out_hook[0].shape))
    
    out1 = hh.features_out_hook[0]

    total_ft  = out1.shape[1]
    first_item = out1[0].cpu().clone()    

    plt.figure(figsize=(20, 17))
    

    for ftidx in range(total_ft):
        if ftidx > 99:
            break
        ft = first_item[ftidx]
        plt.subplot(10, 10, ftidx+1) 
        
        plt.axis('off')
        #plt.imshow(ft[ :, :].detach(),cmap='gray')
        plt.imshow(ft[ :, :].detach())

（ 3、 ... and ） Use TensorBoard visualization

# install tensorboardX
from tensorboardX import SummaryWriter
# If you use PyTorch Self contained tensorboard, Then the following quotation 
from torch.utils.tensorboard import SummaryWriter

# start-up , Command line input 
tensorboard --logdir=/path/to/logs/ --port=xxxx
# in order to tensorboard Can run continuously in the background , You can also use nohup Order or tmux Tools to run tensorboard


# call ：
writer = SummaryWriter('./runs')# Instantiation SummaryWritter As a variable writer, And designate writer The output directory of is... Under the current directory "runs" Catalog 
writer.add_graph(model, input_to_model = torch.rand(1, 3, 224, 224))# Given an input data , The structure of the model is obtained after forward propagation , Re pass TensorBoard Visualizing 
writer.close()


# Continuous variable visualization 
writer = SummaryWriter('./tb_logs')

for i in range(500):   # Put a picture 
    x = i
    writer.add_image("x", x, i) # It's recorded in the log x In the step i  Value 
writer.close()

# The actual use 
writer = SummaryWriter('./logs')
writer.add_image(tudui,input)
writer.close()


# Parameter distribution visualization ：

for (key,val) in zip(resnet18.state_dict().keys(),resnet18.state_dict().values()):
    print(key,val)



writer = SummaryWriter('./tb_logs/')
for step, (key,val) in enumerate(zip(resnet18.state_dict().keys(),resnet18.state_dict().values()):
    writer.add_histogram("w", val, step)
    writer.flush()
writer.close()