GOTURN(Generic Object Tracking Using Regression Networks　ＥＣＣＶ２０１６)

最新推荐文章于 2022-03-08 22:00:00 发布
最新推荐文章于 2022-03-08 22:00:00 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： GOTURN caffe C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012235274/article/details/52239318
版权
caffe 同时被 3 个专栏收录
29 篇文章 0 订阅
订阅专栏
C++
23 篇文章 0 订阅
订阅专栏
GOTURN
1 篇文章 0 订阅
订阅专栏

This tracker is able to track objects at 100 fps. This real-time speed is due to two factors.
First, most previous neural network trackers are trained online. However, training neural networks is a slow process, leading to slow tracking. In contrast, our tracker is trained offline to learn a generic relationship between appearance and motion, so no online training is required.
Second, most trackers take a classification-based approah, classifying many image patches to find the target object. In contrast, this tracker used a regression-based approach, requiring just a single feed-forward pass through the network to regresses directly to the location of the target object.
The combination of offline training and one-pass regression leads to a significant speed-up compared to previous approaches and allows it to track objects at real-time speeds.

下面这个是ｔｒａｉｎ使用的网络，跟ｄｅｐｌｏｙ有点不一样哦。
这里写图片描述

这里写图片描述

自己根据这个模型和网络实现的ｔｅｓｔ过程，使用的是ｖｏｔ２０１４的数据库进行的测试，在测试过程中，在序列检测的过程中使用除第一帧（使用ｇｏｕｎｄｉｎｇ　ｔｒｕｔｈ）外，其他都是使用前一帧的结果进行ｔａｒｇｅｔ的获取，这使用过程中，发现，ＧＯＴＵＲＮ回出现当相似的物体相遇之后，跟踪有时候回出现跳转到另外一个物体（分析：可以是在序列过程中误差的叠加造成ｆｏｒｗａｒｄ时候的ｔａｒｇｅｔ一些偏差导致跟踪错误），还有，对于可形变物体跟踪效果也不好。(使用的时候要注意，输出的结果要除以１０，才是得到的是左上角，和右下角相对于ｐａｔｃｈ的位置)。

#include <string>
#include <vector>

#include "boost/algorithm/string.hpp"
#include "google/protobuf/text_format.h"
#include <opencv2/opencv.hpp>

#include "caffe/blob.hpp"
#include "caffe/layer.hpp"
#include "caffe/common.hpp"
#include "caffe/net.hpp"
#include "caffe/proto/caffe.pb.h"
#include "caffe/util/db.hpp"
#include "caffe/util/format.hpp"
#include "caffe/util/io.hpp"
#include <stdio.h>
#include <malloc.h>
#include <fstream>
#include <boost/progress.hpp>
#include <fstream>
#include <stdio.h>


#include <boost/math/special_functions/next.hpp>
#include <boost/random.hpp>

#include <limits>

#include "caffe/common.hpp"
#include "caffe/util/math_functions.hpp"
#include "caffe/util/rng.hpp"


//#include "caffe/util/math_functions.hpp"

using caffe::Blob;
using caffe::Caffe;
using caffe::Datum;
using caffe::Net;
using caffe::Layer;
using std::string;
namespace db = caffe::db;

void loaddata_target(boost::shared_ptr<Net<float> >& net, std::string image_path);
void loaddata_image(boost::shared_ptr<Net<float> >& net, std::string image_path);

void loaddata_target(boost::shared_ptr<Net<float> >& net, cv::Mat image);
void loaddata_image(boost::shared_ptr<Net<float> >& net, cv::Mat image);

