Caffe学习笔记（一）: 训练和测试自己的数据集

最新推荐文章于 2024-04-22 11:01:14 发布
原创 最新推荐文章于 2024-04-22 11:01:14 发布 · 1.2k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Python #caffe #训练数据集 #计算机视觉

本文详细介绍使用Caffe框架进行图像分类的过程，包括数据准备、模型训练及测试等关键步骤，并解决过程中遇到的具体问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1 数据准备
首先在caffe根目录下建立一个文件夹myfile，用于存放数据文件和后面的caffe模型相关文件。
然后在myfile文件夹下建立build_lmdb和datatest两个文件夹，其中build_lmdb文件夹用于存放生成的lmdb文件，datatest文件夹存放图片数据。
在datatest下主要有2个文件夹和2个.sh文件和2个.txt文件，其中train文件夹中存放待训练的图片，val文件夹中存放待测试的图片，creatlabel.py是分别用来生成train和val的.py文件，train.txt和val.txt是生成的标签文件。
建立好文件夹后，我们把分割好的图片放到train和val文件夹里面 

首先生成label
# -*- coding: utf-8 -*-
import csv
import os
import numpy as np
def IsSubString(SubStrList,Str):
    '''''
    #判断字符串Str是否包含序列SubStrList中的每一个子字符串
    #>>>SubStrList=['F','EMS','txt']
    #>>>Str='F06925EMS91.txt'
    #>>>IsSubString(SubStrList,Str)#return True (or False)
    '''
    flag=True
    for substr in SubStrList:
        if not(substr in Str):
            flag=False
    return flag
#~ #----------------------------------------------------------------------
def GetFileList(FindPath,FlagStr=[]):
    FileList=[]
    FileNames=os.listdir(FindPath)
    if (len(FileNames)>0):
        for fn in FileNames:
            if (len(FlagStr)>0):
                #返回指定类型的文件名
                if (IsSubString(FlagStr,fn)):
                    fullfilename=os.path.join(FindPath,fn)
                    FileList.append(fullfilename)
            else:
                #默认直接返回所有文件名
                fullfilename=os.path.join(FindPath,fn)
                FileList.append(fullfilename)
        #对文件名排序
    if (len(FileList)>0):
         FileList.sort()
    return FileList
if __name__=="__main__":
    FileNameList=GetFileList("/home/user/swscode/datatest/train/",[])
    print FileNameList
# fileObject = open('val.txt', 'w')
data = np.array([FileNameList, ])
labellist = []
for ip in FileNameList:
    print ip
    # fileObject.write(ip)
    # fileObject.write('\n')
    iq=ip.split('/')[-1].split("_")[0]
    iq = int(iq)
    iq = iq-2
    iq=str(iq)
    labellist.append(iq)
with open('train.csv', 'w') as f:
    print "test"
    writer = csv.writer(f, delimiter='\t')
    writer.writerows(zip(FileNameList,labellist))
# fileObject.close()

2 生成train.txt val.txt

数据按8:2比例分配到train和val文件夹
遇到的问题：输出比例错误
解决方案：用字典计数。每一类label按比例分离，而不是整体按比例分离。
遇到的问题：两列label之间多了tab导致找不到文件
解决方案：:%s/\t/ /g 全局替换
# -*- coding: utf-8 -*-
import shutil
import csv
s =0
diriq = {}
# with open('text.csv', 'r') as f:
Filenamelist =[]
labellist=[]
import csv
with open('text.csv') as csvfile:
     readCSV = csv.reader(csvfile, delimiter=',')
     for row in readCSV:
         print row
         print row[0].split()
         Filenamelist.append(row[0].split()[0])
         labellist.append(row[0].split()[1])
         # print row[1]
    # a1 = [row for row in DictReader(f)]
    # print "--->", type(a1)
    # print len(a1)
    # a2 = [row["2"] for row in DictReader(f)]
for a  in labellist :
    if a in diriq:
        diriq[a]+=1
    else:
        diriq[a]=1
