另一个caffe实例整个流程

最新推荐文章于 2020-11-12 18:04:49 发布
最新推荐文章于 2020-11-12 18:04:49 发布
阅读量4.6k 收藏 3
点赞数 2
分类专栏： AI Basises 基础语言 文章标签： caffe gpu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wd1603926823/article/details/52763433
版权

四个类别：第0类 train：10000张 test：1685张   第1类：train：10000张  test：1250张  第2类：train：10000张 test：3553张 第3类：train：10000张 test：3639张

合计：train：40000张   test：10127张   图片要相同尺寸

一、生成label.txt

#include<iostream>
#include<string>
int main()
{
	FILE *fid1;
	fid1 = fopen("train_labels10.9.txt", "w");
	int label0 = 0, label1 = 1,label2=2,label3=3;
	char name[15], label[2], black[] = "\r\n";
	memset(name, 0, sizeof(name));
	for (int i = 0; i < 40000; ++i)
	{

		itoa(i, name, 10);
		strcat(name, ".jpg ");
		if (i<10000)
			itoa(label0, label, 10);
		else if (i>=10000 & i<20000)
			itoa(label1, label, 10);
		else if (i >= 20000 & i<30000)
			itoa(label2, label, 10);
		else
			itoa(label3, label, 10);
		
		strcat(name, label);
		printf("%s", name);
		fwrite(name, sizeof(name), 1, fid1);
		fwrite(black, strlen(black), 1, fid1);
		memset(name, 0, sizeof(name));
		memset(label, 0, sizeof(label));
	}
	
	fclose(fid1);
	return 0;
}
test文件夹也一样生成标签的txt


二、转化为lmdb

E:\pyCaffe_GPU\Build\x64\Release\convert_imageset.exe  E:\pyCaffe_GPU\Build\x64\Release\liuguanglei10_8train\ E:\pyCaffe_GPU\Build\x64\Release\liuguanglei10_8train\train_labels10.9.txt  E:\pyCaffe_GPU\examples\imagenet\train_lmdb_zao --shuffle -backend=lmdb  
pause




三、计算train和test的mean.binaryproto 

E:\pyCaffe_GPU\Build\x64\Release\compute_image_mean.exe  E:\pyCaffe_GPU\examples\imagenet\train_lmdb_zao E:\pyCaffe_GPU\examples\imagenet\mean_zao_train.binaryproto 
pause
（本来运行它时报错因为我图片尺寸有的大有的小  所以在第一步之前就要缩放到相同尺寸 不然这步会报错 所以我只能把图片缩放到相同尺寸后 再把上几步重走一遍 才正确）

四、写两个prototxt属性文件

