• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号
登陆 注册

【caffe-matlab】权重以及特征图的可视化

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

转自 http://blog.csdn.net/zb1165048017/article/details/52643188


前言

移植了各种caffe，是时候进行下一步操作了，先拿可视化下手吧。大部分内容可能跟网上的方法不一样，大家看完我的博客最好去网上看看大牛们的博客，万一被我误导了，就罪过了o(╯□╰)o，开更.............

环境：微软caffe+wind7+matlab2013a

参考：http://caffe.berkeleyvision.org/tutorial/interfaces.html

             http://nbviewer.jupyter.org/github/BVLC/caffe/blob/master/examples/00-classification.ipynb

一、模型读取

读取bvlc_reference_caffenet 的模型结构以及训练好的参数，注意此处的模型结构为deploy，而非train时候的。

[cpp] view plain copy print?
  1. addpath('..') %加入+caffe路径  
  2. caffe.set_mode_cpu();%设置CPU模式  
  3. model = '../../models/bvlc_reference_caffenet/deploy.prototxt';%模型  
  4. weights = '../../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel';%参数  
  5. net=caffe.Net(model,'test');%测试  
  6. net.copy_from(weights); %得到训练好的权重参数  
  7. net %显示net的结构  
然后我们就可以看到模型的结构了：


[cpp] view plain copy print?
  1. net =   
  2.   
  3.   Net with properties:  
  4.   
  5.            layer_vec: [1x24 caffe.Layer]  
  6.             blob_vec: [1x15 caffe.Blob]  
  7.               inputs: {'data'}  
  8.              outputs: {'prob'}  
  9.     name2layer_index: [24x1 containers.Map]  
  10.      name2blob_index: [15x1 containers.Map]  
  11.          layer_names: {24x1 cell}  
  12.           blob_names: {15x1 cell}  
这里额外提一下，net 通过"." 能显示的东西，除了上面输出的这些properties外，还有Net.m中定义的函数
[cpp] view plain copy print?
  1. function self = Net(varargin)  
  2. function layer = layers(self, layer_name)  
  3. function blob = blobs(self, blob_name)  
  4. function blob = params(self, layer_name, blob_index)  
  5. function forward_prefilled(self)  
  6. function backward_prefilled(self)  
  7. function res = forward(self, input_data)  
  8. function res = backward(self, output_diff)  
  9. function copy_from(self, weights_file)  
  10. function reshape(self)  
  11. function save(self, weights_file)  
我们在matlab中进行操作的基础也就是这些函数，当然还有其它的，以后慢慢接触吧。

二、输入数据整理

嗯，还是拿这只猫开刀，这只猫一般藏在E:\CaffeDev\caffe-master\examples\images\cat.jpg，没找到的话直接右键保存下方图片

先说一下过程：

①先把均值读进来

[cpp] view plain copy print?
  1. d = load('../+caffe/imagenet/ilsvrc_2012_mean.mat');  
  2. mean_data = d.mean_data;  
②读取图片
[cpp] view plain copy print?
  1. im = imread('../../examples/images/cat.jpg');%读取图片  
  2. IMAGE_DIM = 256;%图像将要resize的大小，建议resize为图像最小的那个维度  
  3. CROPPED_DIM = 227;%待会需要把一张图片crops成十块，最终softmax求出每一块可能的标签  

设置在输入网络之前需要将图片resize的大小，一般我们会取图片长宽最小的那个，其次需要设置的是输入网络的图片的大小，注意与deploy.prototxt的输入一致，比如
[cpp] view plain copy print?
  1. name: "CaffeNet"  
  2. layer {  
  3.   name: "data"  
  4.   type: "Input"  
  5.   top: "data"  
  6.   input_param { shape: { dim: 10 dim: 3 dim: 227 dim: 227 } }  
  7. }  
这里关注一下input_param，代表一次输入十张图片，每张图片三通道，每张图片大小是227*227。此外注意一下，在opencv中，彩色图像按照BGR存储，而matlab中读取的顺序一般是RGB。所以对这只猫需要进行如下处理：
[cpp] view plain copy print?
  1. im_data = im(:, :, [3, 2, 1]);  %matlab按照RGB读取图片，opencv是BGR，所以需要转换顺序为opencv处理格式  
  2. im_data = permute(im_data, [2, 1, 3]);  % 原始图像m*n*channels,现在permute为n*m*channels大小  
  3. im_data = single(im_data);  % 强制转换数据为single类型  
  4. im_data = imresize(im_data, [IMAGE_DIM IMAGE_DIM], 'bilinear');  % 线性插值resize图像  
