可视化卷积神经网络的特征和过滤器

深度学习图像处理04:图像分类模型训练实战——动物分类 本文深入探讨了深度学习在图像分类任务中的应用,以动物分类为例进行了实战演练。我们从数据集的准备和预处理开始,探讨了如何通过调整图像尺寸和应用数据增强技术来提高模型的泛化能力。接着,我们讨论了不同的深度学习模型架构,训练代码中集成了如ResNet和MobileNet等模型,并介绍了如何使用PyTorch框架来训练这些模型。我们通过命令行参数灵活地控制训练过程,允许用户自定义模型训练的各个方面,包括模型的选择、是否使用预训练权重、学习率和批大小等。 阅读详情

卷积神经网络是一种特殊类型的人工神经网络,广泛应用于图像识别。这种架构的成功始于 2015 年,当时凭借这种方法赢得了 ImageNet 图像分类挑战。

这些方法非常强大并且能够很好地进行预测,但同时它们也难以解释。因此,它们也被称为黑盒模型。

肯定是可用的与模型无关的方法,如LIME和部分依赖图,可以应用于任何模型。但在这种情况下,应用专为神经网络开发的可解释方法更有意义。与 ML 模型不同,卷积神经网络从原始图像像素中学习抽象特征 [1]。

在这篇文章中,我将重点介绍卷积神经网络如何学习特征。这可以通过逐步学习的特征的可视化来实现。在展示 Pythorch 的实现之前,我将解释 CNN 的工作原理,然后我将可视化为分类任务训练的 CNN 学习的特征图和感受野。

本文内容:

  1. 什么是CNN

  2. 定义和训练CNN的MNIST

  3. 在测试集4上评估模型

  4. 可视化过滤器

  5. 可视化特征图

什么是CNN

cnn由构建模块组成:卷积层、池化层和全连接层。卷积层的主要功能是提取特征或所谓的特征映射。它是如何做到的呢?它使用来自数据集[2]的多个过滤器。

之后,通过池化层将卷积运算得到的特征映射降维。最常用的池化操作是Maxpooling,它选择feature map中每个filter patch中最显著的像素值。因此,这两种类型的层对于进行特征提取是很有用的。

与卷积层和池化层不同的是,全连接层将提取的特征映射到最终的输出中,例如MNIST图像的分类为10位数字之一。

在数字图像中,一个二维网格存储像素值。它可以看作是一组数字。内核是一个小网格,通常大小为3x3,应用于图像的每个位置。当你深入到更深的层次时,这些特性会变得越来越复杂。

模型的性能是通过一个损失函数,即输出和目标标签之间的差异,通过在训练集上的前向传播,并通过梯度下降算法的反向传播更新参数,如权值和偏差。

定义和训练CNN的MNIST数据集

让我们首先导入库和数据集。Torch是为一维或多维张量提供数据结构的模块。

几个重要的包:

Torchvision:在我们的例子中,它为我们提供了MNIST数据集。

torch.nn:包含帮助你构建卷积神经网络的类和函数。

torch.optim:提供了所有的优化器,比如Adam。

torch.nn.functional:用于导入函数,如dropout、convolution、pooling、非线性激活函数和loss函数等。

我们下载训练和测试数据集,并将图像数据集转换为张量。我们不需要对图像进行归一化,因为数据集已经包含了灰度图像。将训练数据集划分为训练集和验证集。random_split为这两个集合提供了一个随机分区。DataLoader用于为训练、验证和测试集创建数据加载器,这些数据加载器被划分为小批。batchsize是模型训练过程中一次迭代中使用的样本数量。

 import matplotlib.pyplot as plt
 import numpy as np
 import torch
 import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import Dataset, DataLoader,TensorDataset,random_split,SubsetRandomSampler, ConcatDataset
 from torch.nn import functional as F
 import torchvision
 from torchvision import datasets,transforms
 import torchvision.transforms as transforms
 
 train_dataset = torchvision.datasets.MNIST('classifier_data', train=True, download=True)
 test_dataset  = torchvision.datasets.MNIST('classifier_data', train=False, download=True)
 
 transform = torchvision.transforms.Compose([
     torchvision.transforms.ToTensor()
 ])
 
 train_dataset.transform=transform
 test_dataset.transform=transform
 
 m=len(train_dataset)
 
 #random_split randomly split a dataset into non-overlapping new datasets of given lengths
 train_data, val_data = random_split(train_dataset, [int(m-m*0.2), int(m*0.2)])
 
 batch_size=128
 
 # The dataloaders handle shuffling, batching, etc...
 train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size)
 valid_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size)
 test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,shuffle=True)
 
 print("Batches in Train Loader: {}".format(len(train_loader)))
 print("Batches in Valid Loader: {}".format(len(valid_loader)))
 print("Batches in Test Loader: {}".format(len(test_loader)))
 
 print("Examples in Train Loader: {}".format(len(train_loader.sampler)))
 print("Examples in Valid Loader: {}".format(len(valid_loader.sampler)))
 print("Examples in Test Loader: {}".format(len(test_loader.sampler)))

