【目标识别】【结果存入数据库】将Caffe框架和SSD最后检测结果存入Oracle数据库中

最新推荐文章于 2023-05-31 10:53:23 发布
最新推荐文章于 2023-05-31 10:53:23 发布
阅读量932 收藏
点赞数
文章标签： 目标检测存入数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxiansheng001/article/details/102750104
版权

 

 

1、代码在ssd_detect中实现

// This is a demo code for using a SSD model to do detection.
// The code is modified from examples/cpp_classification/classification.cpp.
// Usage:
//    ssd_detect [FLAGS] model_file weights_file list_file
//
// where model_file is the .prototxt file defining the network architecture, and
// weights_file is the .caffemodel file containing the network parameters, and
// list_file contains a list of image files with the format as follows:
//    folder/img1.JPEG
//    folder/img2.JPEG
// list_file can also contain a list of video files with the format as follows:
//    folder/video1.mp4
//    folder/video2.mp4
//




#include <caffe/caffe.hpp>
#ifdef USE_OPENCV
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#endif  // USE_OPENCV
#include <algorithm>
#include <iomanip>
#include <iosfwd>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <fstream>
#include <iostream>

#include <windows.h>
#include <sql.h>
#include <sqlext.h>
#include <odbcss.h>

//#define SQLBINDCOL
SQLHENV  henv = SQL_NULL_HENV;//定义环境句柄
SQLHDBC  hdbc1 = SQL_NULL_HDBC;//定义数据库连接句柄     
SQLHSTMT  hstmt1 = SQL_NULL_HSTMT;//定义语句句柄

#ifdef USE_OPENCV
using namespace caffe;  // NOLINT(build/namespaces)
//非核心代码已经省略
int main(int argc, char** argv) {
  ::google::InitGoogleLogging(argv[0]);
  // Print output to stderr (while still logging)
  FLAGS_alsologtostderr = 1;

#ifndef GFLAGS_GFLAGS_H_
  namespace gflags = google;
#endif

  gflags::SetUsageMessage("Do detection using SSD mode.\n"
        "Usage:\n"
        "    ssd_detect [FLAGS] model_file weights_file list_file\n");
  gflags::ParseCommandLineFlags(&argc, &argv, true);

  if (argc < 4) {
    gflags::ShowUsageWithFlagsRestrict(argv[0], "examples/ssd/ssd_detect");
    return 1;
  }

  const string& model_file = argv[1];
  const string& weights_file = argv[2];
  const string& mean_file = FLAGS_mean_file;
  const string& mean_value = FLAGS_mean_value;
  const string& file_type = FLAGS_file_type;
  const string& out_file = FLAGS_out_file;
  const float confidence_threshold = FLAGS_confidence_threshold;

  // Initialize the network.
  Detector detector(model_file, weights_file, mean_file, mean_value);

  // Set the output mode.
  std::streambuf* buf = std::cout.rdbuf();
  std::ofstream outfile;
  if (!out_file.empty()) {
    outfile.open(out_file.c_str());
    if (outfile.good()) {
      buf = outfile.rdbuf();
    }
  }
  std::ostream out(buf);

  // Process image one by one.
  std::ifstream infile(argv[3]);
  std::string file;


  //连接数据库
  RETCODE retcode;//错误返回码

  // Allocate the ODBC Environment and save handle.
  retcode = SQLAllocHandle(SQL_HANDLE_ENV, NULL, &henv);
  if (retcode < 0)//错误处理
  {
	  out << "allocate ODBC Environment handle errors." << std::endl;
	  return -1;
  }
  // Notify ODBC that this is an ODBC 3.0 application.
  retcode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION,
	  (SQLPOINTER)SQL_OV_ODBC3, SQL_IS_INTEGER);
  if (retcode < 0) //错误处理
  {
	  out << "the  ODBC is not version3.0 " << std::endl;
	  return -1;
  }

  // Allocate an ODBC connection and connect.
  retcode = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc1);
  if (retcode < 0) //错误处理
  {
	  out << "allocate ODBC connection handle errors." << std::endl;
	  return -1;
  }
  //Data Source Name must be of type User DNS or System DNS
  char* szDSN = "orcl";
  char* szUID = "hyjkxt";//log name
  char* szAuthStr = "hy_jkxt_2016";//passward
  //connect to the Data Source
  retcode = SQLConnect(hdbc1, (SQLCHAR*)szDSN, (SWORD)strlen(szDSN),(SQLCHAR*)szUID, (SWORD)strlen(szUID), (SQLCHAR*)szAuthStr, (SWORD)strlen(szAuthStr));
  if (retcode < 0) //错误处理
  {
	  out << "connect to  ODBC datasource errors." << std::endl;
	  return -1;
  }
  // Allocate a statement handle.
  retcode = SQLAllocHandle(SQL_HANDLE_STMT, hdbc1, &hstmt1);
  if (retcode < 0) //错误处理
  {
	  out << "allocate ODBC statement handle errors." << std::endl;
	  return -1;
  }









  //cv::namedWindow("result");