//int lap(int x1_min,int x1_max,int x2_min,int x2_max);
int main(int argc, char** argv){
  Caffe::set_mode(Caffe::GPU);
  boost::shared_ptr<Net<float> > net(new Net<float>(argv[1], caffe::TEST));
  net->CopyTrainedLayersFromBinaryProto(argv[2]);

  //argv[3]表示的是包含pictures的文件夹
  cv::Mat target, image;
  cv::Mat pre_image, cur_image;
  cv::Point point1, point2;
  float coord;
  char* filepath = new char[100];
  std::ifstream in;//;(string(string(argv[3])));
  sprintf(filepath, "%s/groundtruth.txt",argv[3]);
  in.open(filepath);
  delete [] filepath;
  in >> coord;
  in >> coord;
  in >> coord;
  point1.x = int(coord);
  in >> coord;
  point1.y = int(coord);
  in >> coord;
  in >> coord;
  in >> coord;
  point2.x = int(coord);
  in >> coord;
  point2.y = int(coord);
  in.close();

  char* image_path = new char[100];
  int count = 1;
  int cols,rows;
  int w,h;
  while(1){
      //std::cout << point1 << " " << point2 << std::endl;
      sprintf(image_path,"%s/%.8d.jpg",argv[3],count++);
      pre_image = cv::imread(image_path);
      //std::cout << image_path << std::endl;

      sprintf(image_path,"%s/%.8d.jpg",argv[3],count++);
      cur_image = cv::imread(image_path);

      cols = cur_image.cols;
      rows = cur_image.rows;

      if(cols == 0 || rows == 0) break;

      w = point2.x - point1.x;
      h = point2.y - point1.y;

      //std::cout << w <<" h=" << h << std::endl;

      point1.x = point1.x - w/2;
      point1.y = point1.y - h/2;
      point2.x = point2.x + w/2;
      point2.y = point2.y + h/2;

      //std::cout << point1 << " " << point2 << std::endl;

      point1.x = point1.x < 0 ? 0 : point1.x;
      point1.y = point1.y < 0 ? 0 : point1.y;
      point2.x = point2.x > cols ? cols : point2.x;
      point2.y = point2.y > rows ? rows : point2.y;

     // std::cout << point1 << " " << point2 << std::endl;

      target = pre_image(cv::Rect(point1,point2));
      image  = cur_image(cv::Rect(point1,point2));

      loaddata_target(net,target);
      loaddata_image(net,image);
      net->Forward();

      Blob<float>* output_layer = net->output_blobs()[0];
      std::vector<int> points;
      points.push_back(int(image.cols*((output_layer->cpu_data()[0]/10))));
      points.push_back(int(image.rows*((output_layer->cpu_data()[1]/10))));
      points.push_back(int(image.cols*((output_layer->cpu_data()[2]/10))));
      points.push_back(int(image.rows*((output_layer->cpu_data()[3]/10))));

      point2.x = point1.x + points[2];
      point2.y = point1.y+ points[3];
      point1.x  += points[0];
      point1.y  += points[1];

      cv::rectangle(cur_image, cv::Rect(point1,point2),cv::Scalar(0,225,255),1);

      cv::imshow("target",target);

      cv::imshow("image",cur_image);
      if(count == 3)
          cv::waitKey(0);
      cv::waitKey(33);


      //std::cout << image_path << std::endl;
      //target = pre_image();
     // break;
  }
  delete [] image_path;
  return 1;
}

void loaddata_target(boost::shared_ptr<Net<float> >& net, std::string image_path){
  Blob<float>* input_layer = net->input_blobs()[0];
  int width, height;
  width = input_layer->width();
  height = input_layer->height();
  int size = width*height;
  cv::Mat image = cv::imread(image_path,-1);
  cv::Mat image_resized;
  cv::resize(image, image_resized, cv::Size(height, width));
  float* input_data = input_layer->mutable_cpu_data();
  int temp,idx;
  for(int i = 0; i < height; ++i){
    uchar* pdata = image_resized.ptr<uchar>(i);
    for(int j = 0; j < width; ++j){
      temp = 3*j;
      idx = i*width+j;
      input_data[idx] = (pdata[temp+2]);
      input_data[idx+size] = (pdata[temp+1]);
      input_data[idx+2*size] = (pdata[temp+0]);
    }
  }
  //cv::imshow("image",image_resized);
}

