一、配置檔案

1. 網路結構

henet_car_train_test.prototxt

#name: "LeNet"
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TRAIN
  }
  transform_param {
    scale: 0.00390625
  }
  data_param {
    source: "/home/datasets/carPlate/train_test_labels/train_10"
    batch_size: 64
 

    backend: LMDB
  }
}
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TEST
  }
  transform_param {
    scale: 0.00390625
  }
  data_param {
    source: "/home/datasets/carPlate/train_test_labels/val_G5"
    batch_size: 100
    backend: LMDB  
    }
}
layer {
  name: "conv1"
 

  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  convolution_param {
    num_output: 32
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool1"
 

  type: "Pooling"
  bottom: "conv1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "group0_block0_conv0"
  type: "Convolution"
  bottom: "pool1"
  top: "group0_block0_conv0"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  convolution_param {
    num_output: 32
    pad: 1
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "msra"
    }
  }
}
layer {
  name: "group0_block0_conv0_bn"
  type: "BatchNorm"
  bottom: "group0_block0_conv0"
  top: "group0_block0_conv0"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}
layer {
  name: "group0_block0_conv0_scale"
  type: "Scale"
  bottom: "group0_block0_conv0"
  top: "group0_block0_conv0"
  scale_param {
    bias_term: true
  }
}
layer {
  name: "group0_block0_conv0_relu"
  type: "ReLU"
  bottom: "group0_block0_conv0"
  top: "group0_block0_conv0"
}
layer {
  name: "group0_block0_conv1"
  type: "Convolution"
  bottom: "group0_block0_conv0"
  top: "group0_block0_conv1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  convolution_param {
    num_output: 32
    pad: 1
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "msra"
    }
  }
}
layer {
  name: "group0_block0_conv1_bn"
  type: "BatchNorm"
  bottom: "group0_block0_conv1"
  top: "group0_block0_conv1"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}
layer {
  name: "group0_block0_conv1_scale"
  type: "Scale"
  bottom: "group0_block0_conv1"
  top: "group0_block0_conv1"
  scale_param {
    bias_term: true
  }
}



layer {
  name: "group1_block0_conv0"
  type: "Convolution"
  bottom: "group0_block0_conv1"
  top: "group1_block0_conv0"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  convolution_param {
    num_output: 32
    pad: 1
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "msra"
    }
  }
}
layer {
  name: "group1_block0_conv0_bn"
  type: "BatchNorm"
  bottom: "group1_block0_conv0"
  top: "group1_block0_conv0"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}
layer {
  name: "group1_block0_conv0_scale"
  type: "Scale"
  bottom: "group1_block0_conv0"
  top: "group1_block0_conv0"
  scale_param {
    bias_term: true
  }
}
layer {
  name: "group1_block0_conv0_relu"
  type: "ReLU"
  bottom: "group1_block0_conv0"
  top: "group1_block0_conv0"
}
layer {
  name: "group1_block0_conv1"
  type: "Convolution"
  bottom: "group1_block0_conv0"
  top: "group1_block0_conv1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  convolution_param {
    num_output: 32
    pad: 1
    kernel_size: 3
    stride: 1
    weight_filler {
      type: "msra"
    }
  }
}
layer {
  name: "group1_block0_conv1_bn"
  type: "BatchNorm"
  bottom: "group1_block0_conv1"
  top: "group1_block0_conv1"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}
layer {
  name: "group1_block0_conv1_scale"
  type: "Scale"
  bottom: "group1_block0_conv1"
  top: "group1_block0_conv1"
  scale_param {
    bias_term: true
  }
}
layer {
  name: "group1_block0_sum"
  type: "Eltwise"
  bottom: "group0_block0_conv1"
  bottom: "group1_block0_conv1"
  top: "group1_block0_sum"
  eltwise_param {
    operation: SUM
  }
}
layer {
  name: "group0_block0_sum"
  type: "Eltwise"
  bottom: "group1_block0_sum"
  bottom: "pool1"
  top: "group0_block0_sum"
  eltwise_param {
    operation: SUM
  }
}