count ={}
for file, idname in zip(Filenamelist,labellist):
    if count.has_key(idname):
        if count[idname] < diriq[idname]*0.8:
            print file
            count[idname]+=1
            shutil.copy(file,'/home/user/swscode/datatest/train/')
        else:
            shutil.copy(file,'/home/user/swscode/datatest/val/')
    else:
        count[idname]=1
        shutil.copy(file,'/home/user/swscode/datatest/train/')

3 生成lmdb数据

将图片文件转换成caffe框架中能直接使用的db文件。
遇到的问题：数据路径TRAIN_DATA_ROOT写的绝对路径，导致路径重叠，以至找不到文件
解决方案：路径改为当前路径TRAIN_DATA_ROOT="/"
# Create the imagenet lmdb inputs
# N.B. set the path to the imagenet train + val data dirs
TOOLS=/home/user/swfcode/caffe/build/tools/
EXAMPLE=/home/user/swscode/build_lmdb/
DATA=/home/user/swscode/datatest/


TRAIN_DATA_ROOT="/"
VAL_DATA_ROOT="/"

# Set RESIZE=true to resize the images to 256x256. Leave as false if images have
# already been resized using another tool.
RESIZE=true
if $RESIZE; then
  RESIZE_HEIGHT=256
  RESIZE_WIDTH=256
else
  RESIZE_HEIGHT=0
  RESIZE_WIDTH=0
fi

# if [ ! -d "$TRAIN_DATA_ROOT" ]; then
  # echo "Error: TRAIN_DATA_ROOT is not a path to a directory: $TRAIN_DATA_ROOT"
  # echo "Set the TRAIN_DATA_ROOT variable in create_imagenet.sh to the path" \
       # "where the ImageNet training data is stored."
  # exit 1
# fi

# if [ ! -d "$VAL_DATA_ROOT" ]; then
  # echo "Error: VAL_DATA_ROOT is not a path to a directory: $VAL_DATA_ROOT"
  # echo "Set the VAL_DATA_ROOT variable in create_imagenet.sh to the path" \
       # "where the ImageNet validation data is stored."
  # exit 1
# fi

echo "Creating train lmdb..."

    # --backend="leveldb"\
GLOG_logtostderr=1 $TOOLS/convert_imageset \
    --resize_height=$RESIZE_HEIGHT \
    --resize_width=$RESIZE_WIDTH \
    --shuffle \
    $TRAIN_DATA_ROOT \
    ./train.txt \
    $EXAMPLE/"patch"${1}"_train_lmdb"

echo "Creating val lmdb..."

    # --backend="leveldb"\
GLOG_logtostderr=1 $TOOLS/convert_imageset \
    --resize_height=$RESIZE_HEIGHT \
    --resize_width=$RESIZE_WIDTH \
    --shuffle \
    $VAL_DATA_ROOT \
    ./val.txt \
    $EXAMPLE/"patch"${1}"_val_lmdb"

echo "Done."

4 计算均值并保存

myfile中新建文件create_meanfile.sh。图片减去均值后，再进行训练和测试，会提高速度和精度。
使用./build/tools/compute_image_mean工具根据/examples/cifar10/cifar10_train_lmdb(刚刚生成的)文件计算出这些训练集图片数据的均值，并将其保存到/examples/cifar10/mean.binaryproto文件中。

遇到的问题：数据路径重叠，以至找不到文件
解决方案：DATA="./”
#!/bin/bash
EXAMPLE=/home/user/swscode/build_lmdb/
DATA="./"
TOOLS=/home/user/swfcode/caffe/build/tools   
  
$TOOLS/compute_image_mean $EXAMPLE/train_lmdb \
  imagenet_mean.binaryproto  
    
  echo "Done."

5 创建模型并编写配置文件

