Skip to main content
 首页 » 编程设计

python之为什么我的 CNN 总是返回相同的结果

2025年02月15日9exmyth

我正在尝试构建一个将对象分为 3 个主要类别的 CNN。这三个对象包括兰博基尼、汽缸盖和一架飞机。我的数据集由 6580 张图像组成,每个类别几乎有 2200 张图像。您可以在谷歌驱动器上查看我的数据集 dataset . 我的 CNN 的架构是 AlexNet ,但我已经将完全连接的第 8 层的输出从 1000 修改为 3。 我已经使用这些设置进行训练

test_iter:1000 
test_interval:1000 
base_lr:0.001 
lr_policy:"step" 
gamma:0.1 
stepsize:2500 
max_iter:40000 
momentum:0.9 
weight_decay:0.0005 

但是,问题是当我在训练后部署我的模型时,结果总是如下 {'prob': array([[ 0.33333334, 0.33333334, 0.33333334]], dtype=float32)} .

下面的代码是我加载模型并输出概率向量的脚本。

import numpy as np 
import matplotlib.pyplot as plt 
import sys 
import caffe 
import cv2 
 
MODEL_FILE ='deploy_ex0.prototxt' 
PRETRAINED='snapshot_ex0_1_model_iter_40000.caffemodel' 
 
caffe.set_mode_cpu() 
net = caffe.Net(MODEL_FILE, PRETRAINED, caffe.TEST) 
 
#preprocessing  
 
transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape}) 
 
#mean substraction  
 
mean_file = np.array([104,117,123])  
transformer.set_mean('data', mean_file) 
 
transformer.set_transpose('data', (2,0,1)) 
transformer.set_channel_swap('data', (2,1,0)) 
transformer.set_raw_scale('data', 255.0) 
 
#batch size  
net.blobs['data'].reshape(1,3,227,227) 
 
#load image in data layer  
 
im=cv2.imread('test.jpg', cv2.IMREAD_COLOR) 
img =cv2.resize(im, (227,227)) 
 
net.blobs['data'].data[...] = transformer.preprocess('data', img) 
 
#compute  
 
out=net.forward() 
 
print out 

我想知道为什么我有这样的结果?你能帮我调试我的 CNN 吗?

此外,经过训练我得到了这些结果

I0421 06:56:12.285953  2224 solver.cpp:317] Iteration 40000, loss = 5.06557e-05 
I0421 06:56:12.286027  2224 solver.cpp:337] Iteration 40000, Testing net (#0) 
I0421 06:58:32.159469  2224 solver.cpp:404]     Test net output #0: accuracy = 0.99898 
I0421 06:58:32.159626  2224 solver.cpp:404]     Test net output #1: loss = 0.00183688 (* 1 = 0.00183688 loss) 
I0421 06:58:32.159643  2224 solver.cpp:322] Optimization Done. 
I0421 06:58:32.159654  2224 caffe.cpp:222] Optimization Done. 

谢谢

5 月 11 日回答后编辑:

我使用了一个简单的模型 1 conv , 1 reul , 1 pool 和 2 fully connected layers.. 下面的代码是架构规范:

name:"CNN" 
layer { 
  name: "convnet" 
  type: "Data" 
  top: "data" 
  top: "label" 
  include { 
    phase: TRAIN 
  } 
  transform_param { 
    mirror:true 
    crop_size:227 
    mean_value:87.6231 
    mean_value:87.6757 
 
    mean_value:87.1677 
    #mean_file:"/home/jaba/caffe/data/diota_model/mean.binaryproto" 
  } 
  data_param { 
    source: "/home/jaba/caffe/data/diota_model/train_lmdb" 
    batch_size: 32 
    backend: LMDB 
  } 
} 
 
layer { 
  name: "convnet" 
  type: "Data" 
  top: "data" 
  top: "label" 
  include { 
    phase: TEST 
  } 
  transform_param { 
    mirror:true 
    crop_size:227 
    mean_value:87.6231 
    mean_value:87.6757 
 
    mean_value:87.1677 
    #mean_file:"/home/jaba/caffe/data/diota_model/mean.binaryproto" 
  } 
  data_param { 
    source: "/home/jaba/caffe/data/diota_model/val_lmdb" 
    batch_size: 20 
    backend: LMDB 
  } 
} 
 
layer { 
  name: "conv1" 
  type: "Convolution" 
  bottom: "data" 
  top: "conv1" 
  param { 
    lr_mult: 1 
  } 
  param { 
    lr_mult: 2 
  } 
  convolution_param { 
    num_output: 20 
    kernel_size: 5 
    stride: 1 
    weight_filler { 
      type: "xavier" 
    } 
    bias_filler { 
      type: "constant" 
    } 
  } 
} 
 
layer { 
  name: "relu1" 
  type: "ReLU" 
  bottom: "conv1" 
  top: "conv1" 
} 
 
layer { 
  name: "pool1" 
  type: "Pooling" 
  bottom: "conv1" 
  top: "pool1" 
  pooling_param { 
    pool: MAX 
    kernel_size: 3 
    stride: 2 
  } 
} 
 
layer { 
  name: "ip1" 
  type: "InnerProduct" 
  bottom: "pool1" 
  top: "ip1" 
  param { 
    lr_mult: 1 
  } 
  param { 
    lr_mult: 2 
  } 
  inner_product_param { 
    num_output: 300 
    weight_filler { 
      type: "xavier" 
    } 
    bias_filler { 
      type: "constant" 
    } 
  } 
} 
 
