2. 程式人生 > >caffe + win10基於CaffeNet網路框架訓練自己的圖片進行分類（實踐篇）

caffe + win10基於CaffeNet網路框架訓練自己的圖片進行分類（實踐篇）

阿新 • • 發佈：2019-01-31

  接觸caffe一段時間了 ，一直沒有自己完整的跑過自己的資料，現在使用在win10系統上配置好的caffe環境，使用caffeNet網路框架，對自己準備的圖片資料集進行訓練，並使用生成的模型對圖片進行類別預測。接觸時間比較短，有的地方理解不到位，現在整理下我處理的流程以及過程之中遇到過的問題，希望可以與大家互享經驗，不足之處請大家多多指教。
  在caffe目錄examples下新建my_classify資料夾，其餘檔案均在該目錄下；

一、製作資料集

1、準備圖片
  使用Corel資料集中的400圖片，4類每類選取100張，其中90張作為訓練集，10張作為測試集。所以訓練集train中有360張圖片，測試集test中有40張圖片,分別存放在train與test資料夾中。

這裡寫圖片描述

2、生成帶標籤的列表list.txt
  分別在train與test檔案中生成list.txt列表，切記標籤要從0開始。我使用python指令碼分別對每個類別影象生成標籤 ，然後和在一起的。（方法有點笨，附上基本的生成列表的程式碼，可以寫個迴圈，直接生成train的list.txt的） 
import os
def generate(dir,label):
    files = os.listdir(dir)
    files.sort()
    print '****************'
    print 'input :',dir
    print 'start...'
 

    listText = open(dir+'\\'+'list.txt','w')
    for file in files:
        fileType = os.path.split(file)
        if fileType[1] == '.txt':
            continue        
        name = file + ' ' + str(int(label)) +'\n'
        listText.write(name)
    listText.close()
    print 'down!'
    print '****************'
 
    

if __name__ == '__main__':  
    generate('D:\\caffe\\caffe-master\\examples\\my_classify\\Test',1)

生成的list.txt

這裡寫圖片描述

注：如果label標記不從0開始，可能會導致 label_value < num_labels 問題：

這裡寫圖片描述

3、生成lmdb格式資料集，並生成二進位制imagemean.binaryproto的均值檔案(size 256 256)
採用windows批處理格式的檔案.bat,檔名為：convert_and_computeMean.bat 
D:\caffe\caffe-master\Build\x64\Debug\convert_imageset.exe --resize_height=256 --resize_width=256 --shuffle --backend="lmdb" train/ train/list.txt trainlmdb
D:\caffe\caffe-master\Build\x64\Debug\convert_imageset.exe --resize_height=256 --resize_width=256 --shuffle --backend="lmdb" test/ test/list.txt testlmdb
D:\caffe\caffe-master\Build\x64\Debug\compute_image_mean.exe trainlmdb image_mean.binaryproto
pause

執行結果：

這裡寫圖片描述

生成trainlmdb、testlmdb和image_mean.binaryproto三個檔案

注：如果資料集有改動，要將原來生成的trainlmdb和testlmdb刪除，否則會造成如下問題：

這裡寫圖片描述

至此資料集製作部分完成。

二、新建網路模型train_val.prototxt和solver.prototxt兩個檔案

這裡直接使用caffeNet的網路架構模型
需要做如下更改：
1、訓練集與測試集的路徑，直接改成了絕對路徑；
2、batch_size改成了4，crop_size改成了與圖片一般大小的256；
3、最後一層的num_output設定成4，因為只有4類。