在myfile4中创建myfile4_train_test.prototxt文件
创建myfile4_solver.prototxt文件
根据examples/cifar10/cifar10_quick_solver.prototxt这个配置文件建立模型。名为cifar10_quick_solver的CNN模型由卷基层(convolution)、池化层(pooling)、非线性ReLU层(rectified linear unit (ReLU) nonlinearities)和在顶端的局部对比归一化线性分类器组成(local contrast normalization with a linear classifier on top of it all)。
name: "ResNet-50"
layer {
  name: "data"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TRAIN
  }
  transform_param {
    mirror: true
    crop_size: 224
    mean_file: "/home/user/swscode/imagenet_mean.binaryproto"
  }
  data_param {
    source: "/home/user/swscode/build_lmdb/train_lmdb"
    batch_size: 32
    backend: LMDB
  }
}
layer {
  name: "data"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TEST
  }
  transform_param {
    mirror: false
    crop_size: 224
    mean_file: "/home/user/swscode/imagenet_mean.binaryproto"
  }
  data_param {
    source: "/home/user/swscode/build_lmdb/val_lmdb"
    batch_size: 10
    backend: LMDB
  }
}
layer {
	bottom: "data"
	top: "conv1"
	name: "conv1"
	type: "Convolution"
	convolution_param {
		num_output: 64
		kernel_size: 7
		pad: 3
		stride: 2
		weight_filler {
      		  type: "msra"
    		}
	}
}

layer {
	bottom: "conv1"
	top: "conv1"
	name: "bn_conv1"
	type: "BatchNorm"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}

layer {
	bottom: "conv1"
	top: "conv1"
	name: "scale_conv1"
	type: "Scale"
	scale_param {
		bias_term: true
	}
}

layer {
	bottom: "conv1"
	top: "conv1"
	name: "conv1_relu"
	type: "ReLU"
}

layer {
	bottom: "conv1"
	top: "pool1"
	name: "pool1"
	type: "Pooling"
	pooling_param {
		kernel_size: 3
		stride: 2
		pool: MAX
	}
}

layer {
	bottom: "pool1"
	top: "res2a_branch1"
	name: "res2a_branch1"
	type: "Convolution"
	convolution_param {
		num_output: 256
		kernel_size: 1
		pad: 0
		stride: 1
		bias_term: false
		weight_filler {
      		  type: "msra"
    		}
	}
}

layer {
	bottom: "res2a_branch1"
	top: "res2a_branch1"
	name: "bn2a_branch1"
	type: "BatchNorm"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}

layer {
	bottom: "res2a_branch1"
	top: "res2a_branch1"
	name: "scale2a_branch1"
	type: "Scale"
	scale_param {
		bias_term: true
	}
}

layer {
	bottom: "pool1"
	top: "res2a_branch2a"
	name: "res2a_branch2a"
	type: "Convolution"
	convolution_param {
		num_output: 64
		kernel_size: 1
		pad: 0
		stride: 1
		bias_term: false
		weight_filler {
      		  type: "msra"
    		}
	}
}

layer {
	bottom: "res2a_branch2a"
	top: "res2a_branch2a"
	name: "bn2a_branch2a"
	type: "BatchNorm"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}

layer {
	bottom: "res2a_branch2a"
	top: "res2a_branch2a"
	name: "scale2a_branch2a"
	type: "Scale"
	scale_param {
		bias_term: true
	}
}

layer {
	bottom: "res2a_branch2a"
	top: "res2a_branch2a"
	name: "res2a_branch2a_relu"
	type: "ReLU"
}

layer {
	bottom: "res2a_branch2a"
	top: "res2a_branch2b"
	name: "res2a_branch2b"
	type: "Convolution"
	convolution_param {
		num_output: 64
		kernel_size: 3
		pad: 1
		stride: 1
		bias_term: false
		weight_filler {
      		  type: "msra"
    		}
	}
}

layer {
	bottom: "res2a_branch2b"
	top: "res2a_branch2b"
	name: "bn2a_branch2b"
	type: "BatchNorm"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}

layer {
	bottom: "res2a_branch2b"
	top: "res2a_branch2b"
	name: "scale2a_branch2b"
	type: "Scale"
	scale_param {
		bias_term: true
	}
}

layer {
	bottom: "res2a_branch2b"
	top: "res2a_branch2b"
	name: "res2a_branch2b_relu"
	type: "ReLU"
}

layer {
	bottom: "res2a_branch2b"
	top: "res2a_branch2c"
	name: "res2a_branch2c"
	type: "Convolution"
	convolution_param {
		num_output: 256
		kernel_size: 1
		pad: 0
		stride: 1
		bias_term: false
		weight_filler {
      		  type: "msra"
    		}
	}
}