void loaddata_image(boost::shared_ptr<Net<float> >& net, std::string image_path){
  Blob<float>* input_layer = net->input_blobs()[1];
  int width, height;
  width = input_layer->width();
  height = input_layer->height();
  int size = width*height;
  cv::Mat image = cv::imread(image_path,-1);
  cv::Mat image_resized;
  cv::resize(image, image_resized, cv::Size(height, width));
  float* input_data = input_layer->mutable_cpu_data();
  int temp,idx;
  for(int i = 0; i < height; ++i){
    uchar* pdata = image_resized.ptr<uchar>(i);
    for(int j = 0; j < width; ++j){
      temp = 3*j;
      idx = i*width+j;
      input_data[idx] = (pdata[temp+2]);
      input_data[idx+size] = (pdata[temp+1]);
      input_data[idx+2*size] = (pdata[temp+0]);
    }
  }
  //cv::waitKey(0);
  //cv::imshow("image",image_resized);
}

void loaddata_target(boost::shared_ptr<Net<float> >& net, cv::Mat image){
  Blob<float>* input_layer = net->input_blobs()[0];
  int width, height;
  width = input_layer->width();
  height = input_layer->height();
  int size = width*height;
  //cv::Mat image = cv::imread(image_path,-1);
  cv::Mat image_resized;
  cv::resize(image, image_resized, cv::Size(height, width));
  float* input_data = input_layer->mutable_cpu_data();
  int temp,idx;
  for(int i = 0; i < height; ++i){
    uchar* pdata = image_resized.ptr<uchar>(i);
    for(int j = 0; j < width; ++j){
      temp = 3*j;
      idx = i*width+j;
      input_data[idx] = (pdata[temp+2])-104;
      input_data[idx+size] = (pdata[temp+1])-117;
      input_data[idx+2*size] = (pdata[temp+0])-123;
    }
  }
  //cv::imshow("image",image_resized);
}

void loaddata_image(boost::shared_ptr<Net<float> >& net, cv::Mat image){
  Blob<float>* input_layer = net->input_blobs()[1];
  int width, height;
  width = input_layer->width();
  height = input_layer->height();
  int size = width*height;
  //cv::Mat image = cv::imread(image_path,-1);
  cv::Mat image_resized;
  cv::resize(image, image_resized, cv::Size(height, width));
  float* input_data = input_layer->mutable_cpu_data();
  int temp,idx;
  for(int i = 0; i < height; ++i){
    uchar* pdata = image_resized.ptr<uchar>(i);
    for(int j = 0; j < width; ++j){
      temp = 3*j;
      idx = i*width+j;
      input_data[idx] = (pdata[temp+2])-104;
      input_data[idx+size] = (pdata[temp+1])-117;
      input_data[idx+2*size] = (pdata[temp+0])-123;
    }
  }
  //cv::waitKey(0);
  //cv::imshow("image",image_resized);
}

ｄｅｐｌｏｙ.prototxt

name: "CaffeNet"

input: "target"
input: "image"

#target
input_dim: 1
input_dim: 3
input_dim: 227
input_dim: 227

#image
input_dim: 1
input_dim: 3
input_dim: 227
input_dim: 227