layer {
  name: "conv2"
  type: "Convolution"
  bottom: "group0_block0_sum"
  top: "conv2"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  convolution_param {
    num_output: 50
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "ip1"
  type: "InnerProduct"
  bottom: "pool2"
  top: "ip1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "ip1"
  top: "ip1"
}
layer {
  name: "ip2"
  type: "InnerProduct"
  bottom: "ip1"
  top: "ip2"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "accuracy"
  type: "Accuracy"
  bottom: "ip2"
  bottom: "label"
  top: "accuracy"
  include {
    phase: TEST
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "ip2"
  bottom: "lab`}}}}}}}}
``
l"
  top: "loss"
}
_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "accuracy"
  type: "Accuracy"
  bottom: "ip2"
  bottom: "label"
  top: "accuracy"
  include {
    phase: TEST
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "ip2"
  bottom: "label"
  top: "loss"
}

2. 超引數

lenet_solver.prototxt

# The train/test net protocol buffer definition
net:  "henet_car_train_test.prototxt"
# test_iter specifies how many forward passes the test should carry out.
# In the case of MNIST, we have test batch size 100 and 100 test iterations,
# covering the full 10,000 testing images.
test_iter: 100
# Carry out testing every 500 training iterations.
test_interval: 500
# The base learning rate, momentum and the weight decay of the network.
base_lr: 0.001
momentum: 0.9
weight_decay: 0.0005
# The learning rate policy
lr_policy: "inv"
gamma: 0.0001
power: 0.75
# Display every 100 iterations
display: 100
# The maximum number of iterations
max_iter: 10000
# snapshot intermediate results
snapshot: 5000
snapshot_prefix: "/home/datasets/carPlate/train_test_labels/train_10/train_10"  #前一個train_10是制定路徑，最後一個表示模型檔案的字首
# solver mode: CPU or 
GPU
solver_mode: GPU

二、開始訓練

1. 訓練並輸出日誌

1. 無預訓練
/opt/caffe/build/tools/caffe train \
--solver=/home/datasets/carPlate/train_test_labels/henet_solver.prototxt 2>&1 | tee /home/datasets/carPlate/train_test_labels/train_10/train_10_henet_Res2order.log
2. 載入預訓練模型
/opt/caffe/build/tools/caffe train \
--solver=/home/datasets/carPlate/train_test_labels/henet_solver.prototxt \
--weights=/home/datasets/carPlate/train_test_labels/train_10/train_10_iter_45000.caffemodel \
2>&1 | tee /home/datasets/carPlate/train_test_labels/train_30/train_30_henet_Res2order.log
3. 

2. 輸出數值資訊

/opt/caffe/tools/extra/parse_log.py \
/home/datasets/carPlate/train_test_labels/train_10/train_10_henet_Res2order.log \#前一個步驟儲存的日誌檔案
/home/datasets/carPlate/train_test_labels/train_10/ \#數值資訊的儲存路徑
#生成henet_Res2order.log.test 和henet_Res2order.log.train兩個檔案

3. 繪製loss&accuracy曲線

4.測試資料

/opt/caffe/build/tools/caffe test \
--model=/home/datasets/carPlate/train_test_labels/henet_car_train_test.prototxt \
--weights=/home/datasets/carPlate/train_test_labels/train_30/train_30_iter_45000.caffemodel \
2>&1 | tee /home/datasets/carPlate/train_test_labels/train_30/test_30_henet_Res2order.log

5. 失敗記錄

a. 第一次：從頭開始訓練

1. 網路結構：caffe自帶```lenet_car_train_test.prototx```
2. 超引數:上面的```lenet_solver.prototxt```
3. 訓練資料：train_100 (100%的訓練資料），總的資料說明參見前文。
4. 測試結果：train_100_lenet_iter_10000.caffemodel
5. 測試分析：G4可能因為黃牌比例較大，所以效果較差；single_2是白色車牌，效果較差；其餘效果也未達到99%

b. 第二次：單獨訓練白色和黃色車牌

1. 網路結構：train_batch_size:128->64
2. 超引數：base_lr: 0.001->0.001，weight_decay: 0.0005->0.0005
3. 預訓練模型：train_100_lenet_iter_10000.caffemodel 
4. 訓練資料：train_100_yellow_white
5. 測試結果：白牌和黃牌效果確實提升了，但是藍牌和非車牌很差了，應該是迭代次數過多。

c. 第三次：單獨訓練白色和黃色車牌

1. 網路結構：train_batch_size:128->64, 2個conv層的學習率設為0，ip3學習率縮小100倍：0.01，0.02，
2. 超引數：base_lr: 0.001->0.001，weight_decay: 0.0005->0.0005
3. 預訓練模型：train_100_lenet_iter_10000.caffemodel （從第一次開始）
4. 訓練資料：train_100_yellow_white
5. 測試結果：4類別單獨測試效果都上了90%，尤其是白色從56.0606%提升到97.192%，但藍色略有下降，懷疑主要是由於藍色和非車牌的誤判導致G4效果不理想

c. 第四次：單獨訓練藍色車牌

1. 網路結構：train_batch_size:128->64, 2個conv層的學習率設為0，ip3學習率縮小100倍：0.01，0.02，
2. 超引數：base_lr: 0.001->0.001，weight_decay: 0.0005->0.0005
3. 預訓練模型：train_100_lenet_iter_10000.caffemodel （從第一次開始）
4. 訓練資料：train_100_blue_non500
5. 測試結果：白牌和黃牌效果確實提升了，但是藍牌和非車牌很差了，應該是迭代次數過多。

結論：媽的資料集做錯了，一定不能有資料夾為空！！！！！

6. Lenet重新訓練

常用vim命令：

替換：
:%s/abc/def/g

1. 原始Lenet訓練

1. 網路結構：train_batch_size=64
2. 超引數：base_lr: 0.0001，weight_decay: 0.0005->0.0005
3. 預訓練模型：從零開始
4. 訓練資料：train_100_all
5. 測試結果：這裡只分為2類，每50000次進行重新訓練(使用snapshot引數)。

# The train/test net protocol buffer definition
net: "lenet_train_test.prototxt"
# test_iter specifies how many forward passes the test should carry out.
# In the case of MNIST, we have test batch size 100 and 100 test iterations,
# covering the full 10,000 testing images.
test_iter: 100
# Carry out testing every 500 training iterations.
test_interval: 500
# The base learning rate, momentum and the weight decay of the network.
base_lr: 0.0001
momentum: 0.9
weight_decay: 0.0005
# The learning rate policy
lr_policy: "inv"
gamma: 0.0001
power: 0.75
# Display every 100 iterations
display: 100
# The maximum number of iterations
max_iter: 50000
# snapshot intermediate results
snapshot: 5000
snapshot_prefix: "/home/datasets/carPlate/train_test_2_class/train_100/train_100_lenet"
# solver mode: CPU or GPU
solver_mode: GPU

2. Lenet全連線層的裁剪

第一次

1. 網路結構：train_batch_size=64，修改ip1_400 ->ip1_400，對應的num_oputput 500 ->400， 
2. 超引數：base_lr: 0.0001，weight_decay: 0.0005->0.0005, max_iter:50000
3. 預訓練模型：train_100_lenet_iter_200000.caffemodel（前一個小節得到的模型）
4. 訓練資料：train_100_all
5. 測試結果：這裡只分為2類，每50000次進行重新訓練(使用snapshot引數)。越往後訓練，對負樣本的準確率越高，模型大小：1.05Mb

第二次

1. 網路結構：train_batch_size=64，修改ip1_400 ->ip1_200，對應的num_oputput 400 ->200， 
2. 超引數：base_lr: 0.0001，weight_decay: 0.0005->0.0005, max_iter:100000
3. 預訓練模型：train_100_lenet_iter_200000.caffemodel（前一個小節得到的模型）
4. 訓練資料：train_100_all
5. 測試結果：這裡只分為2類，每50000次進行重新訓練(使用snapshot引數)。越往後訓練，對負樣本的準確率越高，模型大小349k

第三次

1. 網路結構：train_batch_size=64，修改ip1_200 ->ip1_50，對應的num_oputput 200 ->50， 
2. 超引數：base_lr: 0.0001，weight_decay: 0.0005->0.0005, max_iter:100000
3. 預訓練模型：train_100_lenet_iter_200000.caffemodel（前一個小節得到的模型）
4. 訓練資料：train_100_all
5. 測試結果：這裡只分為2類。模型大小152k

第四次

1. 網路結構：train_batch_size=64，修改ip1_50 ->ip1_10，對應的num_oputput 50 ->10， 
2. 超引數：base_lr: 0.0001，weight_decay: 0.0005->0.0005, max_iter:100000
3. 預訓練模型：train_100_lenet_iter_200000.caffemodel（前一個小節得到的模型）
4. 訓練資料：train_100_all
5. 測試結果：這裡只分為2類。模型大小126k

第五次

1. 網路結構：train_batch_size=64，修改ip1_10 ->ip1_4，對應的num_oputput 10 ->4， 
2. 超引數：base_lr: 0.0001，weight_decay: 0.0005->0.0005, max_iter:100000
3. 預訓練模型：train_100_lenet_iter_200000.caffemodel（前一個小節得到的模型）
4. 訓練資料：train_100_all
5. 測試結果：這裡只分為2類。模型大小116k

第五次

1. 網路結構：train_batch_size=64，修改ip1_4 ->ip1_2，對應的num_oputput 4 ->2，去掉最後一層全連線層 
2. 超引數：base_lr: 0.0001，weight_decay: 0.0005->0.0005, max_iter:100000
3. 預訓練模型：train_100_lenet_iter_200000.caffemodel（前一個小節得到的模型）
4. 訓練資料：train_100_all
5. 測試結果：至少需要兩個全連線層。

3. Lenet卷積層的裁剪

name: "LeNet"
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TRAIN
  }
  transform_param {
    scale: 0.00390625
  }
  data_param {
    source: "train_100_all"
    batch_size: 64
    backend: LMDB
  }
}
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TEST
  }
  transform_param {
    scale: 0.00390625
  }
  data_param {
    source: "val_G1"
    batch_size:1 
    backend: LMDB
  }
}
layer {
  name: "conv3"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
   
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
caffe訓練自己的資料集——2. 開始訓練
     
 
							
							
							一、配置檔案



1. 網路結構

henet_car_train_test.prototxt



#name: "LeNet"
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "lab 

  
 

    

    
    
Fast RCNN 訓練自己資料集 (2修改資料讀取介面)
     
 Fast RCNN訓練自己的資料集 （2修改讀寫介面）


這裡樓主講解了如何修改Fast RCNN訓練自己的資料集，首先請確保你已經安裝好了Fast RCNN的環境，具體的編配編制操作請參考我的上一篇文章。首先可以看到fast rcnn的工程目錄下有個Lib目錄
這裡下面存在3個目錄分別是：

datase 

  
 

    

    
    
windows10+GPU下caffe資料集Lmdb格式製作+訓練自己資料集
     
 
                
最近做人臉識別專案，想用到caffe訓練自己的資料，電腦作業系統為win10+GPU,這裡對caffe-windows配置、資料集製作、訓練資料都做一些介紹。（無GPU配置的看我這個部落格）。如果你用的是vs2015，那麼下面介紹的caffe不適合，要用BVLC
 wind 

  
 

    

    
    
如何利用caffe訓練自己資料集
     
  
 
 這篇博文主要參考了另一位博主https://blog.csdn.net/hellohaibo，在此向他表示感謝
 首先，博主今天的caffe崩了，毫無徵兆的崩了，具體表現為博主想做一個更大的資料集，但是在生成lmbd檔案時永遠生成的是一個沒有名字的資料夾，可是博主已經在指定的example目錄裡寫了 

  
 

    

    
    
使用pytorch版faster-rcnn訓練自己資料集
     
  
  
  
 
 
  使用pytorch版faster-rcnn訓練自己資料集
  
   
    引言
    faster-rcnn pytorch程式碼下載
    訓練自己資料集
    接下來工作
    參考文獻
   
  
 
  
 引言 
 最近在復現目標檢測程式碼（師兄強烈推薦F 

  
 

    

    
    
《錯誤手記-01》 facenet使用預訓練模型fine-tune重新訓練自己資料集報錯
     
  
 
 環境資訊：windows10+python3.5+tensorflow1.6.0 
 問題描述： 
 在自己的訓練集上跑train_softmax.py.  
 引數： 
 --logs_base_dir F:/work/runspace/log/  --models_base_ 

  
 

    

    
    
Kaldi中thchs30訓練自己資料集的步驟
     
  
  
  
 一、資料準備過程  網上下載的thchs-openslr資料集需要換成自己的資料集，包含兩個資料夾：data_thchs30和resource。下面講解如何搞定這一部分。  資料集在data_thchs30檔案中，包含四個部分（data、train、dev、test）。  data資料夾中包 

  
 

    

    
    
yolov3訓練自己資料集可參考文章
     
  
  
  
  
   參考部落格原址：
  https://blog.csdn.net/u012966194/article/details/80004647
   
   
    
    
   這篇文章將介紹編譯darknet框架開始，到整理資料集，到用yolo網路實現一個內部資料集中號碼簿的定 

  
 

    

    
    
Yolov3訓練自己資料集+資料分析
     
 
                訓練自己到資料集已經在上一篇文中說明過了，這一篇著重記錄一下資料分析過程

資料分析

1. mAP值計算

1)訓練完成後，執行darknet官方程式碼中到 detector valid 命令，生成對測試集到檢測結果，命令如下：