layer {
	bottom: "res2a_branch2c"
	top: "res2a_branch2c"
	name: "bn2a_branch2c"
	type: "BatchNorm"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}

layer {
	bottom: "res2a_branch2c"
	top: "res2a_branch2c"
	name: "scale2a_branch2c"
	type: "Scale"
	scale_param {
		bias_term: true
	}
}

layer {
	bottom: "res2a_branch1"
	bottom: "res2a_branch2c"
	top: "res2a"
	name: "res2a"
	type: "Eltwise"
}

layer {
	bottom: "res2a"
	top: "res2a"
	name: "res2a_relu"
	type: "ReLU"
}
...

layer {
	bottom: "res5c_branch2a"
	top: "res5c_branch2a"
	name: "bn5c_branch2a"
	type: "BatchNorm"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}

layer {
	bottom: "res5c_branch2a"
	top: "res5c_branch2a"
	name: "scale5c_branch2a"
	type: "Scale"
	scale_param {
		bias_term: true
	}
}

layer {
	bottom: "res5c_branch2a"
	top: "res5c_branch2a"
	name: "res5c_branch2a_relu"
	type: "ReLU"
}

layer {
	bottom: "res5c_branch2a"
	top: "res5c_branch2b"
	name: "res5c_branch2b"
	type: "Convolution"
	convolution_param {
		num_output: 512
		kernel_size: 3
		pad: 1
		stride: 1
		bias_term: false
		weight_filler {
      		  type: "msra"
    		}
	}
}

layer {
	bottom: "res5c_branch2b"
	top: "res5c_branch2b"
	name: "bn5c_branch2b"
	type: "BatchNorm"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}

layer {
	bottom: "res5c_branch2b"
	top: "res5c_branch2b"
	name: "scale5c_branch2b"
	type: "Scale"
	scale_param {
		bias_term: true
	}
}

layer {
	bottom: "res5c_branch2b"
	top: "res5c_branch2b"
	name: "res5c_branch2b_relu"
	type: "ReLU"
}

layer {
	bottom: "res5c_branch2b"
	top: "res5c_branch2c"
	name: "res5c_branch2c"
	type: "Convolution"
	convolution_param {
		num_output: 2048
		kernel_size: 1
		pad: 0
		stride: 1
		bias_term: false
		weight_filler {
      		  type: "msra"
    		}
	}
}

layer {
	bottom: "res5c_branch2c"
	top: "res5c_branch2c"
	name: "bn5c_branch2c"
	type: "BatchNorm"
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
  param {
    lr_mult: 0
    decay_mult: 0
  }
}

layer {
	bottom: "res5c_branch2c"
	top: "res5c_branch2c"
	name: "scale5c_branch2c"
	type: "Scale"
	scale_param {
		bias_term: true
	}
}

layer {
	bottom: "res5b"
	bottom: "res5c_branch2c"
	top: "res5c"
	name: "res5c"
	type: "Eltwise"
}

layer {
	bottom: "res5c"
	top: "res5c"
	name: "res5c_relu"
	type: "ReLU"
}

layer {
	bottom: "res5c"
	top: "pool5"
	name: "pool5"
	type: "Pooling"
	pooling_param {
		kernel_size: 7
		stride: 1
		pool: AVE
	}
}

layer {
	bottom: "pool5"
	top: "fc1500"
	name: "fc1500"
	type: "InnerProduct"
	inner_product_param {
		num_output: 1500
		weight_filler {
      		  type: "msra"
    		}
    		bias_filler {
      		  type: "constant"
      		  value: 0
    	        }
	}
}

layer {
	bottom: "fc1500"
	bottom: "label"
	top: "prob"
	name: "prob"
	type: "SoftmaxWithLoss"
	include {
	  phase: TRAIN
	}
}
layer {
  bottom: "fc1500"
  bottom: "label"
  top: "accuracy@1"
  name: "accuracy/top1"
  type: "Accuracy"
  accuracy_param {
    top_k: 1
  }
}
layer {
  bottom: "fc1500"
  bottom: "label"
  top: "accuracy@5"
  name: "accuracy/top5"
  type: "Accuracy"
  accuracy_param {
    top_k: 5
  }
}