name: "CaffeNet"
layer {
  name: "data"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TRAIN
  }
  transform_param {
    mirror: true
    crop_size: 256
    mean_file: "D:/caffe/caffe-master/examples/my_classify/image_mean.binaryproto"
  }
  data_param {
    source: "D:/caffe/caffe-master/examples/my_classify/trainlmdb"
    batch_size: 4
    backend: LMDB
  }
}
layer {
  name: "data"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TEST
  }
  transform_param {
    mirror: false
    crop_size: 256
    mean_file: "D:/caffe/caffe-master/examples/my_classify/image_mean.binaryproto"
  }
  data_param {
    source: "D:/caffe/caffe-master/examples/my_classify/testlmdb"
    batch_size: 4
    backend: LMDB
  }
}
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 96
    kernel_size: 11
    stride: 4
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
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: "norm1"
  type: "LRN"
  bottom: "pool1"
  top: "norm1"
  lrn_param {
    local_size: 5
    alpha: 0.0001
    beta: 0.75
  }
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "norm1"
  top: "conv2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 256
    pad: 2
    kernel_size: 5
    group: 2
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 1
    }
  }
}
layer {
  name: "relu2"
  type: "ReLU"
  bottom: "conv2"
  top: "conv2"
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "norm2"
  type: "LRN"
  bottom: "pool2"
  top: "norm2"
  lrn_param {
    local_size: 5
    alpha: 0.0001
    beta: 0.75
  }
}
layer {
  name: "conv3"
  type: "Convolution"
  bottom: "norm2"
  top: "conv3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 384
    pad: 1
    kernel_size: 3
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "relu3"
  type: "ReLU"
  bottom: "conv3"
  top: "conv3"
}
layer {
  name: "conv4"
  type: "Convolution"
  bottom: "conv3"
  top: "conv4"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 384
    pad: 1
    kernel_size: 3
    group: 2
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 1
    }
  }
}
layer {
  name: "relu4"
  type: "ReLU"
  bottom: "conv4"
  top: "conv4"
}
layer {
  name: "conv5"
  type: "Convolution"
  bottom: "conv4"
  top: "conv5"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 256
    pad: 1
    kernel_size: 3
    group: 2
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 1
    }
  }
}
layer {
  name: "relu5"
  type: "ReLU"
  bottom: "conv5"
  top: "conv5"
}
layer {
  name: "pool5"
  type: "Pooling"
  bottom: "conv5"
  top: "pool5"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "fc6"
  type: "InnerProduct"
  bottom: "pool5"
  top: "fc6"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 1
    }
  }
}
layer {
  name: "relu6"
  type: "ReLU"
  bottom: "fc6"
  top: "fc6"
}
layer {
  name: "drop6"
  type: "Dropout"
  bottom: "fc6"
  top: "fc6"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 1
    }
  }
}
layer {
  name: "relu7"
  type: "ReLU"
  bottom: "fc7"
  top: "fc7"
}
layer {
  name: "drop7"
  type: "Dropout"
  bottom: "fc7"
  top: "fc7"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc8"
  type: "InnerProduct"
  bottom: "fc7"
  top: "fc8"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "accuracy"
  type: "Accuracy"
  bottom: "fc8"
  bottom: "label"
  top: "accuracy"
  include {
    phase: TEST
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "fc8"
  bottom: "label"
  top: "loss"
}

solver.prototxt檔案

net: "D:/caffe/caffe-master/examples/my_classify/train_val.prototxt"
test_iter: 2
test_interval: 50
base_lr: 0.001
lr_policy: "step"
gamma: 0.1
stepsize: 100
display: 20
max_iter: 500
momentum: 0.9
weight_decay: 0.005
solver_mode: GPU
snapshot: 200
snapshot_prefix: "D:/caffe/caffe-master/examples/my_classify/train"

至此網路搭建部分結束，接下來可以開始訓練

三、訓練

新建train.bat檔案

caffe.exe train --solver=solver.prototxt --gpu=all
pause

訓練結果，其中accuracy=0.625挺低的，首先訓練集不夠多，其次迭代次數較少

這裡寫圖片描述

訓練結束會生成xxx.caffemodel和xxx.solverstate分別儲存訓練過程的引數和中段的引數資訊

四、利用生成的模型使用python介面測試自己的資料

1、通過指令碼將image_mean.binaryproto轉換成python可以識別的mean.npy檔案

import caffe
import numpy as np

MEAN_PROTO_PATH = 'image_mean.binaryproto'            
MEAN_NPY_PATH = 'mean.npy'                        

blob = caffe.proto.caffe_pb2.BlobProto()        
data = open(MEAN_PROTO_PATH, 'rb' ).read()         
blob.ParseFromString(data)                      

array = np.array(caffe.io.blobproto_to_array(blob))
mean_npy = array[0]                            
np.save(MEAN_NPY_PATH ,mean_npy)

2、編寫與train_val.prototxt對應的deploy.prototxt用於測試的網路模型

name: "CaffeNet"
layer {
  name: "data"
  type: "Input"
  top: "data"
  input_param { shape: { dim: 10 dim: 3 dim: 256 dim: 256 } }
}
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  convolution_param {
    num_output: 96
    kernel_size: 11
    stride: 4
  }
}
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: "norm1"
  type: "LRN"
  bottom: "pool1"
  top: "norm1"
  lrn_param {
    local_size: 5
    alpha: 0.0001
    beta: 0.75
  }
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "norm1"
  top: "conv2"
  convolution_param {
    num_output: 256
    pad: 2
    kernel_size: 5
    group: 2
  }
}
layer {
  name: "relu2"
  type: "ReLU"
  bottom: "conv2"
  top: "conv2"
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "norm2"
  type: "LRN"
  bottom: "pool2"
  top: "norm2"
  lrn_param {
    local_size: 5
    alpha: 0.0001
    beta: 0.75
  }
}
layer {
  name: "conv3"
  type: "Convolution"
  bottom: "norm2"
  top: "conv3"
  convolution_param {
    num_output: 384
    pad: 1
    kernel_size: 3
  }
}
layer {
  name: "relu3"
  type: "ReLU"
  bottom: "conv3"
  top: "conv3"
}
layer {
  name: "conv4"
  type: "Convolution"
  bottom: "conv3"
  top: "conv4"
  convolution_param {
    num_output: 384
    pad: 1
    kernel_size: 3
    group: 2
  }
}
layer {
  name: "relu4"
  type: "ReLU"
  bottom: "conv4"
  top: "conv4"
}
layer {
  name: "conv5"
  type: "Convolution"
  bottom: "conv4"
  top: "conv5"
  convolution_param {
    num_output: 256
    pad: 1
    kernel_size: 3
    group: 2
  }
}
layer {
  name: "relu5"
  type: "ReLU"
  bottom: "conv5"
  top: "conv5"
}
layer {
  name: "pool5"
  type: "Pooling"
  bottom: "conv5"
  top: "pool5"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "fc6"
  type: "InnerProduct"
  bottom: "pool5"
  top: "fc6"
  inner_product_param {
    num_output: 4096
  }
}
layer {
  name: "relu6"
  type: "ReLU"
  bottom: "fc6"
  top: "fc6"
}
layer {
  name: "drop6"
  type: "Dropout"
  bottom: "fc6"
  top: "fc6"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc7"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7"
  inner_product_param {
    num_output: 4096
  }
}
layer {
  name: "relu7"
  type: "ReLU"
  bottom: "fc7"
  top: "fc7"
}
layer {
  name: "drop7"
  type: "Dropout"
  bottom: "fc7"
  top: "fc7"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc8"
  type: "InnerProduct"
  bottom: "fc7"
  top: "fc8"
  inner_product_param {
    num_output: 4
  }
}
layer {
  name: "prob"
  type: "Softmax"
  bottom: "fc8"
  top: "prob"
}