./darknet detector va 

  
 

    

    
    
【YOLO初探】之 keras-yolov3訓練自己資料集
     
  
 
 寫在前面 
 如何使用官方資料集參看上一篇文章《【YOLO初探】之 使用官方資料集做目標分類》 
 傳送門：https://blog.csdn.net/plSong_CSDN/article/details/85108256 
 這裡，筆者使用了260張訓練資料，完成了人臉中“眼睛”、“鼻子”、“嘴 

  
 

    

    
    
Fast RCNN  訓練自己資料集 (1編譯配置)
     
 FastRCNN 訓練自己資料集 (1編譯配置)


FastRCNN是Ross Girshick在RCNN的基礎上增加了Multi task training整個的訓練過程和測試過程比RCNN快了許多。別的一些細節不展開，過幾天會上傳Fast RCNN的論文筆記。FastRCNN mAP效能上略有上升。Fa 

  
 

    

    
    
YOLOv3在訓練自己資料集時的速度慢問題
     
 
                YOLOv3以速度快著稱，但是在訓練自己的資料集時發現儘管在命令中同時開啟了多塊gpu，但速度仍舊很慢。按照其他人的訓練日誌可以看出64batch的單gpu訓練，每次迭代大約需要不到1秒但是自己在訓練時卻需要好幾個小時，首先想到的是自己的資料集是否圖片解析度太高，比較之後發現 

  
 

    

    
    