6 训练和测试 

# ./build/tools/caffe train -solver examples/myfile/myfile_solver.prototxt  -weights models/bvlc_reference_caffenet/ResNet-50-model.caffemodel  -gpu 1

7 用训练好的模型进行分类 

遇到的问题：训练结果都是0.01
解决方案：改deploy里的全连接层类别数以及num_output为1500
遇到的问题：找不到caffe里的库函数
解决的方案：sys.path.insert(0,caffe_root+'python')
小结：网络训练模型train_test.prototxt 测试部署模型deploy.prototxt 求解参数solver.prototxt
#coding=utf-8
import sys
sys.path.insert(0,'/home/user/swfcode/caffe/python')
import os
import caffe
import numpy as np
root='/home/user/swscode/datatest/'
deploy=root +'ResNet-50-deploy.prototxt'
caffe_model='/data1/swfdata/swfmodels/residualnet_imagenet/sws_1211resnet_50_iter_150000.caffemodel'
import os
import numpy as np
mylist=[]
dir = root+'val/'
filelist=[]
filenames = os.listdir(dir)
for fn in filenames:
    fullfilename = os.path.join(dir,fn)
    filelist.append(fullfilename)


net = caffe.Net(deploy,caffe_model,caffe.TEST)
    # img=root+‘data/DRIVE/test/60337.jpg‘
def Test(img, net):

    # transformer = caffe.io.Transformer({'data':net.blobs['data'].data.shape})
    transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
    transformer.set_transpose('data', (2,0,1))
    #transformer.set_mean(‘data‘, np.load(mean_file).mean(1).mean(1))
    transformer.set_raw_scale('data', 255)
    transformer.set_channel_swap('data', (2,1,0))
    im=caffe.io.load_image(img)
    net.blobs['data'].data[...] = transformer.preprocess('data',im)


    out = net.forward()
    labels = np.loadtxt(labels_filename, str, delimiter='\t')
    prob= net.blobs['prob'].data[0].flatten()
    print prob
    order=prob.argsort()[:3]
    return prob

    # print 'the class is:',labels[order]
    # f=file("/home/user/swfcode/caffe/label.txt","a+")
    #f.write(labels[order]+'\n')
labels_filename = root +'result.txt'
for i in range(0, len(filelist)):
    img= filelist[i]
    prob=Test(img ,net)
    np.argmax(prob)
    mylist.append(np.argmax(prob))

file=open('result.txt','w')
file.write(str(mylist))
file.close()
源码下载请移步GitHub：https://github.com/songwenshuang/Training-and-test-DataSet-with-Caffe