name: "CaffeNet"
layer {
  name: "data"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TRAIN
  }
  transform_param {
    mirror: true
    crop_size: 190
    mean_file: "E:/pyCaffe_GPU/examples/imagenet/mean_zao_train.binaryproto"
  }
  data_param {
    source: "E:/pyCaffe_GPU/examples/imagenet/train_lmdb_zao/"
    batch_size: 100
    backend: LMDB
  }
}
layer {
  name: "data"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TEST
  }
  transform_param {
    mirror: false
    crop_size: 190
    mean_file: "E:/pyCaffe_GPU/examples/imagenet/mean_zao_test.binaryproto"
  }
  data_param {
    source: "E:/pyCaffe_GPU/examples/imagenet/test_lmdb_zao/"
    batch_size: 20
    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: 13
    kernel_size: 5
    stride: 5
    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: 5
    stride: 3
  }
}
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: 26
    kernel_size: 3
	stride: 1
    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: 1
  }
}
layer {
  name: "norm2"
  type: "LRN"
  bottom: "pool2"
  top: "norm2"
  lrn_param {
    local_size: 5
    alpha: 0.0001
    beta: 0.75
  }
}
layer {
  name: "fc3"
  type: "InnerProduct"
  bottom: "pool2"
  top: "fc3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 1050
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 1
    }
  }
}
layer {
  name: "relu3"
  type: "ReLU"
  bottom: "fc3"
  top: "fc3"
}
layer {
  name: "drop3"
  type: "Dropout"
  bottom: "fc3"
  top: "fc3"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc4"
  type: "InnerProduct"
  bottom: "fc3"
  top: "fc4"
  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: "fc4"
  bottom: "label"
  top: "accuracy"
  include {
    phase: TRAIN
  }
}
layer {
  name: "accuracy"
  type: "Accuracy"
  bottom: "fc4"
  bottom: "label"
  top: "accuracy"
  include {
    phase: TEST
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "fc4"
  bottom: "label"
  top: "loss"
}



net: "E:/pyCaffe_GPU/examples/imagenet/zaotraintest.prototxt"
test_iter: 550
test_interval: 100

base_lr: 0.0001
momentum: 0.9
weight_decay: 0.0005


lr_policy: "step"
gamma: 0.1
stepsize:1000
power: 0.75

display: 10

max_iter: 20000

snapshot: 2000
snapshot_prefix: "E:/pyCaffe_GPU/examples/imagenet/zao"

solver_mode: GPU
五、写train.bat训练 

E:\pyCaffe_GPU\Build\x64\Release\caffe.exe train --solver=E:\pyCaffe_GPU\examples\imagenet\zaosolver.prototxt >zao_log.txt 2>&1


六、画accuracy及loss曲线图

大概稳定在88%的样子。

训练出了caffemodel！

七、预测验证集类别
我有验证集4127张。

1，写自己的deploy文件

name: "CaffeNet"
layer {
  name: "data"
  type: "Input"
  top: "data"
  input_param { shape: { dim: 10 dim: 3 dim: 190 dim: 190 } }
}
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: 13
    kernel_size: 5
    stride: 5
    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: 5
    stride: 3
  }
}
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: 26
    kernel_size: 3
	stride: 1
    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: 1
  }
}
layer {
  name: "norm2"
  type: "LRN"
  bottom: "pool2"
  top: "norm2"
  lrn_param {
    local_size: 5
    alpha: 0.0001
    beta: 0.75
  }
}
layer {
  name: "fc3"
  type: "InnerProduct"
  bottom: "pool2"
  top: "fc3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 1050
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 1
    }
  }
}
layer {
  name: "relu3"
  type: "ReLU"
  bottom: "fc3"
  top: "fc3"
}
layer {
  name: "drop3"
  type: "Dropout"
  bottom: "fc3"
  top: "fc3"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc4"
  type: "InnerProduct"
  bottom: "fc3"
  top: "fc4"
  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: "prob"
  type: "Softmax"
  bottom: "fc4"
  top: "prob"
}

2、预测类别的脚本py

#http://www.111cn.net/phper/python/47504.htm
import time
start=time.clock()
import os
from myclassify1img import classify1img
import caffe
caffe.set_mode_gpu()
caffe.set_device(0)

dir_path='E:/pyCaffe_GPU/examples/imagenet/zao_val/'   

imglist=[]
for path,d,filelist in os.walk(dir_path):
    filelist.sort(key= lambda x:int(x[:-4]))
    for filename in filelist: 
        mypath =dir_path + filename
        imglist.append(mypath)
print imglist

net_file='E:\pyCaffe_GPU\examples\imagenet\mydeploy_zao.prototxt'
caffe_model='E:\pyCaffe_GPU\examples\imagenet\zao_iter_20000.caffemodel'   
mean_file='E:\pyCaffe_GPU\examples\imagenet\mean_zao_train.binaryproto'
class_result='E:\pyCaffe_GPU\examples\imagenet\zao_class_result.txt'

net = caffe.Net(net_file,caffe_model,caffe.TEST)
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))
mean_blob = caffe.proto.caffe_pb2.BlobProto()
mean_blob.ParseFromString(open(mean_file, 'rb').read())
mean_npy = caffe.io.blobproto_to_array(mean_blob)
b2=mean_npy[0,:,:,:]
transformer.set_mean('data',b2.mean(1).mean(1))  
transformer.set_raw_scale('data', 255)
transformer.set_channel_swap('data', (2,1,0)) # if using RGB instead if BGR
#img=caffe.io.load_image('E:/Keras_Code/examples/imagenet/forclassify/test13.bmp')
imagenet_labels_filename = 'E:\pyCaffe_GPU\examples\imagenet\zao_label.txt' 

allclass=[]
for file in imglist:
	img=file    
	myclass=classify1img(imagenet_labels_filename,net,transformer,img)  
	allclass.append(myclass)