3、編寫python介面

import caffe
import numpy as np 

root = 'D:/caffe/caffe-master/examples/my_classify/'
#設定測試網路
deploy = root + 'deploy.prototxt'
#新增訓練的網路權重引數
caffe_model = root + 'train_iter_500.caffemodel'
#測試圖片
img = root + '4.jpg'
#標籤檔案
label_file = root + 'label.txt'
#均值檔案
mean_file = root + 'mean.npy'
#設定使用GPU
caffe.set_model_gpu()
#構造一個net
net = caffe.Net(deploy,caffe_model,caffe.TEST)
# 得到data的形狀，這裡的圖片是預設matplotlib底層載入的
transformer = caffe.io.Transformer({'data':net.blobs['data'].data.shape})
# matplotlib載入的image是畫素[0-1],圖片的資料格式[weight,high,channels]，RGB
# caffe載入的圖片需要的是[0-255]畫素，資料格式[channels,weight,high],BGR，那麼就需要轉換
transformer.set_transpose('data', (2,0,1))
transformer.set_mean('data', np.load(mean_file).mean(1).mean(1))
# 圖片畫素放大到[0-255]
transformer.set_raw_scale('data', 255)
# RGB-->BGR 轉換
transformer.set_channel_swap('data', (2,1,0))
#設定輸入的圖片shape，1張，3通道，長寬都是256
net.blobs['data'].reshape(1,3,256,256)
#載入圖片
im = caffe.io.load_image(img)
net.blobs['data'].data[...] = transformer.preprocess('data', im)
#輸出每層網路的name和shape
for layer_name,blob in net.blobs.iteritems():
    print layer_name + '\t' + str(blob.data.shape)