layer  
{ 
   name:"ip2" 
   type:"InnerProduct" 
   bottom:"ip1" 
   top:"ip2" 
   param 
   { 
    lr_mult:1 
   } 
   param 
   { 
    lr_mult:2 
   } 
   inner_product_param  
   { 
    num_output: 3 
        weight_filler { 
          type: "xavier" 
        } 
        bias_filler { 
          type: "constant" 
        } 
   } 
 
} 
layer { 
  name: "accuracy" 
  type: "Accuracy" 
  bottom: "ip1" 
  bottom: "label" 
  top: "accuracy" 
  include { 
    phase: TEST 
  } 
} 
 
layer { 
  name: "loss" 
  type: "SoftmaxWithLoss" 
  bottom: "ip1" 
  bottom: "label" 
  top: "loss" 
} 

我对这个 CNN 进行了 22 个 epoch 的训练,准确率达到了 86%。对于我使用的求解器参数:

net: "/home/jaba/caffe/data/diota_model/simple_model/train_val.prototxt" 
test_iter: 50 
test_interval: 100 
base_lr: 0.00001 
momentum: 0.9 
weight_decay: 0.0005 
lr_policy: "inv" 
gamma: 0.0001 
power: 0.75 
display: 100 
max_iter: 3500 
snapshot: 100 
snapshot_prefix: "/home/jaba/caffe/data/diota_model/simple_model/snap_shot_model" 
solver_mode: GPU 

现在,当我部署模型时,它不会返回相同的概率向量。但是,有一个问题,当我加载模型并在 validation_lmdb 文件夹中对其进行测试时,我没有得到相同的准确度值,我得到了将近 56%。

我使用下面的脚本来计算准确度:

import os 
import glob 
#import cv2 
import caffe 
import lmdb 
import numpy as np 
from caffe.proto import caffe_pb2 
 
MODEL_FILE ='deploy.prototxt' 
PRETRAINED='snap_shot_model_iter_3500.caffemodel' 
 
caffe.set_mode_cpu() 
#load_model 
 
net = caffe.Net(MODEL_FILE, PRETRAINED, caffe.TEST) 
 
#load input and configure preprocessing 
 
 
 
#mean_file = np.array([104,117,123]) 
 
transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape}) 
#transformer.set_mean('data', mean_file) 
transformer.set_transpose('data', (2,0,1)) 
transformer.set_channel_swap('data', (2,1,0)) 
transformer.set_raw_scale('data', 255.0) 
 
 
#fixing the batch size 
 
net.blobs['data'].reshape(1,3,227,227) 
 
lmdb_env=lmdb.open('/home/jaba/caffe/data/diota_model/val1_lmdb') 
 
lmdb_txn=lmdb_env.begin() 
 
lmdb_cursor=lmdb_txn.cursor() 
 
datum=caffe_pb2.Datum() 
 
 
correct_predictions=0 
 
for key,value in lmdb_cursor: 
 
    datum.ParseFromString(value) 
 
    label=datum.label 
    data=caffe.io.datum_to_array(datum) 
 
    image=np.transpose(data,(1,2,0)) 
 
 
    net.blobs['data'].data[...]=transformer.preprocess('data',image) 
 
    out=net.forward() 
    out_put=out['prob'].argmax() 
    if label==out_put: 
    correct_predictions=correct_predictions+1 
 
 
 
print 'accuracy :' 
print correct_predictions/1002.0 

我改变了数据集的大小1002用于测试,4998用于学习。 你能给我一些解决问题的建议吗?

谢谢!

请您参考如下方法:

我想我看到了两个截然不同的问题,不同形式的过拟合。 6580 张图像中有 85% 用于训练,其中 5593 张用于训练,987 张用于测试。

一个

40000 次迭代 *(256 张图像/迭代)*(1 个纪元/5593 张图像)~= 1831 个纪元。 在 ILSVRC 数据集(1.28M 图像)上,AlexNet 仅训练 40-50 个时期(取决于横向扩展)。 您的模型最终损失为 0,并且在整个测试集中只有 1 张照片出错。

两个

AlexNet 的宽度(每层过滤器)针对 ILSVRC 数据集的 1000 个类和无数特征进行了调整。你还没有为你的数据缩小它。第 5 层扩展到 4096 个过滤器:几乎每个图像一个。 ILSVRC 训练 Alexnet 识别诸如猫脸、轮式车辆的一侧等特征的地方——你的模型将训练以从前方 30 度角、高于水平面 8 度、有草的角度识别深蓝色兰博基尼在背景中,在驾驶员侧的背景中是一棵白杨树。

换句话说,您经过训练的 AlexNet 可以像浇注塑料外壳一样适合训练数据集。除了初始数据集,它不会适合任何。

令我略感惊讶的是,它在其他汽车、其他气缸盖和飞机零件上的表现并没有好一点。但是,我已经看到足够多的过拟合模型具有有效的随机输出。


首先,减少训练时长。其次,尝试减少每一层的 num_output 大小。


5 月 11 日在 OP 发表评论后编辑

是的,你必须减少每一层中的内核/过滤器/输出的数量。第 5 层尤其具有 4K 滤镜,这意味着网络可以为数据集中的每张照片分配近 1 个滤镜。这不会带来有效的学习:您拥有 1000 多个过滤器,而不是使用少量过滤器来学习垫圈的特征,每个过滤器都学习特定垫圈照片的一个非常具体的特征。

AlexNet、GoogleNet、ResNet、VGG 等都是针对静态图像在各种对象上的一般辨别问题而构建和调整的。您当然可以使用一般概念,但它们不是适用于更小且定义更明确的问题的好拓扑。