FCN訓練自己資料集（person-segmentation）、SIFT-FLOW、SBD和VOC實驗總結
     
  
 
 最近花了將近一週的時間，基於提供的原始碼，通過參考網上的部落格，跑通了FCN在三個資料集上的訓練以及測試。在這裡寫下總結，即是記錄，又希望能夠對其他剛剛接觸FCN的人有所幫助。 
 FCN的原始碼地址：https://github.com/shelhamer/fcn.berkeleyvision.o 

  
 

    

    
    
Faster-RCNN 訓練自己資料集的坑記錄
     
 
                
主要照這篇部落格進行訓練配置，因為沒有GPU所以好多坑，CPU訓練可以參見這篇部落格
正所謂，跑通了的都一樣，錯誤千萬樣。按照教程來也是坑多
訓練：

 python train_faster_rcnn_alt_opt.py  --net_name ZF --weights 

  
 

    

    
    
FastRCNN 訓練自己資料集（二）——修改讀寫介面
     
 
                這裡樓主講解了如何修改Fast RCNN訓練自己的資料集，首先請確保你已經安裝好了Fast RCNN的環境，具體的編配編制操作請參考我的上一篇文章。首先可以看到fast rcnn的工程目錄下有個Lib目錄這裡下面存在3個目錄分別是：datasetsfast_rcnnroi_d 

  
 

    

    
    