我们定义了CNN架构。

 class ConvNet(nn.Module):
     def __init__(self,h1=96):
         # We optimize dropout rate in a convolutional neural network.
         super(ConvNet, self).__init__()
 
         self.conv1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=5, stride=1, padding=2)
         self.conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=5, stride=1, padding=2)
         self.drop1=nn.Dropout2d(p=0.5)  
         
         self.fc1 = nn.Linear(32 * 7 * 7, h1)
         self.drop2=nn.Dropout2d(p=0.1)
         self.fc2 = nn.Linear(h1, 10)
 
     def forward(self, x):
         x = F.relu(F.max_pool2d(self.conv1(x),kernel_size = 2))
         x = F.relu(F.max_pool2d(self.conv2(x),kernel_size = 2))
         x = self.drop1(x)
 
         x = x.view(x.size(0),-1)
 
         x = F.relu(self.fc1(x))
         x = self.drop2(x)
         return self.fc2(x)

我们可以很容易地打印架构来快速了解一下:

您可以看到有两个卷积层和两个完全连接的层。每个卷积层之后是ReLU激活函数和maxpooling层。视图函数将数据重塑为一维数组,并将其传递给线性层。第二个完全连接的层,也称为输出层,将图像分类为10位数字之一。

我们定义构建块,将用于训练CNN:

  1. 用硬件加速器比如GPU来训练模型

  2. CNN网络,这将被转移到设备上

  3. 交叉熵损失和Adam优化器

 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 torch.manual_seed(0)
 model = ConvNet()
 model.to(device)
 optimizer = optim.Adam(model.parameters(), lr=0.002)
 criterion= nn.CrossEntropyLoss()

现在,我们可以在训练集中训练网络,并在验证集中对其进行评估:

 history={'train_loss':[],'valid_loss':[],'train_acc':[],'valid_acc':[]}
 num_epochs=10
 
 for epoch in range(num_epochs):
     train_loss,train_correct=0.0,0
     model.train()
     for images, labels in train_loader:
 
         images,labels = images.to(device),labels.to(device)
         optimizer.zero_grad()
         output = model(images)
         loss = criterion(output,labels)
         loss.backward()
         optimizer.step()
         train_loss += loss.item() * images.size(0)
         scores, predictions = torch.max(output.data, 1)
         train_correct += (predictions == labels).sum().item()    
     
     valid_loss, val_correct = 0.0, 0
     model.eval()
     for images, labels in valid_loader:
 
         images,labels = images.to(device),labels.to(device)
         output = model(images)
         loss=criterion(output,labels)
         valid_loss+=loss.item()*images.size(0)
         scores, predictions = torch.max(output.data,1)
         val_correct+=(predictions == labels).sum().item()
 
     train_loss = train_loss / len(train_loader.sampler)
     train_acc = train_correct / len(train_loader.sampler)*100
     valid_loss = valid_loss / len(valid_loader.sampler)
     valid_acc = val_correct / len(valid_loader.sampler) * 100
 
     print("Epoch:{}/{} \t AVERAGE TL:{:.4f} AVERAGE VL:{:.4f} \t AVERAGE TA:{:.2f} %  AVERAGE VA:{:.2f} %".format(epoch + 1, num_epochs,
                                                                                          train_loss,
                                                                                          valid_loss,
                                                                                          train_acc,
                                                                                         valid_acc))
     history['train_loss'].append(train_loss)    
     history['valid_loss'].append(valid_loss)  
     history['train_acc'].append(train_acc)  
     history['valid_acc'].append(valid_acc)  