f=open(class_result,'w')
for ind in range(len(filelist)):
    f.write(filelist[ind]+' '+allclass[ind]+'\n')
f.close()

finish=time.clock()
print "read: %f s"%(finish - start)


结果：


搞定！

3、计算准确率：

#include <iostream>
#include <fstream>
using namespace std;

#define NUM 4126

int i, Datalen = -1;
double Data[NUM];

int main(void)
{
	int pre_class, cor1 = 0, cor2 = 0, cor3 = 0, cor4 = 0,all3=0,all0=0,all1=0,all2=0,correct=0;
	ifstream fin("zao_class_result.txt");
	if (!fin)
	{
		cerr << "Can not open txt file." << endl;
		getchar();
		return 1;
	};
	while (!fin.eof())
	{
		Datalen++;
		fin >> Data[Datalen];
	};
	fin.close();
	
	for (i = 0; i <= NUM; i++)
	{
		pre_class = Data[i];
		//cout << pre_class << " ";
		if (i < 685)
		{
			++all0;
			if (pre_class == 0)
			    ++cor1;
		}
		else if (i >= 685 & i < 935)
		{
			++all1;
			if (pre_class == 1)
				++cor2;
		}	
		else if (i >= 935 & i < 2488)
		{
			++all2;
			if (pre_class == 2)
				++cor3;
		}	
		else
		{
			++all3;
			if (pre_class == 3)
				++cor4;
		}
	}
	//cout << endl << endl;
	cout << cor1 << " " << cor2 << " " << cor3 << " " << cor4 << endl;
	cout << all0 << " " << all1 << " " << all2 << " " << all3 << endl;
	correct = cor1 + cor2 + cor3 + cor4;
	//cout << "correct number:" << correct << endl;
	double ac = correct / double(NUM+1);
	cout << "correct number:" << ac << endl;
	return 0;
}
一共4127张   准确率77%


八、提取特征

#extract many images in one folder
import time
start=time.clock()
import os
import numpy as np
import matplotlib.pyplot as plt
import caffe
from useless_test import vis_square
from PIL import Image
import scipy.io as sio 
caffe.set_mode_gpu()
caffe.set_device(0)

deployPrototxt ='E:\pyCaffe_GPU\examples\imagenet\mydeploy_zao.prototxt'  #
modelFile ='E:\pyCaffe_GPU\examples\imagenet\zao_iter_20000.caffemodel'   #
mean_file='E:\pyCaffe_GPU\examples\imagenet\mean_zao_train.binaryproto'  #
net = caffe.Net(deployPrototxt, modelFile,caffe.TEST)

#for layer_name, blob in net.blobs.iteritems():  
#    print layer_name + '\t' + str(blob.data.shape)

transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})  
transformer.set_transpose('data', (2,0,1))    
mean_blob = caffe.proto.caffe_pb2.BlobProto()
mean_blob.ParseFromString(open(mean_file, 'rb').read())
mean_npy = caffe.io.blobproto_to_array(mean_blob)
b2=mean_npy[0,:,:,:]
transformer.set_mean('data',b2.mean(1).mean(1))  
transformer.set_raw_scale('data', 255)   
transformer.set_channel_swap('data', (2,1,0))  
net.blobs['data'].reshape(1,3,190,190)   #

dir_path='E:/pyCaffe_GPU/examples/imagenet/zao_val'  #
filelists=os.listdir(dir_path)
#print filelists

#dim=4096  changed by you
features = np.empty((len(filelists),1050),dtype="float32")   #

for ind,everyimg in enumerate(filelists):
    theimg='E:/pyCaffe_GPU/examples/imagenet/zao_val/'+everyimg
    net.blobs['data'].data[...] = transformer.preprocess('data',caffe.io.load_image(theimg))
    net.forward()
    feat_fc= net.blobs['fc3'].data[0]
    feat_fc.shape=(1050,1)  #
    row_feat_fc=np.transpose(feat_fc)
    features[ind,:]=row_feat_fc

#np.savetxt("E:/Keras_Code/examples/imagenet/savefeatures.txt",row_feat_fc)
sio.savemat("E:/pyCaffe_GPU/examples/imagenet/zao_imgsfeatures.mat", {'feature':features})  #
finish=time.clock()
print "read: %f s"%(finish - start)