FastRCNN 訓練自己資料集（一）——編譯配置
     
 



FastRCNN是Ross Girshick在RCNN的基礎上增加了Multi task training整個的訓練過程和測試過程比RCNN快了許多。別的一些細節不展開，過幾天會上傳Fast
 RCNN的論文筆記。FastRCNN mAP效能上略有上升。Fast RCNN中，提取OP的過程和訓練過程仍 

  
 

    

    
    
py-faster-rcnn訓練自己資料集需要修改的引數
     
 
								
								            
						
                

faster rcnn預設有三種網路模型ZF（小）、VGG_CNN_M_1024（中）、VGG16
 （大）


訓練圖片大小為500*500，類別數1。

修改VGG_CNN_M_1024模型配置 

  
 

    

    
    
YOLO訓練自己資料集配置檔案修改.md
     
 VOC2016 最早1093張personVOC2017 劉堯792張personVOC2018 恩德792張person_handVOC2019 person_head_hand(hand/hand1) 但是可以不生成hand1的labelVOC2020 person_head_hand size=224* 

  
 

    

    
    
yolo v2 訓練自己資料集遇到的問題
     
 
                
1.CUDA Error: out of memory darknet:
 ./src/cuda.c:36: check_error: Assertio `0' failed.

需要修改所使用的模型cfg檔案中的subdivision的引數。
由subdivisions= 

  
 

    

    
    
Yolo V2訓練自己資料集
     
 
                在參照了很多其他的部落格，成功訓練了自己的資料集，這裡記錄一下防止忘記便於以後總結學習。

VOC資料集準備

準備資料

首先準備好自己的資料集，最好固定格式，此處以VOC為例，採用jpg格式的影象，在名字上最好使用像VOC一樣類似I000001.jpg、I000002.j