使用mmclassification训练自己的图像分类器
带你成为别人眼中的大佬！
06-16 295
train文件夹中包含用于训练的图像，val文件夹中包含用于验证的图像。例如，如果有10个类别，则train和val文件夹中应该各有10个子文件夹，每个子文件夹的名称应该是相应类别的名称。可以在config文件夹中选择一个适合自己的配置文件，也可以自己创建一个新的配置文件。其中包括了网络结构、数据增强、优化器等相关参数的设置。有了以上的步骤和代码示例，我们就可以使用mmclassification训练自己的图像分类器了。是配置文件的路径，可用于指定训练采用的网络模型、优化器和学习率等超参数。
Caffe学习笔记
热门推荐
from_jiarenyf
09-04 1万+
安装与配置 Tutorial学习 PyCaffe学习 buildtools学习 其他
caffe 学习笔记
07-20
CAFFE 学习笔记详细翻译了CAFFE 官网tutorial中给出的例子，有每一步的操作过程，和对应的讲解。适合初学者上手
caffe学习笔记全系列
11-10
caffe学习笔记全系列
caffe学习笔记完整版
11-08
以具体的实例讲解caffe的使用（附代码），包括MNIST、CIFAR10在caffe的应用，可视化卷积层，如何训练自己的网络等。
caffe训练测试（用caffe训练自己的数据）
MaggieQuan的博客
09-12 8317
初试caffe训练，这里不是跑的caffe里自带的例子，是训练测试自己的数据集，欢迎指正~ps：这边就不介绍caffe的安装配置了，直接进入主题啦~ 1大量样本的准备 既然要做训练的话没有大量的图片样本是不行滴，这个阶段耗费很久的时间，说到这里要吐血了，三个人，对采集的视频中的每帧图片进行截图，不夸张的说总共截的图片大概有近百万张，当然啦还要对图片进行筛选不好的样本不要，否则会影响测试效果！我...
caffe学习笔记3用自己的数据训练和测试-薛开宇1
08-03
【标题】：“Caffe学习笔记3：用自己的数据训练和测试” 【内容】： 在深度学习领域，Caffe是一个广泛使用的框架，尤其适用于图像识别任务。本篇学习笔记主要讲解如何利用Caffe用自定义的数据集进行训练和测试，...
Caffe学习笔记：使用自己的数据训练和测试
"caffe学习笔记3用自己的数据训练和测试" 本篇学习笔记的主要内容是关于如何使用自己的数据在Caffe框架中进行训练和测试，主要涉及到数据准备、计算图像均值、网络定义、训练、恢复数据等步骤。 首先，在数据准备...
caffe学习笔记：mnist数据集的训练和测试
JoliceYu的技术博客
11-22 1753
最近一直在研究linux下的caffe，记录下自己在学习过程的一些步骤。1、准备数据和训练1、准备数据，在caffe的根目录下依次执行以下2个命令：./data/mnist/get_mnist.sh ##获取mnist数据集 ./examples/mnist/create_mnist.sh ##创建lmdb或者而是levedb文件运行上面的2个指令后，在./examples/mnist文件夹下
caffe学习笔记4-学习搭建自己的网络——MNIST在caffe上进行训练与学习-薛开宇.pdf
最新发布
07-21
在本次学习笔记中，我们将深入探讨如何使用Caffe框架搭建一个神经网络模型，并用它来训练和学习MNIST数据集。首先，MNIST数据集是由手写数字组成的图像集合，它在机器学习领域中作为入门级的实验数据集而被广泛使用...
学习笔记3_用自己的数据训练和测试-薛开宇1
08-03
【学习笔记3_用自己的数据训练和测试-薛开宇1】这篇笔记主要讲解了如何在Caffe框架下利用自定义的数据集进行模型训练和测试。以下是详细的步骤和知识点： 3.1 数据准备 首先，创建自己的小型数据集，这里以猫和鸟为...
Caffe训练和测试自己的数据集
Eddy的博客
04-07 1万+
学习caffe后跑了自带的例子是不是感觉很不过瘾，学习caffe的目的不是简单做几个练习，而是要用到自己的实际项目或者科研中，所以本文介绍如何从自己的原始图片到lmdb数据，再到训练和测试模型的整个流程。
数据构建-把所有文件夹切分成train,val,test
yscript的博客
04-22 436
训练数据是文件夹数据（比如3DMRI医学图像），一个文件夹视为一个训练数据，需要把所有文件夹(而非文件)切分成train,val,test
Caffe学习笔记1
SolaxiY的博客
05-04 231
MNIST数据集运行caffe框架中的脚本下载MNIST数据集cd data/mnist./get_mnist.sh用tree查看MNIST数据集结构sudo apt-get install treetree将二进制原始数据文件转换为LEVELDB或LMDB才能被Caffe识别转换为LMDB格式./examples/mnist/create_mnist.sh查看生成的结果：data.mdb和loc...
caffe学习笔记（一）
SHERO_M
08-10 371
准备工作，安装各种依赖和OpenCV，代码如下： 1 sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libhdf5-serial-dev protobuf-compiler 2 sudo apt-get install --no-install-recommends libbo
caffe学习笔记
wym2011aaj的专栏
08-01 1289
一、 整体思路 1、训练素材库 行为名称 说明 fighting 打架/肢体冲突/校园暴力/校园欺凌 handup 举手 playphone 玩手机 sleeping 课堂睡觉/趴桌子睡觉 writing 写字 2、训练过程 ①通过关键字爬取百度等搜索引擎的图片，通过Python脚本获取。 ②素材存放到Git仓库上，便于素材的更新。 ③通过Digits进行可视化...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值