OK啦！

/

最讨厌星期一！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！不想上班！！！！！要是有坐在家里收钱的工作就好了！！！！！！！！

元气少女缘结神
关注
专栏目录
Caffe源码，训练流程分析
m_buddy的博客
04-14 917
1. 前言 1.1 Caffe结构简单梳理 在之前的文章（Caffe源码整体结构及介绍）中介绍了Caffe中的一些重要的组件： 1）Blob 主要用来表示网络中的数据，包括训练数据，网络各层自身的参数(包括权值、偏置以及它们的梯度)，网络之间传递的数据都是通过 Blob 来实现的，同时 Blob 数据也支持在 CPU 与 GPU 上存储，能够在两者之间做同步。 2）Layer 是对神经网络中各种层...
Caffe 初始化流程理解（数据流建立）
jy001227801的专栏
08-07 486
本文是作者原创，如有理解错误，恳请大家指出，如需引用，请注明出处。Caffe FeatureMap数据流的建立用语解释 FeatureMap: 输入的图片信息或者经过多层处理后的图片信息。 weights: 只针对卷积层存在的权重系数。 caffe :文中提到的caffe均指caffed1.0,如果使用caffe2.0会特别指出。 在讲解FeatureMap的数据流之前，首先需要明确一下caffe的
Windows下caffe训练实例
08-13
windows下，caffe训练实例，包含训练数据，以及配置文件。一定将配置文件里面的路径，改为自己电脑上的路径，才可以正确运行。
Caffe实例
weixin_30273763的博客
01-03 225
下载链接以及说明： 1.caffe代码按照官方教程下载windows分支下面的就可以了（https://github.com/BVLC/caffe/tree/windows）。 2.cmake(https://cmake.org/download/) 3.miniconda3 python3.6 x64(https://conda.io/miniconda.html...
caffe 实例笔记 2 LeNet详细解读及实现
bea_tree的博客
06-19 1万+
1 温习 1.1 关于caffe的名称： caffe = convolutional architecture for fast feature embedding 1.2 caffe.proto Protocol Buffers顾名思义这是一种协议接口，这是了解caffe功能之后，需要了解的第一件事情。有很多相关博客。简单看一下其结构： package xx;#xx将作为
caffe分类小例子
Cristal_yin的博客
10-31 1241
Caffedata、examples、include、matlab、models、python、src、toolsexamples：官网提供的基本的模型include:框架源码头文件src:caffe框架源码models:存放训练完的模型以及网络结构文档tools：用于可执行的文件分类小例子用已有的参数文件和训练好的模型对现有的图片进行分类，这个用官网的例子作为测试import numpy as n
Caffe第一个深度学习例子菜鸟编程【mnist实例篇】
千年板蓝根
11-12 199
温馨提示：在代码森林上机训练之前先使用ubuntu登录系统，密码通过右侧上机界面获取，登录成功以后切换到root用户下，密码和ubuntu的密码是一样的，使用命令： su root caffe自带的例子mnist。 mnist是一个手写数字库，由DL大牛Yan LeCun进行维护。mnist最初用于支票上的手写数字识别, 现在成了DL的入门练习库。征对mnist识别的专门模型是Lenet，算是最早的cnn模型了。 mnist数据训练样本为60000张，测试样本为10000张，每个样本为28*
caffe_Component:caffe原始码学习
03-24
《Caffe组件详解：深入学习Caffe源代码》 Caffe（Convolutional Architecture for Fast Feature Embedding）是由...深度学习框架的学习是一个不断探索和实践的过程，希望本文能为您的Caffe之旅提供有价值的引导。
opencv + caffemodel 人脸识别-python源码.zip
最新发布
05-02
6. **案例设计**：这表明提供的不仅是一段代码，而是一个精心设计的实例，可能包括了从数据处理到结果展示的完整流程，有助于学习者理解和应用这些技术。 在实际操作中，这个案例可能会包括以下步骤： - 加载Caffe...
Caffe数据集：CIFAR10之二
12-01
在深度学习领域，Caffe是一种高效且广泛应用的...通过下载和处理"data_batch_2.bin"和"data_batch_3.bin"等文件，开发者可以实践从数据预处理到模型训练和评估的整个流程，从而提升对深度学习技术的理解和应用能力。
180520 Caffe官方例子example问题汇总
专注机器学习之路
05-20 910
问题1：no module name _caffe 解决python在import caffe时出现的no module name _caffe问题 # 将相对路径改为绝对路径 caffe_root = '/home/brucelau/anaconda3/envs/caffe27/' # caffe_root = '../' # this file should be run from ...
【9】Caffe学习系列：运行caffe自带的简单例子
yeler082的博客
10-16 463
为了程序的简洁，在caffe中是不带练习数据的，因此需要自己去下载。但在caffe根目录下的data文件夹里，作者已经为我们编写好了下载数据的脚本文件，我们只需要联网，运行这些脚本文件就行了。 注意：在caffe中运行所有程序，都必须在根目录下进行，即caffe/，否则会出错,因为脚本文件对应的目录是caffe的根目录。 1、catand fish-bike实例 step1: 生成trai...
深度学习Caffe案例
外环西路
05-08 3245
总结一些深度学习应用案例，会不断更新内容，实验测试放在github上，希望能与大家一起交流学习。 1 CIFAR10 分类 CIFAR10_TRAINING 2 基于VGG人脸表情识别 vgg_faceemotion_transferlearning 相关文章 1. caffe 深度学习 http://www.voidcn.com/article/p-ssnwjkco...
caffe工作流程
Dachao_Xu的博客
03-15 1257
转自点击打开链接
Caffe学习系列(9)：运行caffe自带的两个简单例子
weixin_34007020的博客
12-25 732
为了程序的简洁，在caffe中是不带练习数据的，因此需要自己去下载。但在caffe根目录下的data文件夹里，作者已经为我们编写好了下载数据的脚本文件，我们只需要联网，运行这些脚本文件就行了。 注意：在caffe中运行所有程序，都必须在根目录下进行，否则会出错 1、mnist实例 mnist是一个手写数字库，由DL大牛Yan LeCun进行维护。mnist最初用于支票上的手写数字识别, 现在...
Caffe自带的测试的实例
计算机的专栏
04-13 2083
Caffe自带的测试的实例Caffe有自带的数据集：minist和cifar10。1.   Cd  /home/amax/chunweitian/caffe/data2.    下载数据sudosh data/cifar10/get_cifar10.sh运行成功后，会在data/cifar10/文件下生成一堆bin文件。 3.   转换数据格式为lmdb根目录下执行：sudosh examples...
caffe 常用指令实例
weixin_41760827的博客
06-27 325
本文作为快速查询手册，方便快速查找使用命令。1. 图像转换为lmdb文件：在做这一步之前需要下载图片文件。一般有四个部分：train，val文件夹（每个文件夹应该有大量的图片文件，尺寸可以不同，因为后续的caffe tools中提供了resize工具）。两个txt文件分别对应train 和 val 文件夹中的图片，每一行为图片名称（*.jpg）加上一个空格（只能为一个空格，如果发现用的是tab或者...
Caffe经典模型--faster-rcnn目标检测实战案例（一）
xw_2_xh的博客
01-29 1484
这篇文章主要记录py-faster-rcnn的编译及测试，是实战案例的前期准备。想动手训练自己的数据集可以参考下一篇文章Caffe经典模型--faster-rcnn目标检测实战案例（二）（训练kitti数据集） 在编译py-faster-rcnn之前，首先要确保机器上已经安装后caffe，如果还没有安装好caffe，可以参考Centos下的Caffe编译安装简易手册 下面正式开始py-fast...
caffe自学-mnist示例程序详解
热门推荐
Sue.Y的专栏
10-16 1万+
caffe中的mnist示例程序超详解，中间包含准备数据、网络模型解析、训练和测试全过程，以及遇到的error和解决方法，适合零caffe以及linux零基础的童鞋
"Caffe深度学习训练全过程及应用实例
总之，Caffe是一款功能强大且易于使用的深度学习框架，它的深度学习训练全过程包括了数据预处理、网络模型构建、训练参数配置、模型训练、模型评估和模型预测等多个步骤。通过掌握这些步骤，用户可以使用Caffe进行...
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

元气少女缘结神

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值