注意一下你在训练的train.prototxt中的预处理部分
[cpp] view plain copy print?
  1. transform_param {  
  2.    mirror: true  
  3.    crop_size: 227  
  4.    mean_file: "data/ilsvrc12/imagenet_mean.binaryproto"  
  5.  }  
这里最后一行代表进行了零均值处理，关于这一部分参数，可以看我前面用classification,exe手写识别时候提到的那个博客，介绍了如何看这一部分进行了怎样的预处理。

先零均值化一下，然后按照deploy和train的prototxt，将这只猫crop(分成)十块，采用的是classification.demo的分割方法，分别取猫的上下左右四个角以及中心的大小为deploy中提到的227*227大小。这是五个，然后再对图片翻转180°；合起来就是代表这只猫的十张图片：

[cpp] view plain copy print?
  1. im_data = im_data - mean_data;  % 零均值  
  2. crops_data = zeros(CROPPED_DIM, CROPPED_DIM, 3, 10, 'single');%注意此处是因为prototxt的输入大小为宽*高*通道数*10  
  3. indices = [0 IMAGE_DIM-CROPPED_DIM] + 1;%获得十块每一块大小与原始图像大小差距，便于crops  
  4. %下面就是如何将一张图片crops成十块  
  5. n = 1;  
  6. %此处两个for循环并非是1：indices，而是第一次取indices(1)，然后是indices(2)，每一层循环两次  
  7. %分别读取图片四个角大小为CROPPED_DIM*CROPPED_DIM的图片  
  8. for i = indices  
  9.     for j = indices  
  10.         crops_data(:, :, :, n) = im_data(i:i+CROPPED_DIM-1, j:j+CROPPED_DIM-1, :);%产生四个角的cropdata，1 2 3 4  
  11.         crops_data(:, :, :, n+5) = crops_data(end:-1:1, :, :, n);%翻转180°来一次，产生四个角的翻转cropdata，6 7 8 9  
  12.         n = n + 1;  
  13.     end  
  14. end  
  15. center = floor(indices(2) / 2) + 1;  
  16. %以中心为crop_data左上角顶点，读取CROPPED_DIM*CROPPED_DIM的块  
  17. crops_data(:,:,:,5) = ...  
  18.     im_data(center:center+CROPPED_DIM-1,center:center+CROPPED_DIM-1,:);  
  19. %与for循环里面一样，翻转180°，绕左边界翻转  
  20. crops_data(:,:,:,10) = crops_data(end:-1:1, :, :, 5);  