训练代码可以分为两部分。

向前传播:

  • 我们通过模型(images)将输入图像传递给网络

  • 损失是通过调用标准(输出,标签)来计算的,其中输出构成预测类,标签构成目标类。

反向传播:

  • 清除梯度以确保我们不会用optimizer.zero_grad()积累其他值

  • loss.backward()用于执行反向传播,并根据损失计算梯度

  • step()总是在梯度计算之后。它遍历所有参数并更新它们的值。

对训练集和验证集都计算损失函数和准确性。

在测试集上评估模型

模型训练完成后,我们可以对测试集的性能进行评估:

 correct = 0
 total = 0
 test_loss = 0
 with torch.no_grad():
     for images, labels in test_loader:
         images, labels = images.to(device), labels.to(device)
         outputs = model(images)
         loss = criterion(outputs,labels)
         test_loss += loss.item() * images.size(0)
         _, predicted = torch.max(outputs.data, 1)
         total += labels.size(0)
         correct += (predicted == labels).sum().item()
 
 test_loss = test_loss / len(test_loader.sampler)
 
 print('Accuracy of the network on the test images: {:.2f} %%'.format(100 * correct / total))
 print('Loss of the network on the test images: {:.4f}'.format(test_loss))

让我们把测试代码分解成小块:

torch.no_grad()用于禁用梯度跟踪,我们不再需要计算梯度,因为模型已经训练。

将输入图像传递给网络

  1. 通过添加loss.item()*images.size(0)计算测试损失

  2. 通过添加(predicted==labels).sum().item()计算测试精度

可视化过滤器

我们可以将学习到的过滤器可视化,CNN使用它来卷积feature map,其中包含从上一层提取的特征。可以通过遍历模型的所有层,list(model.children())来获得这些过滤器。如果层是卷积的,我们可以将权重存储在model_weights列表中,该列表将包含两个卷积层中使用的过滤器。

 model_weights = [] 
 conv_layers = [] 
 model_children = list(model.children())
 
 # counter to keep count of the conv layers
 counter = 0 
 # append all the conv layers and their respective weights to the list
 for i in range(len(model_children)):
     if type(model_children[i]) == nn.Conv2d:
         counter += 1
         model_weights.append(model_children[i].weight)
         conv_layers.append(model_children[i])
     elif type(model_children[i]) == nn.Sequential:
         for j in range(len(model_children[i])):
             for child in model_children[i][j].children():
                 if type(child) == nn.Conv2d:
                     counter += 1
                     model_weights.append(child.weight)
                     conv_layers.append(child)
 print(f"Total convolutional layers: {counter}")

下面是我找到的过滤器的形状。

 for weight, conv in zip(model_weights, conv_layers):
     # print(f"WEIGHT: {weight} \nSHAPE: {weight.shape}")
     print(f"CONV: {conv} ====> SHAPE: {weight.shape}")

现在,我们可以可视化学习到的第一个卷积层的滤波器:

 # visualize the first conv layer filters
 plt.figure(figsize=(20, 17))
 for i, filter in enumerate(model_weights[0]):
     plt.subplot(4, 4, i+1) # we have 5x5 filters and total of 16 (see printed shapes)
     plt.imshow(filter[0, :, :].detach().cpu().numpy(), cmap='viridis')
     plt.axis('off')
     plt.savefig('filter1.png')
 plt.show()

现在,轮到可视化第二层卷积层的滤波器了。

 # visualize the second conv layer filters
 plt.figure(figsize=(20, 17))
 for i, filter in enumerate(model_weights[1]):
     plt.subplot(6, 6, i+1) # (8, 8) because in conv0 we have 5x5 filters and total of 64 (see printed shapes)
     plt.imshow(filter[0, :, :].detach().cpu().numpy(), cmap='viridis')
     plt.axis('off')
     plt.savefig('filter2.png')
 plt.show()

可视化特征图

Feature Map,又称Activation Map,是通过卷积运算得到的,通过filter/kernel将其应用到输入数据上。下面,我们定义一个函数来提取应用激活函数后获得的特征。

 activation = {}
 def get_activation(name):
     def hook(model, input, output):
         activation[name] = output.detach()
     return hook