#網路向前傳播
out = net.forward()
labels = np.loadtxt(label_file,str,delimiter = '\t')
prob = net.blobs['prob'].data[0].flatten()

print prob
order = prob.argsort()[-1]
#輸出類別
print 'the class is:',labels[order]

測試圖片為：這裡寫圖片描述
分類結果為：這裡寫圖片描述

相關推薦

caffe + win10基於CaffeNet網路框架訓練自己的圖片進行分類（實踐篇）

  接觸caffe一段時間了 ，一直沒有自己完整的跑過自己的資料，現在使用在win10系統上配置好的caffe環境，使用caffeNet網路框架，對自己準備的圖片資料集進行訓練，並使用生成的模型對圖片進行類別預測。接觸時間比較短，有的地方理解不到位，現在整理下我

Fast MaskRCNN 框架訓練時的各種坑（三）

根據上篇文章中的各種坑填平之後，可以跑訓練了，但是又又又又出現了錯誤。 明明是有GPU，但是顯示send device incarnation=1,這個值就不對了。 然後查了網上說是tensorflow 版本太高，降到1.1 由於之前的坑，所以anaconda裝了python2.7

使用tensorflow訓練自己的資料集（一）——製作資料集

使用tensorflow訓練自己的資料集—製作資料集 想記錄一下自己製作訓練集並訓練的過、希望踩過的坑能幫助後面入坑的人。 本次使用的訓練集的是kaggle中經典的貓狗大戰資料集（提取碼：ufz5）。因為本人筆記本配置很差還不是N卡所以把train的資料分成了訓練集和測試集並沒有使用

使用tensorflow訓練自己的資料集（四）——計算模型準確率

使用tensorflow訓練自己的資料集—定義反向傳播 上一篇使用tensorflow訓練自己的資料集（三）中製作已經介紹了定義反向傳播過程來訓練神經網路，訓練完神經網路後應對神經網路進行準確率的計算。 import time import forward import back

TensorFlow-cifar訓練與測試（可對自己資料進行分類和測試）

第一部分：測試軟硬體 硬體：NVIDIA-GTX1080 軟體：Windows7、python3.6.5、tensorflow-gpu-1.4.0 第二部分：資料下載 資料集下載連結 第三部分：程式碼分步展示 第一步：匯入tensorflow import os fr

使用tensorflow訓練自己的資料集（一）

使用tensorflow訓練自己的資料集 想記錄一下自己製作訓練集並訓練的過、希望踩過的坑能幫助後面入坑的人。 本次使用的訓練集的是kaggle中經典的貓狗大戰資料集（提取碼：ufz5）。因為本人筆記本配置很差還不是N卡所以把train的資料分成了訓練集和測試集

使用tensorflow訓練自己的資料集（二）

使用tensorflow訓練自己的資料集—定義神經網路 上一篇使用tensorflow訓練自己的資料集（一）中製作已經介紹了製作自己的資料集、接下來就是定義向前傳播過程了也就是定義神經網路。本次使用了兩層卷積兩層最大池化兩層全連線神經網路最後加softmax層的

使用tensorflow訓練自己的資料集（三）——定義反向傳播過程

使用tensorflow訓練自己的資料集—定義反向傳播 上一篇使用tensorflow訓練自己的資料集（二）中製作已經介紹了定義神經網路、接下來就是定義反向傳播過程進行訓練神經網路了。反向傳播過程中使用了滑動平均類和學習率指數下降來優化神經網路。 ps.沒有GP