可视化看看长啥样：
[cpp] view plain copy print?
  1. clear  
  2. clc  
  3. close all  
  4. %caffenet的解读：http://www.2cto.com/kf/201606/515700.html  
  5. %% 设置网络  
  6. addpath('..') %加入+caffe路径  
  7. caffe.set_mode_cpu();%设置CPU模式  
  8. model = '../../models/bvlc_reference_caffenet/deploy.prototxt';%模型  
  9. weights = '../../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel';%参数  
  10. net=caffe.Net(model,'test');%测试  
  11. net.copy_from(weights); %得到训练好的权重参数  
  12. net %显示net的结构  
  13.   
  14. %% 预处理  
  15. d = load('../+caffe/imagenet/ilsvrc_2012_mean.mat');  
  16. mean_data = d.mean_data;%读取均值  
  17. im = imread('../../examples/images/cat.jpg');%读取图片  
  18. IMAGE_DIM = 256;%图像将要resize的大小，建议resize为图像最小的那个维度  
  19. CROPPED_DIM = 227;%最终需要把一张图片crops成十块，最终求出每一块可能的标签  
  20. im_data=im;  
  21. im_data = im(:, :, [3, 2, 1]);  %matlab按照RGB读取图片，opencv是BGR，所以需要转换顺序为opencv处理格式  
  22. im_data = permute(im_data, [2, 1, 3]);  % 原始图像m*n*channels,现在permute为n*m*channels大小  
  23. im_data = single(im_data);  % 强制转换数据为single类型  
  24. im_data = imresize(im_data, [IMAGE_DIM IMAGE_DIM], 'bilinear');  % 线性插值resize图像  
  25. % im_data = im_data - mean_data;  % 零均值  
  26. crops_data = zeros(CROPPED_DIM, CROPPED_DIM, 3, 10, 'single');%注意此处是因为prototxt的输入大小为宽*高*通道数*10  
  27. indices = [0 IMAGE_DIM-CROPPED_DIM] + 1;%获得十块每一块大小与原始图像大小差距，便于crops  
  28. %下面就是如何将一张图片crops成十块  
  29. n = 1;  
  30. %此处两个for循环并非是1：indices，而是第一次取indices(1)，然后是indices(2)，每一层循环两次  
  31. %分别读取图片四个角大小为CROPPED_DIM*CROPPED_DIM的图片  
  32. for i = indices  
  33.     for j = indices  
  34.         crops_data(:, :, :, n) = im_data(i:i+CROPPED_DIM-1, j:j+CROPPED_DIM-1, :);%产生四个角的cropdata，1 2 3 4  
  35.         crops_data(:, :, :, n+5) = crops_data(end:-1:1, :, :, n);%翻转180°来一次，产生四个角的翻转cropdata，6 7 8 9  
  36.         n = n + 1;  
  37.     end  
  38. end  
  39. center = floor(indices(2) / 2) + 1;  
  40. %以中心为crop_data左上角顶点，读取CROPPED_DIM*CROPPED_DIM的块  
  41. crops_data(:,:,:,5) = ...  
  42.     im_data(center:center+CROPPED_DIM-1,center:center+CROPPED_DIM-1,:);  
  43. %与for循环里面一样，翻转180°，绕左边界翻转  
  44. crops_data(:,:,:,10) = crops_data(end:-1:1, :, :, 5);  
  45.   
  46.   
  47. cat_map=zeros(CROPPED_DIM*2,CROPPED_DIM*5,3);%两行五列展示  
  48. cat_num=0;  
  49. for i=0:1  
  50.     for j=0:4  
  51.         cat_num=cat_num+1  
  52.         cat_map(CROPPED_DIM*i+1:(i+1)*CROPPED_DIM,CROPPED_DIM*j+1:(j+1)*CROPPED_DIM,:)=crops_data(:,:,:,cat_num);  
  53.     end  
  54. end  
  55. imshow(uint8(cat_map))  

看着比较怪的原因在于，中间经过了matlab处理方式到opencv处理方式的转变，但是我们依旧用matlab输出了。

三、前向计算

[cpp] view plain copy print?
  1. res=net.forward({crops_data});  
  2. prob=res{1};  
  3. prob1 = mean(prob, 2);  
  4. [~, maxlabel] = max(prob1);  
这一步完毕以后，整个网络就会充满参数了，权重，特征图均生成完毕，接下来可视化它们。

四、特征图可视化

4.1、特征图提取方法

说一下步骤，首先利用net 中的blob_name函数取出与deploy.prototxt对应的 top 名字，显示一下看看

[cpp] view plain copy print?
  1. names=net.blob_names  
  2.   
  3. names =   
  4.   
  5.     'data'  
  6.     'conv1'  
  7.     'pool1'  
  8.     'norm1'  
  9.     'conv2'  
  10.     'pool2'  
  11.     'norm2'  
  12.     'conv3'  
  13.     'conv4'  
  14.     'conv5'  
  15.     'pool5'  
  16.     'fc6'  
  17.     'fc7'  
  18.     'fc8'  
  19.     'prob'  

然后利用blob调用get_data()函数获取我们需要的特征图的值。注意，每一层的特征图是四维，看看前三层的特征图大小：

[cpp] view plain copy print?
  1. size(featuremap{1})=227   227     3    10  
  2. size(featuremap{2})= 55    55    96    10  
  3. size(featuremap{3})=  27    27    96    10  
结合deploy中每一层的卷积核大小以及步长，利用 (当前层特征图大小 - 卷积核大小) / 步长+1=下一层特征图大小，可以推导出每一个featuremap 的前两维，第三个维度代表的是卷积核个数，featuremap {2}到featuremap {3}是池化了。第四个维度代表最开始输入了十张图

4.2 部分可视化方法：

这一部分针对指定的第crop_num张图像在第map_num层进行可视化。注意，这一部分的可视化包含池化层等。