//  std::vector<cv::Rect> pos;
  while (infile >> file) {
    if (file_type == "image") {
		//std::cout << file << std::endl;
      cv::Mat img = cv::imread(file, -1);
      CHECK(!img.empty()) << "Unable to decode image " << file;
	  double t1 = cv::getTickCount();
      std::vector<vector<float> > detections = detector.Detect(img);
	  //t1 = cv::getTickCount() - t1;
	  //std::cout << "time:" << 1000 * t1 / cv::getTickFrequency() << std::endl;
	 
	  /* Print the detection results. */
	  //ofstream f1("/home/ubuntu/results.txt",ios::app);
	  std::ofstream f2("E:/detect/results.txt", ios::out);
	  int cat, person = 0, car = 0, boat = 0, p = 0, c = 0, b = 0, flag = 0;;
	  string s = "";
	  for (int i = 0; i < detections.size(); ++i) {
		  const vector<float>& d = detections[i];
		  // Detection format: [image_id, label, score, xmin, ymin, xmax, ymax].
		  CHECK_EQ(d.size(), 7);
		  const float score = d[2];
		  if (score >= confidence_threshold) {
			  cat = static_cast<int>(d[1]);   //\BC\C6\CB\E3\C8˳\B5\B4\AC\CA\FD\C1\BF
			  if (cat == 1)
				  person++;
			  else if (cat == 2)
				  car++;
			  else
				  boat++;
		  }
	  }
	  for (int i = 0; i < detections.size(); ++i) {
		  const vector<float>& d = detections[i];
		  // Detection format: [image_id, label, score, xmin, ymin, xmax, ymax].
		  CHECK_EQ(d.size(), 7);
		  const float score = d[2];
		  string pcb;
		  stringstream ss;
		  if (score >= confidence_threshold) {
			  flag = 1;
			  cat = static_cast<int>(d[1]);  //\BD\ABĿ\B1\EA\D6\D6\C0\E0\B4\FA\BAź\CD\CA\FD\C1\BFд\C8\EB\D7ַ\FB\B4\AEs
			  if (cat == 1)
			  {
				  if (p == 0)
				  {
					  p = 1;
					  ss.str("");
					  ss << d[1];
					  pcb = ss.str();
					  s += " ";
					  s += pcb;
					  //s+=" ";
					  ss.str("");
					  ss << person;
					  pcb = ss.str();
					  s += " ";
					  s += pcb;
					  //s+=" ";
				  }
			  }
			  else if (cat == 2)
			  {
				  if (c == 0)
				  {
					  c = 1;
					  ss.str("");
					  ss << d[1];
					  pcb = ss.str();
					  s += " ";
					  s += pcb;
					  //s+=" ";
					  ss.str("");
					  ss << car;
					  pcb = ss.str();
					  s += " ";
					  s += pcb;
					  //s+=" ";
				  }
			  }
			  else
			  {
				  if (b == 0)
				  {
					  b = 1;
					  ss.str("");
					  ss << d[1];
					  pcb = ss.str();
					  s += " ";
					  s += pcb;
					  //s+=" ";
					  ss.str("");
					  ss << boat;
					  pcb = ss.str();
					  s += " ";
					  s += pcb;
					  //s+=" ";
				  }
			  }
			  ss.str("");      //\B0\FCΧ\BA\D0\D7\F8\B1\EA
			  ss << (d[3] * img.cols);
			  pcb = ss.str();
			  s += " ";
			  s += pcb;
			  //s+=" ";
			  ss.str("");
			  ss << (d[4] * img.rows);
			  pcb = ss.str();
			  s += " ";
			  s += pcb;
			  //s+=" ";
			  ss.str("");
			  ss << (d[5] * img.cols);
			  pcb = ss.str();
			  s += " ";
			  s += pcb;
			  //s+=" ";
			  ss.str("");
			  ss << (d[6] * img.rows);
			  pcb = ss.str();
			  s += " ";
			  s += pcb;
			  //s+=" ";

		  }

	  }
	  if (!f2) break;
	  int q1, q2, q3, q5;
	  //file·\BE\B6+ԭͼƬ\C3\FB\B3\C6:/home/xxzx/.../KD481-\BF\BF\B4\AC\C5\C5_20170622165111_6532_14B50310_14981214718.jpg
	  //fil·\BE\B6+ԭͼƬ\C3\FB\B3\C6ȥ\B3\FD.jpg\B5\C4\CEļ\FE\C3\FB:/home/xxzx/.../KD481-\BF\BF\B4\AC\C5\C5_20170622165111_6532_14B50310_14981214718
	  //iddԭͼƬ\C3\FB\B3\C6ȥ\B3\FD.jpg\B5\C4\CEļ\FE\C3\FB:KD481-\BF\BF\B4\AC\C5\C5_20170622165111_6532_14B50310_14981214718
	  //idԭͼƬ\C3\FB\B3Ʋ\BF\B7\D6:KD481-\BF\BF\B4\AC\C5\C5
	  //iddata1\B4\D3ʱ\BC俪ʼ\B5\BD\D7\EE\BA\F3:20170622165111_6532_14B50310_14981214718
	  //time\C4\EA\D4\C2\C8\D5ʱ\B7\D6\C3\EB:20170622165111
	  //year,month,day:2017,06,22
	  //sfmʱ\B7\D6\C3\EB:165111
	  //shi,fen,miaoʱ\A3\AC\B7֣\AC\C3\EB:16,51,11
	  //idtime\C3\FB\B3\C6+ʱ\BC\E4:KD481-\BF\BF\B4\AC\C5\C5_2017-06-22
	  string fil, id, data, time, iddata, year, month, day, md, iddata1, idd, mds, dsfm, sfm, idtime, ymd, shi, fen, miao, sf;
	  q1 = file.rfind("/");
	  q2 = file.find(".jpg");
	  fil = file;
	  fil.erase(q2);
	  //cout<<fil<<std::endl;
	  //cout<<q1<<std::endl;
	  //s=s.assign(s,1,string::npos);
	  idd.assign(fil, q1 + 1, string::npos);
	  q3 = idd.find("_");
	  id.assign(idd, 0, q3);//mingcheng
	  iddata1.assign(idd, q3 + 1, string::npos);
	  q5 = iddata1.find("_");
	  time.assign(iddata1, 0, q5);//shijian
	  year.assign(time, 0, 4);
	  mds.assign(time, 4, string::npos);
	  month.assign(mds, 0, 2);
	  dsfm.assign(mds, 2, string::npos);
	  day.assign(dsfm, 0, 2);
	  sfm.assign(dsfm, 2, string::npos);
	 // string wpath = "D:/beifen/warning/";
	  //string upath = "D:/beifen/warning/";
	  string wpath = "D:/beifen/warning/";//写入数据库的路径
	  string upath = "D:/beifen/warning/";//存储路径
	  idtime = id + "_";
	  idtime = idtime + time;
	  shi.assign(sfm, 0, 2);
	  sf.assign(sfm, 2, string::npos);
	  fen.assign(sf, 0, 2);
	  miao.assign(sfm, 4, 6);
	  //cout<<iddata<<" "<<id<<" "<<data<<" "<<s<< std::endl;
	  //wpath  windows·\BE\B6:D:/beifen/warning/2017/06/22/
	  //upath  ubuntu·\BE\B6:/home/xxzx/Share/warning/2017/06/22/
	  //ymd\C4\EA\D4\C2\C8\D5:2016-06-22
	  //s\BC\EC\B2\E2\D0\C5Ϣ:1 1 x1 y1 x2 y2  \D6\D6\C0\E0\B4\FA\C2\EB  Ŀ\B1\EA\CA\FD\C1\BF   Ŀ\B1\EA\D7\F8\B1\EA
	  string path = year; path = path + '/'; path = path + month; path = path + '/'; path = path + day; path = path + '/'; path = path + idtime; path = path + ".jpg";
	  wpath = wpath + path;
	  upath = upath + path;
	  ymd = year + "-"; ymd = ymd + month; ymd = ymd + "-"; ymd = ymd + day; ymd = ymd + " "; ymd = ymd + shi; ymd = ymd + ":"; ymd = ymd + fen; ymd = ymd + ":"; ymd = ymd + miao;

	  if (flag == 1) {
		  s = s.assign(s, 1, string::npos);
		  /*\CA\FD\BEݿ\E2\B2\D9\D7\F7\B4\FA\C2\EB



		  */
		  //idtime,id,wpath,s
		  //f1<<idtime<<" "<<id<<" "<<ymd<<" "<<time<<" "<<year<<" "<<month<<" "<<day<<" "<<sfm<<" "<<wpath<<" "<<upath<<" "<<s<<std::endl;
		  f2 << idtime << std::endl;
		  f2 << id << std::endl;
		  f2 << ymd << std::endl;
		  f2 << wpath << std::endl;
		  f2 << s << std::endl;
		  //数据写入数据库
		  string str = "INSERT INTO HY_SPJK_CNN_BJXXB(BJBH,SXTBH,CLBJ,SJ,JTLJ,JCXX) VALUES('" + idtime + "','" + id + "','" + '0' + "'," + "to_date('" + ymd + "','yyyy/mm/dd_hh24:mi:ss')" + ",'" + wpath + "','" + s + "')";
		 // string str = "INSERT INTO HY_SPJK_CNN_BJXXB(BJBH,SXTBH,CLBJ,SJ,JTLJ,JCXX,FWQIP) VALUES('" + idtime + "','" + id + "','" + '0' + "'," + "to_date('" + ymd + "','yyyy/mm/dd_hh24:mi:ss')" + ",'" + wpath + "','" + s + "','10.67.185.117')";

		  //out << str << std::endl;
		  char *camIdChar = new char[str.size() + 1];
		  const char * mystr = str.c_str();
		  strcpy(camIdChar, mystr);
		  
		  //insert into HY_SPJK_CNN_BJXXB values('idtime','id','0','ymd','wpath','s');
		  
		  TCHAR *szSelect1 = camIdChar;
		  retcode = SQLExecDirect(hstmt1, (SQLCHAR*)szSelect1, SQL_NTS);
		  //out << szSelect1 << std::endl;
		  //string str="INSERT INTO HY_SPJK_CNN_BJXXB(BJBH,SXTBH,CLBJ,SJ,JTLJ,JCXX) VALUES('" + idtime + "','" + id + "','" + '0' + "'," + "to_date('" + ymd + "','yyyy/mm/dd_hh24:mi:ss')" + ",'" + wpath + "','" + s + "')"
		  //retcode = SQLExecDirect(hstmt1, (SQLCHAR*)"insert into HY_SPJK_CNN_BJXXBBF(BJBH,SXTBH,CLBJ,JTLJ,JCXX) values('160_20170718121212','160','0','wpath','s')", SQL_NTS);
		  if (retcode<0)
		  {
			  out << "insert errors." << std::endl;
			  return -1;
		  }
		  //system("/home/ubuntu/caffe/examples/ssd/test");
		  //out<<file<<std::endl;
		  std::ifstream in;
		  std::ofstream out;
		  char inpath[1000], outpath[1000];
		  strcpy(inpath, file.c_str());
		  strcpy(outpath, upath.c_str());
		  //string infile;
		  //stringstream ss;
		  //ss.str("");
		  //ss<<file;
		  //infile=ss.str();
		  //in.open("/home/xxzx/1.jpg",ios::binary);//open source file
		  //in.open("/home/xxzx/caffe/data/xxzx_test/海工大队码头_20170620203248_6332_16F34780_14979619684.jpg",ios::binary);
		  in.open(inpath, ios::binary);	//\B4\F2\BF\AAĿ\B1\EA·\BE\B6\CEļ\FE
		  if (in.fail())//open source failed
		  {
			  out << "Error 1: Fail to open the source file." << std::endl;
			  in.close();
			  out.close();
			  return 0;
		  }
		  out.open(outpath, ios::binary);  //\BD\AB\B4?\C4\CEļ\FEת\B4浽ָ\B6\A8Ŀ¼
		  //out.open("/home/xxzx/Share/warning/2017/06/20/海工大队码头_20170620203300.jpg",ios::binary);//build target file 
		  //out.open(upath,ios::binary);
		  if (out.fail())//build file failed
		  {
			  out << "Error 2: Fail to create the new file." << std::endl;
			  out.close();
			  in.close();
			  return 0;
		  }
		  out << in.rdbuf();
		  out.close();
		  in.close();
	  }
	  //f1.close();  
	  f2.close();
//
//      /* Print the detection results. */
	  pos.clear();
//      for (int i = 0; i < detections.size(); ++i) 
//	  {
//        const vector<float>& d = detections[i];
//        // Detection format: [image_id, label, score, xmin, ymin, xmax, ymax].
//        CHECK_EQ(d.size(), 7);
//        const float score = d[2];
//        if (score >= confidence_threshold) 
//		{
//          out << file << " ";
//          out << static_cast<int>(d[1]) << " ";
//          out << score << " ";
//          out << static_cast<int>(d[3] * img.cols) << " ";
//          out << static_cast<int>(d[4] * img.rows) << " ";
//          out << static_cast<int>(d[5] * img.cols) << " ";
//          out << static_cast<int>(d[6] * img.rows) << std::endl;
//		  int posx = static_cast<int>(d[3] * img.cols);
//		  int posy = static_cast<int>(d[4] * img.rows);
//		  int posw = static_cast<int>(d[5] * img.cols) - posx;
//		  int posh = static_cast<int>(d[6] * img.rows) - posy;
//		  cv::Rect pos(posx,posy,posw,posh);
//		  cv::rectangle(img, pos, cv::Scalar(255, 0, 0));
//		  cv::imshow("result", img);
//		  cv::waitKey(0);
//        }
//      }
    } else if (file_type == "video") {
      cv::VideoCapture cap(file);
      if (!cap.isOpened()) {
        LOG(FATAL) << "Failed to open video: " << file;
      }
      cv::Mat img;
      int frame_count = 0;
      while (true) {
        bool success = cap.read(img);
        if (!success) {
          LOG(INFO) << "Process " << frame_count << " frames from " << file;
          break;
        }
        CHECK(!img.empty()) << "Error when read frame";
        std::vector<vector<float> > detections = detector.Detect(img);

        /* Print the detection results. */
        for (int i = 0; i < detections.size(); ++i) {
          const vector<float>& d = detections[i];
          // Detection format: [image_id, label, score, xmin, ymin, xmax, ymax].
          CHECK_EQ(d.size(), 7);
          const float score = d[2];
          if (score >= confidence_threshold) {
            out << file << "_";
            out << std::setfill('0') << std::setw(6) << frame_count << " ";
            out << static_cast<int>(d[1]) << " ";
            out << score << " ";
            out << static_cast<int>(d[3] * img.cols) << " ";
            out << static_cast<int>(d[4] * img.rows) << " ";
            out << static_cast<int>(d[5] * img.cols) << " ";
            out << static_cast<int>(d[6] * img.rows) << std::endl;
          }
        }
        ++frame_count;
      }
      if (cap.isOpened()) {
        cap.release();
      }
    } else {
      LOG(FATAL) << "Unknown file_type: " << file_type;
    }
  }
  /* Clean up.*/
  SQLFreeHandle(SQL_HANDLE_STMT, hstmt1);
  SQLDisconnect(hdbc1);
  SQLFreeHandle(SQL_HANDLE_DBC, hdbc1);
  SQLFreeHandle(SQL_HANDLE_ENV, henv);
  return(0);
  return 0;
}