从训练数据集中,我们取一个代表数字9的图像。因此,我们将在第一个卷积层中可视化该图像获得的特征映射。

 model.conv1.register_forward_hook(get_activation('conv1'))
 data, _ = train_dataset[4]
 data=data.to(device)
 data.unsqueeze_(0)
 output = model(data)
 
 k=0
 act = activation['conv1'].squeeze()
 fig,ax = plt.subplots(4,4,figsize=(12, 15))
 
 for i in range(act.size(0)//4):
         for j in range(act.size(0)//4):
            ax[i,j].imshow(act[k].detach().cpu().numpy())
            k+=1    
            plt.savefig('fm1.png')

现在,我们在第二层卷积中将同一幅图像获得的特征映射可视化。

 model.conv2.register_forward_hook(get_activation('conv2'))
 data, _ = train_dataset[4]
 data=data.to(device)
 data.unsqueeze_(0)
 output = model(data)
 act = activation['conv2'].squeeze()
 
 fig, axarr = plt.subplots(act.size(0)//4,4,figsize=(12, 16))
 k=0
 for i in range(act.size(0)//4):
         for j in range(4):
           axarr[i,j].imshow(act[k].detach().cpu().numpy())
           k+=1  
           plt.savefig('fm2.png')

最后总结

恭喜你!您已经学会了用Pytorch将CNN学到的特征可视化。网络在其卷积层中学习新的、日益复杂的特征。从第一个卷积层到第二个卷积层,您可以看到这些特征的差异。在卷积层中走得越远,特征就越抽象。

感谢你的阅读。祝你过得愉快。

作者:Eugenia Anello

原文地址:https://medium.com/dataseries/visualizing-the-feature-maps-and-filters-by-convolutional-neural-networks-e1462340518e

卷积神经网络CNN的可视化 通常我们认为深度学习模型是“黑盒”的,即模型学到的表示很难用人类可以理解的方式来提取和呈现。然而对于卷积神经网络来说却不是这样的。CNN学到的表示非常适合可视化,因为CNN本身就是视觉概念的表示。 CNN可视化和解释:【本文给出3个层面的可视化】 1)可视化卷积神经网络的中间输出(中间激活) 有助于理解卷积网络神经连续的层如何对输入进行变换,也有助于初步了解卷积神经网络每个过滤器的含义。 ... 阅读详情

相关推荐

kaggle 猫狗数据集二分类 系列(4)使用神经网络可视化 去看网络中间层提取的特征是什么样子

系列(1)构建模型进行二分类,保存模型,画出走势图 系列(2)采用数据增强再次训练 系列(3)采用预训练网络再次训练 系列(4)使用神经网络可视化 去看网络中间层提取的特征是什么样子 ...

q742971636的博客 2909

PyTorch入门精简资料(七)手写数字识别

Datawhale_Task7 手写数字识别 用PyTorch完成手写数字识别 1.MNIST数据集转换为图像 import os import struct import numpy as np import cv2 def create_txt(path_txt, str_data): if not os.path.exists(path_txt): wi...

Courageux_J的博客 346

AI人工智能深度学习算法:卷积神经网络的可视化技术

AI人工智能深度学习算法:卷积神经网络的可视化技术 1.背景介绍 卷积神经网络(Convolutional Neural Networks, CNNs)作为深度学习领域的核心技术之一,已经在图像识别、自然语言处理等多个领域取得了显著的成果。然而,随着模型复杂度的增加,理解和

AI天才研究院 354

CNN卷积神经网络

1、 CNN 的第一层通常是卷积层(Convolutional Layer)。 首先需要了解卷积层的输入内容是什么?如上所述,输入内容为一个 32 x 32 x 3 的像素值数组。解释卷积层的最佳方法是想象有一束手电筒光正从图像的左上角照过。假设手电筒光可以覆盖 5 x 5 的区域,想象一下手电筒光照过输入图像的所有区域。在机器学习术语中,这束手电筒被叫做过滤器(filter,有时候也被称为神经元(neuron)或核(kernel)),被照过的区域被称为感受野(receptive ...

zsj777的专栏 1128

第57步 深度学习图像识别:CNN可视化(Pytorch)

第57步 深度学习图像识别:CNN可视化(Pytorch)

Jet4505的博客 1396

Android 白名单保活实战:主流厂商适配指南

本文详细解析了Android应用白名单保活的实战策略,重点针对华为、小米、OPPO、vivo等主流厂商的系统特性,提供了精准的后台设置页面跳转适配方案。文章从基础的前台服务实现讲起,深入讲解了白名单的判断、申请与厂商适配的核心代码与避坑指南,旨在帮助开发者合规、稳定地提升应用后台存活率。

motor的博客 1863

卷积神经网络(深度学习系列第四课)

深度学习系列第四课笔记记录

qq_42815552的博客 1760

使用KITTI数据集测试不同算法的性能

该文章将使用同一个kitti数据集来测试不同算法的性能,目前已经测试的算法包括:LIO-SAM,FAST-LIO2,Point-LIO,Faster-LIO。

wwtx的博客 2587

神经网络中的通道数,卷积核和过滤器的区别

一 在卷积神经网络中需要输入in_channels和out_channels,即输入通道数和输出通道数。,如果是彩色的,即RGB类型,这时候通道数固定为3,如果是灰色的,通道数为1。卷积核就是由长和宽来指定的,是一个二维的概念。卷积核就是由长和宽来指定的,是一个二维的概念。3.对于第二层或者更多层的卷积,此时的。过滤器比卷积核高一个维度——深度。2.卷积完成之后,输出的通道数。过滤器可以看做是卷积核的集合。设置的就是过滤器的数目。指定的,是一个三维的概念。还是取决于过滤器数目。二 卷积核与过滤器的区别。

weixin_51959584的博客 1023

《Python Web项目集锦》-专栏介绍和目录

本专栏专注于Python Web项目,涉及内容包含FastAPI、Django、Flask等,所有项目代码完整且可直接运行。不管是零基础还是有经验的开发,相信都能从本专栏获益。有任何问题欢迎私聊博主,专栏持续更新中...

数据知道的博客 5218

模型实战(31)之 yolo26 实现对手部关键点数据集 的训练与关键点检测

模型实战(31)之 yolo26 实现对手部关键点数据集 的训练与关键点检测

yohnyang的博客 210

卷积神经网络CNN/Pytorch,如何理解特征图Feature map?

基础详解,卷积神经网络/Pytorch,如何理解特征图Feature map?

MengYa_Dream的博客 2万+

从养殖场到科技前沿:YOLOv11+OpenCV精准计数鸡蛋与鸡

YOLOv11结合OpenCV技术,精准识别和计数鸡蛋与鸡,广泛应用于养殖场、市场监控和自动化包装。通过深度学习与计算机视觉,提升农业生产效率,让智能化管理更简单高效。

专注于深入研究多种编程语言,以实战为导向,逐步拓展开发技能,提升工程化编码和思维能力,展现无敌技术实力。 1209

pytorch卷积可视化_使用Pytorch可视化卷积神经网络

pytorch卷积可视化Filter and Feature map Image by the author 筛选和特征图作者提供的图像 When dealing with image’s and image data, CNN are the go-to architectures. Convolutional neural networks have proved to provide man...

weixin_26752765的博客 3672

rk3588调试imx415记录

分享适配imx415的软件配置以及一些关键的调试命令

m0_60805802的博客 2892

HAL STM32+EC11编码器实现增减调节及单击、双击、长按功能

HAL STM32+EC11编码器实现增减调节及单击、双击、长按功能

perseverance51博客 4238

pytorch卷积神经网络_使用Pytorch和Matplotlib可视化卷积神经网络的特征

在处理图像和图像数据时,CNN是最常用的架构。卷积神经网络已经被证明在深度学习和计算机视觉领域提供了许多最先进的解决方案。没有CNN,图像识别、目标检测、自动驾驶汽车就不可能实现。但当归结到CNN如何看待和识别他们所做的图像时,事情就变得更加棘手了。· CNN如何判断一张图片是猫还是狗?· 在图像分类问题上,是什么让CNN比其他模型更强大?· 他们在图像中看到了什么?这是我第一次了解CNN时的一些...

weixin_39628256的博客 309

[毕设项目-MCP+ENSP]一句话搞定ENSP自动化:MCP + LLM实战(架构图、工具清单、踩坑全解)

用 MCP + LLM 把“人话”变成对华为 ENSP 的安全自动化操作,三款工具覆盖配置/查询/落盘,配套架构、实战与排坑清单。

逐梦苍穹的博客 2549

卷积神经网络的可视化(二)(可视化卷积神经网络的过滤器)

可视化卷积神经网络的过滤器:有助于精确理解卷积神经网络中每个过滤器容易接受的视觉模式或视觉概念

myDarling_的博客 992

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

可视化卷积神经网络的过滤器_使用Pytorch和Matplotlib可视化卷积神经网络的特征...

在处理图像和图像数据时,CNN是最常用的架构。卷积神经网络已经被证明在深度学习和计算机视觉领域提供了许多最先进的解决方案。没有CNN,图像识别、目标检测、自动驾驶汽车就不可能实现。但当归结到CNN如何看待和识别他们所做的图像时,事情就变得更加棘手了。CNN如何判断一张图片是猫还是狗?在图像分类问题上,是什么让CNN比其他模型更强大?他们在图像中看到了什么?这是我第一次了解CNN时的一些问题。问题会...

weixin_39939303的博客 466

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

可视化卷积神经网络的过滤器_深度学习笔记17_卷积神经网络数据可视化_中间激活...

可视化的概念深度学习模型是“黑盒”,即模型学到的表示很难用人类可以理解的方式来提取和呈现。但是我们现在的学习的卷积伸进网络却可以通过可视化很形象的说明深度学习在卷积神经网络方面可以很表示的,并不是黑盒。目前比较容易理解的三种可视化的方法如下: 可视化卷积神经网络的中间输出(中间激活)就是可以展示网络中各个卷积层和池化层输出的特征图理解卷积神经网络连续的层如何对输入进行变换于初步了解卷积神经网络每个...

weixin_39774044的博客 260

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

教你如何运用可视化理解卷积神经网络(CNNs)的指南

全文共4327字,预计学习时长20分钟或更长 “人类的神经网络是如何运行的?”这个问题让很多数据科学家感到困惑。解释某个简单神经网络的工作机制非常容易,但是当某个计算机视觉项目中的层数增加1000倍时,该怎么办呢? 终端用户想要了解模型是如何得到最终结果时,仅用纸和笔来解释深度神经网络的工作机制是行不通的。那么,如何让神经网络不再像“黑匣子”一样神秘? 可视化可以做到这一点——将神经网络的不同特征可视化能使一切变得清晰明了,也能更直观地呈现卷积神经网络(CNN) 成千上万的图像训练结果。 ...

Will的博客 1008

《Python深度学习》第五章-4(可视化中间激活层)读书笔记

5.4 卷积神经网络的可视化 卷积神经网络学到的表示非常适合可视化,很大程度上是因为它们是视觉概念的表示\color{red}视觉概念的表示视觉概念的表示。接下来介绍3种可视化方法。 可视化卷积神经网络的中间输出(中间激活)\color{red}可视化卷积神经网络的中间输出(中间激活)可视化卷积神经网络的中间输出(中间激活):有助于理解卷积神经网络连续的层如何对输入进行变换,也有助于初步了解卷积神经网络每个过滤器的含义。 可视化卷积神经网络的过滤器\color{red}可视化卷积神经网络的过滤器可视化卷积

Paul_Huang的专栏 1273

《Python 深度学习》刷书笔记 Chapter 5 Part-4 卷积神经网络的可视化(Fillter)

文章目录可视化卷积神经网络2-25 读入模组5-26 观察图像观察卷积层特征提取5-27 建立多输出模型观察输出5-28 显示图像5-29 打印全部的识别图5-32 为过滤器的可视化定义损失张量5-33 获取损失相对于输入的梯度5-34 梯度标准化5-35 给定输入numpy值,得到numpy输出5-36 通过随机梯度下降将让损失最大化5-37 张量转换为有效图像的实用函数5-38 生成过滤器可视化的函数5-39 生成某一层中所有过滤器响应模式组成的网络总结写在最后 可视化卷积神经网络 一直以来,人们.

LeungSr的博客 358
上一篇: 统治世界的 10 大算法,你知道几个?
下一篇: 引用次数在15000次以上的都是什么神仙论文?
机器学习算法那些事
博客等级 码龄9年 1633粉丝 62原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值