[cpp] view plain copy print?
  1. function [  ] = feature_partvisual( net,mapnum,crop_num )  
  2. names=net.blob_names;  
  3. featuremap=net.blobs(names{mapnum}).get_data();%获取指定层的特征图  
  4. [m_size,n_size,num,crop]=size(featuremap);%获取特征图大小，长*宽*卷积核个数*通道数  
  5. row=ceil(sqrt(num));%行数  
  6. col=row;%列数  
  7. feature_map=zeros(m_size*row,n_size*col);  
  8. cout_map=1;  
  9. for i=0:row-1  
  10.     for j=0:col-1  
  11.         if cout_map<=num  
  12.             feature_map(i*m_size+1:(i+1)*m_size,j*n_size+1:(j+1)*n_size)=(mapminmax(featuremap(:,:,cout_map,crop_num),0,1)*255)';  
  13.             cout_map=cout_map+1;  
  14.         end  
  15.     end  
  16. end  
  17. imshow(uint8(feature_map))  
  18. str=strcat('feature map num:',num2str(cout_map-1));  
  19. title(str)  
  20. end  
调用方法：
[cpp] view plain copy print?
  1. mapnum=1;%第几层的feature☆☆☆☆☆☆☆☆  
  2. crop_num=1;%第几个crop的特征图☆☆☆☆☆☆☆☆  
  3. feature_partvisual( net,mapnum,crop_num )  


中间有个处理细节是归一化然后乘以255，是避免featuremap的数值过小，或者有负数，导致特征图一片漆黑；在下面的权重可视化方法采取的是另一种处理。

读者可以更改"☆"标志的行中的数值去提取不同crop图像的不同层特征图。

第一层特征图：


第二层featuremap：


4.3、全部可视化

这一部分可视化每一张输入图片在指定卷积层的特征图，按照每一行为存储图片的特征图为图例。

[cpp] view plain copy print?
  1. function [  ] = feature_fullvisual( net,mapnum )  
  2. names=net.blob_names;  
  3. featuremap=net.blobs(names{mapnum}).get_data();%获取指定层的特征图  
  4. [m_size,n_size,num,crop]=size(featuremap)%获取特征图大小，长*宽*卷积核个数*图片个数  
  5. row=crop;%行数  
  6. col=num;%列数  
  7. feature_map=zeros(m_size*row,n_size*col);  
  8. for i=0:row-1  
  9.     for j=0:col-1  
  10.         feature_map(i*m_size+1:(i+1)*m_size,j*n_size+1:(j+1)*n_size)=(mapminmax(featuremap(:,:,j+1,i+1),0,1)*255)';  
  11.     end  
  12. end  
  13. figure  
  14. imshow(uint8(feature_map))  
  15. str=strcat('feature map num:',num2str(row*col));  
  16. title(str)  
  17. end  
调用方法
[cpp] view plain copy print?
  1. mapnum=2;%第几层的feature☆☆☆☆☆☆☆☆  
  2. feature_fullvisual( net,mapnum )  
第一层：


第二层：基本看不清楚了，十张输入图片，每一张都有96个特征图，不好显示


五、卷积核可视化

【注】卷积核可视化中，采用的像素放大方法与特征图的不一样。特征图中采用归一化mapminmax到(0,1)范围，然后乘以255,；在下面卷积核的可视化中采用(x-最小值)/最大值*255的方法去放大像素。读者可根据自己喜好决定。

5.1、权重提取方法

先建议读者去看看多通道卷积的概念：http://blog.csdn.net/u014114990/article/details/51125776，不看也行，注意这句话，每一个通道的卷积核是不一样的，同一个卷积核只在同一个特征图中共享，应该理解的没错吧o(╯□╰)o。

通过net 的layer_names 函数能够获取deploy.txt 对应的name 的名称，每一个name的blob对应两个值，分别是权重和偏置，提取方法如下：

【注】貌似仅仅卷积核能够获取到权重，池化层倒是没有权重，全连接部分也是有权重的，但是没什么意义

[cpp] view plain copy print?
  1. layers=net.layer_names;  
  2. convlayer=[];  
  3. for i=1:length(layers)  
  4.     if strcmp(layers{i}(1:3),'con')%仅仅卷积核能获取到权重  
  5.         convlayer=[convlayer;layers{i}];  
  6.     end  
  7. end  
  8. w=cell(1,length(convlayer));%存储权重  
  9. b=cell(1,length(convlayer));%存储偏置  
  10. for i=1:length(convlayer)  
  11.     w{i}=net.layers(convlayer(i,:)).params(1).get_data();  
  12.     b{i}=net.layers(convlayer(i,:)).params(2).get_data();  
  13. end  