2、然后编译caffe，形成classification.exe可执行文件，还有关于连接数据库部分稍后补充，有点急事

秦始皇的天下
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用于目标检测的 MobileNet-SSD 模型架构及权重文件(使用 Caffe 框架进行预训练)
09-30
在SSD中，网络会直接预测不同尺度和纵横比的框，以覆盖不同大小的目标。同时，SSD还采用了多尺度特征层来检测不同大小的目标，这样可以兼顾小目标和大目标的检测精度。 本压缩包提供的MobileNet-SSD模型是基于Caffe...
数据库连接池
挽不了风丶的博客
12-24 324
# pip3 install DBUtils from DBUtils.PooledDB import PooledDB import pymysql ''' 数据库连接池 ''' POOL = PooledDB( creator=pymysql, # 使用链接数据库的模块 maxconnections=6, # 连接池允许的最大连接数，0和None表示不限制连接数 ...
对SSD计算mAP的过程进行详解，按要介绍！
页页读
10-29 3338
完整代码见最后！ 一、（test_net函数） 对测试img进行推断并保存测试后的结果 首先是先将测试数据集送入net进行推断出来detections，存入det_file为pickle文件，这是为了再次评测的时候，如果网络没变的话就直接从pickle中取出上次推断的结果进行评测就好了。 代码： def test_net(save_folder, net, cuda, dataset,...
C# OpenCvSharp+ 微信二维码引擎实现二维码识别
最新发布
.NET 人工智能实践
05-31 2247
微信开源了其二维码的解码功能，并贡献给 OpenCV 社区。其开源的 wechat_qrcode 项目被收录到 OpenCV contrib 项目中。从 OpenCV 4.5.2 版本开始，就可以直接使用。微信的扫码引擎，很早就支持了远距离二维码检测、自动调焦定位、多码检测识别等功能，它是基于 CNN 的二维码检测。OpenCvSharp在 4.6.0.20220608 版本也加入了支持。
目标检测画图显示图
无左无右的博客
06-17 2213
这是我见过最好的代码了，摘录自u版本的yolov3里面的。 首先看画出的效果图： 每个类用不同颜色框，上面写出类别和分数这些信息，并且是填充。字体大小能够根据图片大小自动调整。 def plot_one_box(x, img, color=None, label=None, line_thickness=None): # Plots one bounding box on image i...
基于caffe框架深度学习的物体识别源码
09-09
本项目是基于Caffe框架实现的物体识别系统，尤其针对超市中的水果和蔬菜进行自动识别，适用于提升自助秤重的智能化水平。Caffe是一个高效、开源的深度学习库，由加州大学伯克利分校开发，它在速度和精度之间取得了很...
caffe_ssd_人脸识别描述文件以及模型.zip
08-04
标题中的“caffe_ssd_人脸识别描述文件以及模型.zip”表明这是一个关于使用Caffe深度学习框架实现的SSD（Single Shot Multibox Detector）模型，用于人脸识别的任务。SSD是一种高效的物体检测算法，它在单个神经网络...
目标检测算法SSD运行代码caffe
09-27
例如，在Caffe-SSD中，可能会从VGG16的最后几层开始，添加一些新的卷积层用于不同尺度和比例的特征提取。 2. **多尺度预测**：SSD的关键创新在于其多尺度预测机制。每个卷积层都会输出一组固定大小的“锚框”...
SSD图像目标检测Caffe模型
04-29
SSD图像目标检测VGG16网络模型,用于图像预处理,该模型使用atrous算法.
C++流 rdbuf()以及seekg()/seekp()与tellg()/tellp()的用法详解
热门推荐
Guo_guo
04-17 1万+
我们使用STL编程的时候有时候会想到把一个流对象指向的内容用另一个流对象来输出，比如想把一个文件的内容输出到显示器上，我们可以用简单的两行代码就可以完成。 ifstream infile("test.txt"); cout 上面的代码就把infile流对象中的流重定向到标准输出cout上，您可以在屏幕上看到test.txt的内容。 下面的例子来自MSDN，清晰的描述了rdbuf函
SSD使用笔记——ssd_detect.cpp的使用以及自动标注的实现
Gotta-C的博客
05-29 2849
1.编译ssd-caffe，在.build/examples/ssd/下生成ssd_detect.bin 查看ssd_detect.cpp参数，输入测试网络，测试模型，图片/视频列表，文件类型（图像/视频），阈值。输出带有检测坐标信息的文本。 // This is a demo code for using a SSD model to do detection. // The code i...
人脸检测之FaceBoxes
年轻即出发，
01-21 3926
  出自李子青老师组的作品，FaceBoxes: A CPU Real-time Face Detector with High Accuracy   文章整体创新分为3个部分： (1)RDCL模块 在这个模块中，卷积的滑动步长是很大，属于比较稀疏的滑动卷积。其中conv1滑动步长为4，使得feature map缩小1/4，conv2使得滑动步长为2，使得feature map缩小1...
mysql检测写入_tensorflow利用预训练模型进行目标检测（三）：将检测结果存入mysql数据库...
weixin_28756413的博客
01-18 288
#!usr/bin/python#-*- coding: utf-8 -*-importnumpy as npimportmatplotlibmatplotlib.use('Agg')importmatplotlib.pyplotfrom matplotlib importpyplot as pltimportosimporttensorflow as tffrom PIL importImage...
caffe目标分类和SSD网络目标识别运行c++实例
同学醒醒放学了
07-21 2555
本文主要说明如何通过C++接口实现ssd多目标识别的演示。  1.前期准备工作   预先安装，编译caffe，具体可以参考https://blog.csdn.net/u012986684/article/details/72469542。此篇文章有详细的安装编译教程。 2.编译遇到问题   在编译过程中，总会出现这样或者那样的问题。推荐两篇教程帮助大家解决问题。https://blog.c...
caffe windows10 ssd配置
d408550969的博客
05-15 3347
主要都是根据这篇文章配置的http://blog.csdn.net/muwu5635/article/details/60874721 说一下我碰到的问题。 文章里说到：复制data\VOC0712的create_data.bat到caffe根目录下，修改如下root_dir，但是貌似没有给出具体怎么写。 本人有点懒，直接将代码贴出来 @Echo off Echo caffe cre
tensorflow利用预训练模型进行目标检测（三）：将检测结果存入mysql数据库
weixin_34259232的博客
11-28 554
mysql版本：5.7 ； 数据库：rdshare；表captain_america3_sd用来记录某帧是否被检测。表captain_america3_d用来记录检测到的数据。 python模块，包部分内容参考http://www.runoob.com/python/python-modules.htmlhttps://www.cnblogs.com/ningskyer/articles/6...
Caffe深度学习框架官方教程中文详解
在Caffe框架中，Blobs是数据和中间结果的主要载体，负责存储和交换信息。Blob的实现细节涉及到内存管理和多线程优化。Layers是模型的核心部分，它们执行特定的计算任务并连接Blobs，形成神经网络的结构。Layers包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值