Tensorflow 訓練自己的資料集（二）（TFRecord）

Tensorflow 提供了一種統一的格式來儲存資料，這個格式就是TFRecord,上一篇部落格中所提到的方法當資料的來源更復雜，每個樣例中的資訊更豐富的時候就很難有效的記錄輸入資料中的資訊了，於是Tensorflow提供了TFRecord來統一儲存資料，接下來

Tensorflow + ResNet101 + fasterRcnn 訓練自己的模型 資料（一）

一、資料準備： 1、PASCAL VOC資料集格式 2、資料擴充：做了旋轉【0， 90，180，270】（備註：這裡可以不做那麼多許旋轉，fasterrcnn在訓練的時候要做圖片的映象變換）、降取樣 降取樣： import os import cv2 import nu

用已有的模型來訓練自己的資料集（finetune）

1.首先準備自己的資料集，這次的資料集和上篇部落格中自己訓練的資料集是一樣的，按照上次的步驟，生成train_lmdb,val_lmdb和均值檔案 2.下載已有的模型這裡用的是caffenet模型，下載bvlc_reference_caffenet.caffemodel以及

Android網路框架：OKHttp原始碼簡單解析（一）

這是第一次解析原始碼並把它寫出來，在之前，我一直以為只要會用別人的輪子就好，做出實際的效果就行，對看原始碼對自己的能力提升不以為然。後來偶然聽到一句話：看別人的DEMO，你就可以會用輪子，但是要想用好輪子，還是得看原始碼。我覺得看原始碼有兩個方面的好處： 1

Android:Okhttp+Retrofit+Rx+RxLificycler+Fragmenation框架搭建自己的技術堆疊（一）

            自己獨立開發一個新專案。從技術選型到框架構建，再到具體的程式碼編輯，單元測試，全部由一個人負責。（說白了，就是把你扔那裡，看你能弄出什麼么蛾子）。特此，在這裡記錄自己的開發過程。        在沒看到產品需求和設計之前，自己先確定大概的專案框架和技術

TensorFlow——訓練自己的資料——CIFAR10（一）資料準備

Reading Data 所用函式 def read_cifar10(data_dir, is_train, batch_size, shuffle):` Args: data_dir: the directory of CI

Tensorflow 訓練自己的資料集（一）（資料直接匯入到記憶體）

製作自己的訓練集 下圖是我們資料的存放格式，在data目錄下有驗證集與測試集分別對應iris_test， iris_train 為了向偉大的MNIST致敬，我們採用的資料名稱格式和MNIST類似 classification_index.jpg

使用SSD基於caffe框架訓練自己的資料

宣告：本文僅以自己的實驗過程編寫，如若轉載，請與博主聯絡。建議讀者在做本文中的嘗試之前，先訓練一編官網論文中的例子，按照SSD教程跑一邊，或者參看博主博文：http://blog.csdn.net/xunan003/article/details/78427446    配

阿里雲免費GPU+caffe框架下訓練自己圖片

      阿里雲的參考文件：https://help.aliyun.com/document_detail/49571.html       在文件裡提供了caffe的一個案例，利用Caffe實現mnist的資料訓練。準備的資料來源可以在“深度學習案例程式碼及資料下載”頁

用SSD框架訓練自己的資料集

一份非常簡單易懂的SSD tensorflow訓練教程，初學者也可以看得懂。當初自學的時候走了很多彎路，所以把自己的經驗和踩過的坑分享給大家，如果文中有什麼寫的不對的地方歡迎大家在評論區和我討論。 https://blog.csdn.net/Echo_Harring

MaskRCNN-Benchmark框架訓練自己的資料集

          Facebook AI Research 開源了 Faster R-CNN 和 Mask R-CNN 的 PyTorch 1.0 實現基準：MaskRCNN-Benchmark。相比 Detectron 和 mmdetecti

SSD框架訓練自己的資料集

from __future__ import print_function import caffe from caffe.model_libs import * from google.protobuf import text_format import math import os i