提取完毕以后观察一下每一层的权重维度，发现也是四维，显示一下前三个卷积核的维度：
[cpp] view plain copy print?
  1. size(w{1})= 11    11     3    96  
  2. size(w{2})= 5     5    48   256  
  3. size(w{3})= 3     3   256   384  

前两个维度不说了，卷积核的大小，第三个维度代表卷积核的左边，也就是上一层的特征图的个数(对应前面说的每一个通道对应不同卷积核)，第四个维度代表每一个通道对应的卷积核个数(也就是卷积核右边下一层的特征图的个数)。

5.2、部分可视化方法

那么我们可视化也是可选的，需要选择哪一个特征图对应的卷积核，可视化方法如下：

[cpp] view plain copy print?
  1. <pre name="code" class="cpp"><pre name="code" class="cpp">function [  ] = weight_partvisual( net,layer_num ,channels_num )  
  2. layers=net.layer_names;  
  3. convlayer=[];  
  4. for i=1:length(layers)  
  5.     if strcmp(layers{i}(1:3),'con')  
  6.         convlayer=[convlayer;layers{i}];  
  7.     end  
  8. end  
  9. w=net.layers(convlayer(layer_num,:)).params(1).get_data();  
  10. b=net.layers(convlayer(layer_num,:)).params(2).get_data();  
  11. minval=min(min(min(min(w))));  
  12. maxval=max(max(max(max(w))));  
  13. w=(w-minval)/maxval*255;  
  14.   
  15. weight=w(:,:,channels_num,:);%四维，核长*核宽*核左边输入*核右边输出(核个数)  
  16. [kernel_r,kernel_c,input_num,kernel_num]=size(w);  
  17. map_row=ceil(sqrt(kernel_num));%行数  
  18. map_col=map_row;%列数  
  19. weight_map=zeros(kernel_r*map_row,kernel_c*map_col);  
  20. kernelcout_map=1;  
  21. for i=0:map_row-1  
  22.     for j=0:map_col-1  
  23.         if kernelcout_map<=kernel_num  
  24.             weight_map(i*kernel_r+1+i:(i+1)*kernel_r+i,j*kernel_c+1+j:(j+1)*kernel_c+j)=weight(:,:,:,kernelcout_map);  
  25.             kernelcout_map=kernelcout_map+1;  
  26.         end  
  27.     end  
  28. end  
  29. figure  
  30. imshow(uint8(weight_map))  
  31. str1=strcat('weight num:',num2str(kernelcout_map-1));  
  32. title(str1)  
  33.   
  34. end  

调用方法

[cpp] view plain copy print?
  1. layer_num=1;%想看哪一个卷积核对应的权重☆☆☆☆☆☆☆☆☆☆  
  2. channels_num=1;%想看第几个通道对应的卷积核  
  3. weight_partvisual( net,layer_num ,channels_num )  

看看效果：

第一个卷积层的第一个通道对应的卷积核：


第二个卷积层的第一个通道对应的卷积核：


2017.3.4更新日志：

谢谢 TensorSense指出的代码错误，上面说过避免像素值过小的计算方法是通过减去最最小值除以最大值以后乘以255，但是代码却写成了

[cpp] view plain copy print?
  1. w=w-min(min(min(min(w))));  
  2. w=w/max(max(max(max(w))))*255;  
在此做一下更正，应该是
[plain] view plain copy print?
  1. minval=min(min(min(min(w))));  
  2. maxval=max(max(max(max(w))));  
  3. w=(w-minval)/maxval*255;  

当然也可以用全部可视化中提到的MATLAB自带函数mapminmanx函数进行归一化。


5.3、全部可视化

将指定卷积层对应的每一个特征图的全部卷积核画出