layer {
  name: "conv1" type: "Convolution" bottom: "target" top: "conv1" param { lr_mult: 0 decay_mult: 1 }
  param {
    lr_mult: 0 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: 0 decay_mult: 1 }
  param {
    lr_mult: 0 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: 0 decay_mult: 1 }
  param {
    lr_mult: 0 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: 0 decay_mult: 1 }
  param {
    lr_mult: 0 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: 0 decay_mult: 1 }
  param {
    lr_mult: 0 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: "conv1_p" type: "Convolution" bottom: "image" top: "conv1_p" param { lr_mult: 0 decay_mult: 1 }
  param {
    lr_mult: 0 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_p" type: "ReLU" bottom: "conv1_p" top: "conv1_p" }
layer {
  name: "pool1_p" type: "Pooling" bottom: "conv1_p" top: "pool1_p" pooling_param { pool: MAX kernel_size: 3 stride: 2 }
}
layer {
  name: "norm1_p" type: "LRN" bottom: "pool1_p" top: "norm1_p" lrn_param { local_size: 5 alpha: 0.0001 beta: 0.75 }
}
layer {
  name: "conv2_p" type: "Convolution" bottom: "norm1_p" top: "conv2_p" param { lr_mult: 0 decay_mult: 1 }
  param {
    lr_mult: 0 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_p" type: "ReLU" bottom: "conv2_p" top: "conv2_p" }
layer {
  name: "pool2_p" type: "Pooling" bottom: "conv2_p" top: "pool2_p" pooling_param { pool: MAX kernel_size: 3 stride: 2 }
}
layer {
  name: "norm2_p" type: "LRN" bottom: "pool2_p" top: "norm2_p" lrn_param { local_size: 5 alpha: 0.0001 beta: 0.75 }
}
layer {
  name: "conv3_p" type: "Convolution" bottom: "norm2_p" top: "conv3_p" param { lr_mult: 0 decay_mult: 1 }
  param {
    lr_mult: 0 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_p" type: "ReLU" bottom: "conv3_p" top: "conv3_p" }
layer {
  name: "conv4_p" type: "Convolution" bottom: "conv3_p" top: "conv4_p" param { lr_mult: 0 decay_mult: 1 }
  param {
    lr_mult: 0 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_p" type: "ReLU" bottom: "conv4_p" top: "conv4_p" }
layer {
  name: "conv5_p" type: "Convolution" bottom: "conv4_p" top: "conv5_p" param { lr_mult: 0 decay_mult: 1 }
  param {
    lr_mult: 0 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_p" type: "ReLU" bottom: "conv5_p" top: "conv5_p" }
layer {
  name: "pool5_p" type: "Pooling" bottom: "conv5_p" top: "pool5_p" pooling_param { pool: MAX kernel_size: 3 stride: 2 }
}

layer {
  name: "concat" type: "Concat" bottom: "pool5" bottom: "pool5_p" top: "pool5_concat" concat_param { axis: 1 }
}

layer {
  name: "fc6-new" type: "InnerProduct" bottom: "pool5_concat" top: "fc6" param { lr_mult: 10 decay_mult: 1 }
  param {
    lr_mult: 20 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-new" type: "InnerProduct" bottom: "fc6" top: "fc7" param { lr_mult: 10 decay_mult: 1 }
  param {
    lr_mult: 20 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: "fc7-newb" type: "InnerProduct" bottom: "fc7" top: "fc7b" param { lr_mult: 10 decay_mult: 1 }
  param {
    lr_mult: 20 decay_mult: 0 }
  inner_product_param {
    num_output: 4096 weight_filler { type: "gaussian" std: 0.005 }
    bias_filler {
      type: "constant" value: 1 }
  }
}
layer {
  name: "relu7b" type: "ReLU" bottom: "fc7b" top: "fc7b" }
layer {
  name: "drop7b" type: "Dropout" bottom: "fc7b" top: "fc7b" dropout_param { dropout_ratio: 0.5 }
}


layer {
  name: "fc8-shapes" type: "InnerProduct" bottom: "fc7b" top: "fc8" param { lr_mult: 10 decay_mult: 1 }
  param {
    lr_mult: 20 decay_mult: 0 }
  inner_product_param {
    num_output: 4 weight_filler { type: "gaussian" std: 0.01 }
    bias_filler {
      type: "constant" value: 0 }
  }
}
小_小_杨_
关注
专栏目录
计算机视觉论文总结系列（一）：目标检测篇
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
03-23 8442
本系列主要面向计算机视觉目标检测、图像分割及OCR等领域，每篇将对该领域论文等方面展开介绍，本篇主要介绍目标检测领域历年论文，希望大家能够多多交流如有错误请大家在评论区指正，如有侵权联系删除
ECCV 2012 List of accepted papers
热门推荐
xdyang的图像视觉小屋
07-04 2万+
Oral presentation  oral出来了，只有40篇文章，录取率只有大概2.3%。先Mark一下，等出来后选感兴趣的看几篇 Paper id Paper title Author names 13 Diverse M-Best Solutions in Markov Random Fields Dhruv Batra*, Toyota Techno
GOTURN: Generic Object Tracking Using Regression Networks
成长Bar的博客专栏
04-05 1763
GOTURN: Generic Object Tracking Using Regression Networks        GOTURN是一种深度视觉跟踪算法，速度可以达到惊人的100fps，GOTURN是2016年ECCV上的文章。        参考源码：https://github.com/autocyz/GOTURN        文章地址：http://davheld.github
GOTURN模型文件
08-13
goturn追踪算法的caffe模型文件，官网下载速度过慢，所以放过来备用。
goturn.caffemodel.zip.001
05-09
GOTURN is much faster due to offline training without online fine-tuning nature.
GOTURN
Major_S的博客
03-03 393
GOTURN
GOTURN-(达到100FPS的深度学习跟踪算法代码)
godloveme的专栏
02-20 3390
本代码是基予caffe的linux的, 安装好caffe之后需要编译GOTURN代码,在编译过程中会出现如下错误: fatal error: caffe/proto/caffe.pb.h: No such file or directory #include "caffe/proto/caffe.pb.h" 解决方法： 用protoc从caffe/src/caffe/proto/caf
计算机视觉之目标跟踪——论文Learning to Track at 100 FPS with Deep Regression Networks
CodeTutor
03-13 1824
论文解读 模型 输入 输出 模型结构 训练 motion model 训练数据 实现 说明 源码解读 srchelper文件夹 bounding_boxcpp image_proccpp srctrain文件夹 example_generatorcpp tracker_trainercpp traincppLearning to Track at 100 FPS with Deep Regressi
目标跟踪CVPR,ICCV,ECCV会议年度论文2018
yuuzhao的博客
05-22 3245
CVPR 2018 Paper arXiv下载链接：http://openaccess.thecvf.com/CVPR2018.py Track检索相关论文： GANerated Hands for Real-Time 3D Hand Tracking From Monocular RGB Detect-and-Track: Efficient Pose Estimation in Videos...
OpenCV中GOTURN模型压缩文件的合并
qq_34741911的博客
11-26 729
GOTURN模型的下载地址 https://github.com/opencv/opencv_extra/tree/c4219d5eb3105ed8e634278fad312a1a8d2c182d/testdata/tracking 有四压缩文件如下图 下载好后，需要将四个压缩文件合并为一个 合并方法：（我用的是winRAR解压缩工具）选择 goturn.caffemodel.zip....
DNN系列7_GOTURN模型实现视频对象跟踪
qq_32809093的博客
08-23 472
7 GOTURN模型实现视频对象跟踪  GOTURN(Generic Object Tracking Using Regression Networks)介绍  下载模型与使用 7.1 GOTURN算法介绍 7.2使用模型实现对象跟踪  编码处理 - 加载Caffem模型 - 使用模型预测 模型下载地址 实例7：GOTURN模型实现视频对象跟踪 #include <opencv2/opencv.hpp> #include <opencv2/dnn.hpp>.
GOTURN: Learning to Track at 100 FPS with Deep Regression Networks笔记
EdwarL's Blog
03-11 1399
2016年stanford David Held的作品，第一个用深度学习实现了100FPS的generic tracking任务的工作，因为offline而且是完全offline的（不做online的fine-tuning，在tracking新的object的时候，也并不改变network weights）。所以优点就是速度快，缺点是对于遮挡表现很差。1. Motivation 计算机视觉
目标检测安装：GOTURN安装
BigCowPeking
08-05 1169
1. Github https://github.com/davheld/GOTURN Introduction GOTURN addresses the problem of single target tracking: given a bounding box label of an object in the first frame of the video, we track th...
安装Goturn过程
anfly007的专栏
03-01 1350
最近读了Goturn的文章，决定重现一下。 首先正常安装，发现报错。 原来是要cmake安装caffe。 于是用cmake重新安装caffe。 cd caffe 报错does not appear to contain CMakeLists.txt 好吧，因为没有到源码目录。 cd caffe-master 然后按照这个教程：http://blog.csdn.net/u0
【深度学习系列4】复现pygoturn（包含安装opencv）
m0_37668446的博客
08-16 355
1 github下载需要该项目源代码 //git clone + github远程仓库地址 git clone https://github.com/amoudgl/pygoturn 嫌弃麻烦的小伙伴直接下载我上传的资料 2额外环境 还差几个分别装一下（先得进虚拟环境参考之前的博客） conda install numpy=1.14.5 conda install opencv-python==4.0.0.21 conda install tensorboardX=1.6 ...
论文笔记（一） GOTURN
huangpiao
07-03 4606
一.算法原理        GOTURN（Generic Object Tracking Using Regression Networks）这个算法没有过多的图像处理过程，主要是利用了卷积神经网络的特性进行学习。其中网络的结构类似于孪生网络（Siamese Network），采用两输入的方式。通过输入前后两幅图像，输出目标的窗口（左上角坐标和右下角坐标）。     假设目标窗口的长宽分别是w
【论文】Know Your Surroundings: Exploiting Scene Information for Object Tracking -2020
green hand的博客
12-23 928
Abstract 目前最先进的跟踪器只依赖于目标外观模型来定位每个帧中的对象。然而，在出现例如快速的外观变化或存在干扰器对象的情况下，这种方法很容易失败，因为仅有目标外观模型不足以进行鲁棒跟踪。 在这种情况下，了解周围场景中其他物体的存在和位置是非常有益的。 这些场景信息可以通过序列传播，例如，可以显式地避免干扰对象并消除目标候选区域。 在本文中，我们提出了一种新的跟踪体系结构，它可以利用场景信息进行跟踪。 我们的跟踪器表示密集的局部状态向量等信息，例如，如果局部区域是目标、背景或干扰器，则可以进...
目标跟踪（2）GOTURN:基于深度学习的目标跟踪
weixin_43229348的博客
03-08 2674
在这篇文章中，我们将了解一种名为 GOTURN 的基于深度学习的对象跟踪算法。 GOTURN 的原始实现是在 Caffe 中，但它已被移植到 OpenCV 跟踪 API，我们将使用这个 API 在 C++ 和 Python 中演示 GOTURN。 1. 什么是目标跟踪? 对象跟踪的目标是跟踪视频序列中的对象。使用视频序列的帧和边界框来初始化跟踪算法，以指示我们感兴趣跟踪的对象的位置。跟踪算法为所有后续帧输出一个边界框。 2. 什么是GOTURN? GOTURN 是 Generic Object Tracki
【目标跟踪】Learning to Track at 100 FPS with Deep Regression Networks 学习
书侠
06-02 8047
这篇文章是斯坦福大学2016年4月发的，文中提出了一种通过离线训练带标签的视频来更有效跟踪目标物体的方法。以前的深度学习用来做跟踪的算法都比较慢，这一论文的跟踪器使用了简单的前向传播而无需在线训练，测试时的跟踪帧率达到了100fps.由于在训练网络时既使用了带标签的视频，也使用了大量的图片，可以防止过拟合。跟踪器学习了泛化的运动特征，所以可以去跟踪训练集中没有出现的新物体。传统通用目标跟踪器（相对于特定目标跟踪器）
distractor-aware siamese networks for visual object tracking
最新发布
03-16
distractor-aware siamese networks for visual object tracking是一种用于视觉目标跟踪的模型，它能够识别并排除干扰物，提高跟踪的准确性。该模型采用孪生网络结构，通过学习目标和背景之间的相似性来进行跟踪。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值