[plain] view plain copy print?
  1. function [  ] = weight_fullvisual( net,layer_num  )  
  2. layers=net.layer_names;  
  3. convlayer=[];  
  4. for i=1:length(layers)  
  5.     if strcmp(layers{i}(1:3),'con')  
  6.         convlayer=[convlayer;layers{i}];  
  7.     end  
  8. end  
  9.   
  10. weight=net.layers(convlayer(layer_num,:)).params(1).get_data();%四维，核长*核宽*核左边输入*核右边输出(核个数)  
  11. b=net.layers(convlayer(layer_num,:)).params(2).get_data();  
  12. minval=min(min(min(min(w))));  
  13. maxval=max(max(max(max(w))));  
  14. w=(w-minval)/maxval*255;  
  15.   
  16. [kernel_r,kernel_c,input_num,kernel_num]=size(weight);  
  17. map_row=input_num;%行数  
  18. map_col=kernel_num;%列数  
  19. weight_map=zeros(kernel_r*map_row,kernel_c*map_col);  
  20. for i=0:map_row-1  
  21.     for j=0:map_col-1  
  22.         weight_map(i*kernel_r+1+i:(i+1)*kernel_r+i,j*kernel_c+1+j:(j+1)*kernel_c+j)=weight(:,:,i+1,j+1);  
  23.     end  
  24. end  
  25. figure  
  26. imshow(uint8(weight_map))  
  27. str1=strcat('weight num:',num2str(map_row*map_col));  
  28. title(str1)  
  29.   
  30. end  


第一层：


第二层：


附上所有代码：

主函数

[cpp] view plain copy print?
  1. <pre name="code" class="cpp">clear  
  2. clc  
  3. close all  
  4. %caffenet的解读：http://www.2cto.com/kf/201606/515700.html  
  5. %% 设置网络  
  6. addpath('..') %加入+caffe路径  
  7. caffe.set_mode_cpu();%设置CPU模式  
  8. model = '../../models/bvlc_reference_caffenet/deploy.prototxt';%模型  
  9. weights = '../../models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel';%参数  
  10. net=caffe.Net(model,'test');%测试  
  11. net.copy_from(weights); %得到训练好的权重参数  
  12. net %显示net的结构  
  13.   
  14. %% 预处理  
  15. d = load('../+caffe/imagenet/ilsvrc_2012_mean.mat');  
  16. mean_data = d.mean_data;%读取均值  
  17. im = imread('../../examples/images/cat.jpg');%读取图片  
  18. IMAGE_DIM = 256;%图像将要resize的大小，建议resize为图像最小的那个维度  
  19. CROPPED_DIM = 227;%最终需要把一张图片crops成十块，最终求出每一块可能的标签  
  20. im_data=im;  
  21. im_data = im(:, :, [3, 2, 1]);  %matlab按照RGB读取图片，opencv是BGR，所以需要转换顺序为opencv处理格式  
  22. im_data = permute(im_data, [2, 1, 3]);  % 原始图像m*n*channels,现在permute为n*m*channels大小  
  23. im_data = single(im_data);  % 强制转换数据为single类型  
  24. im_data = imresize(im_data, [IMAGE_DIM IMAGE_DIM], 'bilinear');  % 线性插值resize图像  
  25. % im_data = im_data - mean_data;  % 零均值  
  26. crops_data = zeros(CROPPED_DIM, CROPPED_DIM, 3, 10, 'single');%注意此处是因为prototxt的输入大小为宽*高*通道数*10  
  27. indices = [0 IMAGE_DIM-CROPPED_DIM] + 1;%获得十块每一块大小与原始图像大小差距，便于crops  
  28. %下面就是如何将一张图片crops成十块  
  29. n = 1;  
  30. %此处两个for循环并非是1：indices，而是第一次取indices(1)，然后是indices(2)，每一层循环两次  
  31. %分别读取图片四个角大小为CROPPED_DIM*CROPPED_DIM的图片  
  32. for i = indices  
  33.     for j = indices  
  34.         crops_data(:, :, :, n) = im_data(i:i+CROPPED_DIM-1, j:j+CROPPED_DIM-1, :);%产生四个角的cropdata，1 2 3 4  
  35.         crops_data(:, :, :, n+5) = crops_data(end:-1:1, :, :, n);%翻转180°来一次，产生四个角的翻转cropdata，6 7 8 9  
  36.         n = n + 1;  
  37.     end  
  38. end  
  39. center = floor(indices(2) / 2) + 1;  
  40. %以中心为crop_data左上角顶点，读取CROPPED_DIM*CROPPED_DIM的块  
  41. crops_data(:,:,:,5) = ...  
  42.     im_data(center:center+CROPPED_DIM-1,center:center+CROPPED_DIM-1,:);  
  43. %与for循环里面一样，翻转180°，绕左边界翻转  
  44. crops_data(:,:,:,10) = crops_data(end:-1:1, :, :, 5);  
  45.   
  46. %% 展示被crop的图需要im_data = im_data - mean_data注释  
  47. cat_map=zeros(CROPPED_DIM*2,CROPPED_DIM*5,3);%两行五列展示  
  48. cat_num=0;  
  49. for i=0:1  
  50.     for j=0:4  
  51.         cat_num=cat_num+1  
  52.         cat_map(CROPPED_DIM*i+1:(i+1)*CROPPED_DIM,CROPPED_DIM*j+1:(j+1)*CROPPED_DIM,:)=crops_data(:,:,:,cat_num);  
  53.     end  
  54. end  
  55. figure  
  56. imshow(uint8(cat_map))  
  57. %% 前向计算  
  58. res=net.forward({crops_data});  
  59. prob=res{1};  
  60. prob1 = mean(prob, 2);  
  61. [~, maxlabel] = max(prob1);  
  62. %% 观察网络结构,获取特征图  
  63. %注意blob_names和layer_names的区别  
  64. %获取特征图，特征图就是prototxt的每一层top名字  
  65. mapnum=2;%第几层的feature☆☆☆☆☆☆☆☆  
  66. crop_num=1;%第几个crop的特征图☆☆☆☆☆☆☆☆  
  67. feature_partvisual( net,mapnum,crop_num )  
  68. feature_fullvisual( net,mapnum )  
  69.   
  70. %% 观察网络结构,获取权重  
  71. %看多通道卷积解释http://blog.csdn.net/u014114990/article/details/51125776  
  72. %中间group过一次，96分两两group变成48，第56行  
  73. %获取权重，每一层的layer_names存储了权重和偏置，第一个参数是权重，第二个参数是偏置  
  74. layer_num=2;%想看哪一层的权重☆☆☆☆☆☆☆☆☆☆  
  75. channels_num=1;%想看第几个通道对应的卷积核  
  76. weight_partvisual( net,layer_num ,channels_num )  
  77. weight_fullvisual( net,layer_num  )  

部分特征图可视化：
[cpp] view plain copy print?
  1. function [  ] = feature_partvisual( net,mapnum,crop_num )  
  2. names=net.blob_names;  
  3. featuremap=net.blobs(names{mapnum}).get_data();%获取指定层的特征图  
  4. [m_size,n_size,num,crop]=size(featuremap);%获取特征图大小，长*宽*卷积核个数*通道数  
  5. row=ceil(sqrt(num));%行数  
  6. col=row;%列数  
  7. feature_map=zeros(m_size*row,n_size*col);  
  8. cout_map=1;  
  9. for i=0:row-1  
  10.     for j=0:col-1  
  11.         if cout_map<=num  
  12.             feature_map(i*m_size+1:(i+1)*m_size,j*n_size+1:(j+1)*n_size)=(mapminmax(featuremap(:,:,cout_map,crop_num),0,1)*255)';  
  13.             cout_map=cout_map+1;  
  14.         end  
  15.     end  
  16. end  
  17. figure;imshow(uint8(feature_map))  
  18. str=strcat('feature map num:',num2str(cout_map-1));  
  19. title(str)  
  20. end  
全部特征图可视化：
[cpp] view plain copy print?
  1. function [  ] = feature_fullvisual( net,mapnum )  
  2. names=net.blob_names;  
  3. featuremap=net.blobs(names{mapnum}).get_data();%获取指定层的特征图  
  4. [m_size,n_size,num,crop]=size(featuremap)%获取特征图大小，长*宽*卷积核个数*图片个数  
  5. row=crop;%行数  
  6. col=num;%列数  
  7. feature_map=zeros(m_size*row,n_size*col);  
  8. for i=0:row-1  
  9.     for j=0:col-1  
  10.         feature_map(i*m_size+1:(i+1)*m_size,j*n_size+1:(j+1)*n_size)=(mapminmax(featuremap(:,:,j+1,i+1),0,1)*255)';  
  11.     end  
  12. end  
  13. figure  
  14. imshow(uint8(feature_map))  
  15. str=strcat('feature map num:',num2str(row*col));  
  16. title(str)  
  17. end  
部分卷积核可视化：
[cpp] view plain copy print?
  1. function [  ] = weight_visual( net,layer_num ,channels_num )  
  2. layers=net.layer_names;  
  3. convlayer=[];  
  4. for i=1:length(layers)  
  5.     if strcmp(layers{i}(1:3),'con')  
  6.         convlayer=[convlayer;layers{i}];  
  7.     end  
  8. end  
  9. w=net.layers(convlayer(layer_num,:)).params(1).get_data();  
  10. b=net.layers(convlayer(layer_num,:)).params(2).get_data();  
  11. minval=min(min(min(min(w))));  
  12. maxval=max(max(max(max(w))));  
  13. w=(w-minval)/maxval*255;  
  14. [kernel_r,kernel_c,input_num,kernel_num]=size(w);  
  15. map_row=ceil(sqrt(kernel_num));%行数  
  16. map_col=map_row;%列数  
  17. weight_map=zeros(kernel_r*map_row,kernel_c*map_col);  
  18. kernelcout_map=1;  
  19. for i=0:map_row-1  
  20.     for j=0:map_col-1  
  21.         if kernelcout_map<=kernel_num  
  22.             weight_map(i*kernel_r+1+i:(i+1)*kernel_r+i,j*kernel_c+1+j:(j+1)*kernel_c+j)=weight(:,:,:,kernelcout_map);  
  23.             kernelcout_map=kernelcout_map+1;  
  24.         end  
  25.     end  
  26. end  
  27. figure  
  28. imshow(uint8(weight_map))  
  29. str1=strcat('weight num:',num2str(kernelcout_map-1));  
  30. title(str1)  
  31.   
  32. end  
全部卷积核可视化：
[plain] view plain copy print?
  1. function [  ] = weight_fullvisual( net,layer_num  )  
  2. layers=net.layer_names;  
  3. convlayer=[];  
  4. for i=1:length(layers)  
  5.     if strcmp(layers{i}(1:3),'con')  
  6.         convlayer=[convlayer;layers{i}];  
  7.     end  
  8. end  
  9.   
  10. weight=net.layers(convlayer(layer_num,:)).params(1).get_data();%四维，核长*核宽*核左边输入*核右边输出(核个数)  
  11. b=net.layers(convlayer(layer_num,:)).params(2).get_data();  
  12. minval=min(min(min(min(weight))));  
  13. maxval=max(max(max(max(weight))));  
  14. weight=(weight-minval)/maxval*255;  
  15.   
  16. [kernel_r,kernel_c,input_num,kernel_num]=size(weight);  
  17. map_row=input_num;%行数  
  18. map_col=kernel_num;%列数  
  19. weight_map=zeros(kernel_r*map_row,kernel_c*map_col);  
  20. for i=0:map_row-1  
  21.     for j=0:map_col-1  
  22.         weight_map(i*kernel_r+1+i:(i+1)*kernel_r+i,j*kernel_c+1+j:(j+1)*kernel_c+j)=weight(:,:,i+1,j+1);  
  23.     end  
  24. end  
  25. figure  
  26. imshow(uint8(weight_map))  
  27. str1=strcat('weight num:',num2str(map_row*map_col));  
  28. title(str1)  
  29.   
  30. end  


六、全连接探讨

这里初步探索一下CaffeNet 的最后一个池化层pool5到第一个全连接层fc6的连接，我最开始的理解是直接把pool层所有的单元拉成一个列向量，不过分析以后，感觉应该是类似BP，pool5先被拉成一个一维向量，然后利用权重连接到fc6层的所有单元上，类似二部图的连接方法。

实验过程如下：

①首先提取出pool5的特征图大小

[plain] view plain copy print?
  1. K>> A=net.blobs('pool5').get_data();  
  2. K>> size(A)  
  3.   
  4. ans =  
  5.   
  6.      6     6   256    10  

可以发现对于每一个输入图片(总共十张)都有256个6*6大小的特征图。预先计算一下256*6*6=9216

②然后提取出fc6的特征图大小
[plain] view plain copy print?
  1. K>> B=net.blobs('fc6').get_data();  
  2. K>> size(B)  
  3.   
  4. ans =  
  5.   
  6.         4096          10  
然后发现pool5到fc6的连接并不是简单的拉成一维向量，而是利用了一个9216*4096的权重去将pool5的特征映射到fc6的单元中

③验证一下是否如所想的映射方法， 只需要看看pool5到fc6的权重大小即可

[plain] view plain copy print?
  1. K>> C=net.layers('fc6').params(1).get_data();  
  2. K>> size(C)  
  3.   
  4. ans =  
  5.   
  6.         9216        4096  
发现果

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
2016 最流行的周末编程语言排行，Rust 夺冠！发布时间：2022-07-18
下一篇：
rust 高级话题发布时间：2022-07-18
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap