精华内容
下载资源
问答
  • 【Caffe实践】 多目标输出探究

    万次阅读 2015-06-01 11:59:25
    Caffe 多目标输出

    正常的CNN,其输入是图像,其输出是一个label整数,其正是用Caffe的底层数据Datum(Image,LMDB,LevelDB的基础)来表示

    message Datum {
      optional int32 channels = 1;
      optional int32 height = 2;
      optional int32 width = 3;
      // the actual image data, in bytes
      optional bytes data = 4;
      optional int32 label = 5;
      // Optionally, the datum could also hold float data.
      repeated float float_data = 6;
      // If true data contains an encoded image that need to be decoded
      optional bool encoded = 7 [default = false];
    }

    当数据读入的时候,其是通过

    CVMatToDatum(cv_img, datum);
    datum->set_label(label);
    

    所以,Image输入,LevelDB输入,LMDB输入,不能解决多输出问题(改动代码,对其它代码的影响比较大)

    在HDF5作为输入中,其是接受多输出的,但其只能接受double和float的输入,但是我们的图像一般是0–255的,所以其实只要用int8 就可以满足了,可以节省4-8倍的空间。

    而hdf5只能是float和double的原因在于,其是直接将4维数组转化为blob数据结构。

      blob->Reshape(
        dims[0],
        (dims.size() > 1) ? dims[1] : 1,
        (dims.size() > 2) ? dims[2] : 1,
        (dims.size() > 3) ? dims[3] : 1);

    虽然Blob是一个模板,但是,其unsigned int 和int的类型都没有实现

    template <> void Blob<unsigned int>::Update() 
    { NOT_IMPLEMENTED; }
    template <> void Blob<int>::Update() 
    { NOT_IMPLEMENTED; }

    没有实现的原因,是因为输入数据和里面的所有的中间数据都采用相同的结构(Blob),所以如果用int来保存的化,就没有办法进行求梯度等操作。

    //The "update" method is used for parameter blobs in a Net, which are stored
    //as Blob<float> or Blob<double> -- hence we do not define it for
    //Blob<int> or Blob<unsigned int>.
    
    template <> unsigned int Blob<unsigned int>::asum_data() const 
    {
      NOT_IMPLEMENTED;
      return 0;
    }
    
    template <> int Blob<int>::asum_data() const 
    {
      NOT_IMPLEMENTED;
      return 0;
    }
    template <> unsigned int Blob<unsigned int>::asum_diff() const 
    {
      NOT_IMPLEMENTED;
      return 0;
    }
    
    template <> int Blob<int>::asum_diff() const 
    {
      NOT_IMPLEMENTED;
      return 0;
    }
    template <> unsigned int Blob<unsigned int>::sumsq_data() const 
    {
      NOT_IMPLEMENTED;
      return 0;
    }
    
    template <> int Blob<int>::sumsq_data() const 
    {
      NOT_IMPLEMENTED;
      return 0;
    }
    template <> unsigned int Blob<unsigned int>::sumsq_diff() const 
    {
      NOT_IMPLEMENTED;
      return 0;
    }
    
    template <> int Blob<int>::sumsq_diff() const 
    {
      NOT_IMPLEMENTED;
      return 0;
    }
    template <> void Blob<unsigned int>::scale_data(unsigned int scale_factor) 
    {
      NOT_IMPLEMENTED;
    }
    
    template <> void Blob<int>::scale_data(int scale_factor) 
    {
      NOT_IMPLEMENTED;
    }
    template <> void Blob<unsigned int>::scale_diff(unsigned int scale_factor) 
    {
      NOT_IMPLEMENTED;
    }
    
    template <> void Blob<int>::scale_diff(int scale_factor) 
    {
      NOT_IMPLEMENTED;
    }

    HDF5最大的缺点在于,因为其是直接将数据转化为Blob,所以其不能利用所有的DataTransformer功能,因为数据转换层又是基于Datum或者图像cv::Mat来转换.(最近加了直接对Blob的转换)
    解决方案:
    1. 自己添加一层DataBlob层来实现。
    2. 直接存储uint8格式,HDF5输入的时候,强制转化为float格式即可。

    展开全文
  • xgboost 使用 MAE或MAPE 作为目标函数

    千次阅读 2018-01-30 16:21:40
    xgboost目标函数 首先我们知道xgboost支持自定义目标函数,参见: ...但是其要求目标函数必须二阶可导,我们必须显式给出梯度(可理解为一阶导)和hess阵(可理解为二阶导),但是MAE可导。具体xgboost的原理的我

    xgboost目标函数

    首先我们知道xgboost支持自定义目标函数,参见:

    但是其要求目标函数必须二阶可导,我们必须显式给出梯度(可理解为一阶导)和hess阵(可理解为二阶导),但是MAE不可导。具体xgboost的原理的我们可以参见陈天奇的PPT或者此博客:

    使用可导目标函数逼近MAE

    损失函数示意图
    如上图所示,xgboost自带的平方损失,与MAE相距较远。比较接近的损失有Huber Loss 以及 Fair Loss。具体可参考:

    自定义近似MAE导数

    我们不必要限制在寻找逼近MAE损失函数,然后再使用逼近的导数这样的过程。我们可以直接构造MAE的导数。当然这个构造过程可能没有太多的理论支持,但是它的确work。参见:

    展开全文
  • 1、暴力操作:执行sql脚本(清空目标表数据)--> 表输入(获取源表数据)-->表输出(将源表数据插入到目标表中) 因为表输出可以不用指定数据库字段,因此实现需求,但太暴力,boss明确说明,这样可取。...
  • SORT 多目标跟踪算法笔记

    万次阅读 多人点赞 2019-04-21 15:20:46
    sort 是一种简单的在线实时多目标跟踪算法。文章要点为: ...所提方法以检测作为关键组件,传播目标状态到未来帧中,将当前检测与现有目标相关联,并管理跟踪目标的生命周期。 Detection 为从 ...

    SORT 是一种简单的在线实时多目标跟踪算法。文章要点为:

    • 以 IoU 作为前后帧间目标关系度量指标;
    • 利用卡尔曼滤波器预测当前位置;
    • 通过匈牙利算法关联检测框到目标;
    • 应用试探期甄别虚检;
    • 使用 Faster R-CNN,证明检测好跟踪可以很简单。

    技术方案

    SORT 算法以检测作为关键组件,传播目标状态到未来帧中,将当前检测与现有目标相关联,并管理跟踪目标的生命周期。

    检测

    跟踪框架使用 Faster R-CNN 并应用其在 PASCAL VOC 挑战中的默认参数,只输出概率大于50%的行人检测结果而忽略其他类。
    文章在实验中替换 MDP 和所提方法的检测,发现检测质量对跟踪性能有显著影响。在这里插入图片描述

    估计模型

    目标模型,即用于将目标身份传播到下一帧的表示和运动模型。SORT 算法用一个独立于其他物体和相机运动的线性等速模型来近似每个物体的帧间位移。每个目标的状态建模为:

    x = [ u , v , s , r , u ˙ , v ˙ , s ˙ ] T , \mathbf{x} = [u,v,s,r,\dot{u},\dot{v},\dot{s}]^T, x=[u,v,s,r,u˙,v˙,s˙]T,

    其中 u u u v v v 分别代表目标中心的水平和垂直像素位置,而 s s s r r r 分别代表目标边界框的比例(面积)和纵横比。注意,纵横比被认为是常数。关联检测到目标后,用检测到的边界框更新目标状态,其中速度分量通过卡尔曼滤波器框架进行优化求解。如果没有与目标相关的检测,则使用线性速度模型简单地预测其状态而不进行校正。

    数据关联

    在将检测分配给现有目标时:

    • 预测每个目标在当前帧中的新位置,估计其边界框形状;
    • 由每个检测与现有目标的所有预测边界框之间的交并比(IoU)计算分配成本矩阵;
    • 使用匈牙利算法对分配进行优化求解;
    • 拒绝检测与目标重叠小于 I O U m i n IOU_{min} IOUmin 的分配。

    文章发现边界框的 IoU 距离隐式处理由目标经过引起的短时遮挡。具体地说,当遮挡物盖过目标时,只检测到遮挡物。尽管隐藏目标离检测框中心更近,但 IoU 距离更倾向于具有相似比例的检测。这使得可以在不影响覆盖目标的情况下,通过检测对遮挡目标进行校正。

    创建和删除轨迹标识

    当目标进入和离开图像时,需要相应地创建或销毁唯一标识。对于创建跟踪程序,文中认为任何重叠小于 I o U m i n IoU_{min} IoUmin 的检测都表示存在未跟踪的目标。使用速度设置为零的边界框信息初始化跟踪器。由于此时无法观测到速度,因此速度分量的协方差用较大的值初始化,反映出这种不确定性。此外,新的跟踪器将经历一个试用期,其中目标需要与检测相关联以积累足够的证据以防止误报的跟踪。

    如果 T L o s t T_{Lost} TLost 帧未检测到,则终止轨迹。这可以防止跟踪器数量的无限增长以及由于无检测校正下预测时间过长而导致的定位错误。在所有实验中, T L o s t T_{Lost} TLost 设为1有以下原因:

    • 首先,等速模型对真实动力学的预测能力较差;
    • 其次,我们主要关注逐帧跟踪,目标重识别超出本工作范畴;
    • 此外,早期删除丢失的目标有助于提高效率。如果目标重新出现,跟踪将在新标识下隐式恢复。

    sort.py

    算法和程序都比较简单。程序依赖 scikit-learn 所提供的 linear_assignment 实现匈牙利匹配。KalmanFilterFilterPy 提供。

    matplotlib.pyplot.ion() 打开交互模式。

      # all train
      sequences = ['PETS09-S2L1','TUD-Campus','TUD-Stadtmitte','ETH-Bahnhof','ETH-Sunnyday','ETH-Pedcross2','KITTI-13','KITTI-17','ADL-Rundle-6','ADL-Rundle-8','Venice-2']
      args = parse_args()
      display = args.display
      phase = 'train'
      total_time = 0.0
      total_frames = 0
      colours = np.random.rand(32,3) #used only for display
      if(display):
        if not os.path.exists('mot_benchmark'):
          print('\n\tERROR: mot_benchmark link not found!\n\n    Create a symbolic link to the MOT benchmark\n    (https://motchallenge.net/data/2D_MOT_2015/#download). E.g.:\n\n    $ ln -s /path/to/MOT2015_challenge/2DMOT2015 mot_benchmark\n\n')
          exit()
        plt.ion()
        fig = plt.figure() 
      
      if not os.path.exists('output'):
        os.makedirs('output')
    

    对于每个序列,创建一个 SORT 跟踪器实例。
    加载序列的检测数据。检测框格式为[x1,y1,w,h]

      for seq in sequences:
        mot_tracker = Sort() #create instance of the SORT tracker
        seq_dets = np.loadtxt('data/%s/det.txt'%(seq),delimiter=',') #load detections
        with open('output/%s.txt'%(seq),'w') as out_file:
          print("Processing %s."%(seq))
          for frame in range(int(seq_dets[:,0].max())):
            frame += 1 #detection and frame numbers begin at 1
            dets = seq_dets[seq_dets[:,0]==frame,2:7]
            dets[:,2:4] += dets[:,0:2] #convert to [x1,y1,w,h] to [x1,y1,x2,y2]
            total_frames += 1
    

    skimage.io.imread 从文件加载图像。

            if(display):
              ax1 = fig.add_subplot(111, aspect='equal')
              fn = 'mot_benchmark/%s/%s/img1/%06d.jpg'%(phase,seq,frame)
              im =io.imread(fn)
              ax1.imshow(im)
              plt.title(seq+' Tracked Targets')
    

    update 由检测框更新轨迹。trackers命名有问题。

            start_time = time.time()
            trackers = mot_tracker.update(dets)
            cycle_time = time.time() - start_time
            total_time += cycle_time
    

    matplotlib.axes.Axes.add_patch 将补丁p添加到轴补丁列表中;剪辑框将设置为 Axes 剪切框。 如果未设置变换,则将其设置为 transData。返回补丁。
    matplotlib.axes.Axes.set_adjustable 定义 Axes 将更改哪个参数以实现给定面。

            for d in trackers:
              print('%d,%d,%.2f,%.2f,%.2f,%.2f,1,-1,-1,-1'%(frame,d[4],d[0],d[1],d[2]-d[0],d[3]-d[1]),file=out_file)
              if(display):
                d = d.astype(np.int32)
                ax1.add_patch(patches.Rectangle((d[0],d[1]),d[2]-d[0],d[3]-d[1],fill=False,lw=3,ec=colours[d[4]%32,:]))
                ax1.set_adjustable('box-forced')
    
            if(display):
              fig.canvas.flush_events()
              plt.draw()
              ax1.cla()
    
      print("Total Tracking took: %.3f for %d frames or %.1f FPS"%(total_time,total_frames,total_frames/total_time))
      if(display):
        print("Note: to get real runtime results run without the option: --display")
    

    Sort

    Sort 是一个多目标跟踪器,管理多个 KalmanBoxTracker 对象。

      def __init__(self,max_age=1,min_hits=3):
        """
        Sets key parameters for SORT
        """
        self.max_age = max_age
        self.min_hits = min_hits
        self.trackers = []
        self.frame_count = 0
    

    update

    参数dets:格式为[[x1,y1,x2,y2,score],[x1,y1,x2,y2,score],...]的 numpy 检测数组。
    要求:即使空检测,也必须为每个帧调用此方法一次。返回一个类似的数组,其中最后一列是对象 ID。

    注意:返回的对象数可能与提供的检测数不同。

    update 的输入参数dets为 numpy.array,然而 KalmanBoxTracker 要求的输入为列表。

    Created with Raphaël 2.2.0 update dets KalmanBoxTracker.predict associate_detections_to_trackers KalmanBoxTracker.update KalmanBoxTracker tracks End

    从现有跟踪器获取预测位置。
    predict 推进状态向量并返回预测的边界框估计。

    在当前帧逐个预测轨迹位置,记录状态异常的跟踪器索引。trks存储跟踪器的预测,不幸与下面的跟踪器重名。

        self.frame_count += 1
        #get predicted locations from existing trackers.
        trks = np.zeros((len(self.trackers),5))
        to_del = []
        ret = []
        for t,trk in enumerate(trks):
          pos = self.trackers[t].predict()[0]
          trk[:] = [pos[0], pos[1], pos[2], pos[3], 0]
          if(np.any(np.isnan(pos))):
            to_del.append(t)
    

    numpy.ma.masked_invalid 屏蔽出现无效值的数组(NaN 或 inf)。
    numpy.ma.compress_rows 压缩包含掩码值的2-D 数组的整行。这相当于np.ma.compress_rowcols(a, 0),有关详细信息,请参阅 extras.compress_rowcols
    reversed 返回反向 iterator. seq 必须是具有 __reversed__() 方法的对象,或者支持序列协议(__len__() 方法和 __getitem__() 方法,整数参数从0开始)。

    逆向删除异常的跟踪器,防止破坏索引。压缩能够保证在数组中的位置不变。
    associate_detections_to_trackers 将检测分配给跟踪对象(均以边界框表示)。返回3个列表:matchesunmatched_detectionsunmatched_trackers

        trks = np.ma.compress_rows(np.ma.masked_invalid(trks))
        for t in reversed(to_del):
          self.trackers.pop(t)
        matched, unmatched_dets, unmatched_trks = associate_detections_to_trackers(dets,trks)
    

    使用分配的检测更新匹配的跟踪器。为什么不通过matched存储的索引选择跟踪器?
    update 使用观测边界框更新状态向量。

        #update matched trackers with assigned detections
        for t,trk in enumerate(self.trackers):
          if(t not in unmatched_trks):
            d = matched[np.where(matched[:,1]==t)[0],0]
            trk.update(dets[d,:][0])
    

    由未匹配的检测创建和初始化新的跟踪器。

        #create and initialise new trackers for unmatched detections
        for i in unmatched_dets:
            trk = KalmanBoxTracker(dets[i,:]) 
            self.trackers.append(trk)
    

    get_state 返回当前边界框估计值。
    ret格式为[[x1,y1,x2,y2,score],[x1,y1,x2,y2,score],...]

    自后向前遍历,仅返回在当前帧出现且命中周期大于self.min_hits(除非跟踪刚开始)的跟踪结果;如果未命中时间大于self.max_age则删除跟踪器。
    hit_streak忽略目标初始的若干帧。

        i = len(self.trackers)
        for trk in reversed(self.trackers):
            d = trk.get_state()[0]
            if((trk.time_since_update < 1) and (trk.hit_streak >= self.min_hits or self.frame_count <= self.min_hits)):
              ret.append(np.concatenate((d,[trk.id+1])).reshape(1,-1)) # +1 as MOT benchmark requires positive
            i -= 1
            #remove dead tracklet
            if(trk.time_since_update > self.max_age):
              self.trackers.pop(i)
    
        if(len(ret)>0):
          return np.concatenate(ret)
        return np.empty((0,5))
    

    associate_detections_to_trackers

    这里命名不准确,应该是将检测框关联到跟踪目标(objects)或者轨迹(tracks),而不是跟踪器(trackers)。
    跟踪器数量为0则直接构造结果。

      if(len(trackers)==0):
        return np.empty((0,2),dtype=int), np.arange(len(detections)), np.empty((0,5),dtype=int)
      iou_matrix = np.zeros((len(detections),len(trackers)),dtype=np.float32)
    

    iou 不支持数组计算。
    逐个计算两两间的交并比,调用 linear_assignment 进行匹配。

      for d,det in enumerate(detections):
        for t,trk in enumerate(trackers):
          iou_matrix[d,t] = iou(det,trk)
      matched_indices = linear_assignment(-iou_matrix)
    

    记录未匹配的检测框及轨迹。

      unmatched_detections = []
      for d,det in enumerate(detections):
        if(d not in matched_indices[:,0]):
          unmatched_detections.append(d)
      unmatched_trackers = []
      for t,trk in enumerate(trackers):
        if(t not in matched_indices[:,1]):
          unmatched_trackers.append(t)
    

    过滤掉 IoU 低的匹配。

      #filter out matched with low IOU
      matches = []
      for m in matched_indices:
        if(iou_matrix[m[0],m[1]]<iou_threshold):
          unmatched_detections.append(m[0])
          unmatched_trackers.append(m[1])
        else:
          matches.append(m.reshape(1,2))
    

    初始化用列表,返回值用 Numpy.array。

      if(len(matches)==0):
        matches = np.empty((0,2),dtype=int)
      else:
        matches = np.concatenate(matches,axis=0)
    
      return matches, np.array(unmatched_detections), np.array(unmatched_trackers)
    

    KalmanBoxTracker

    此类表示观测目标框所对应跟踪对象的内部状态。
    定义等速模型。
    内部使用 KalmanFilter,7个状态变量,4个观测输入。
    F是状态变换模型,H是观测函数,R为测量噪声矩阵,P为协方差矩阵,Q为过程噪声矩阵。
    状态转移矩阵A根据运动学公式确定
    x = [ u , v , s , r , u ˙ , v ˙ , s ˙ ] T , \mathbf{x} = [u,v,s,r,\dot{u},\dot{v},\dot{s}]^T, x=[u,v,s,r,u˙,v˙,s˙]T,
    F = [ 1 0 0 0 Δ u 0 0 0 1 0 0 0 Δ v 0 0 0 1 0 0 0 Δ s 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 ] F=\begin{bmatrix} 1 &amp; 0 &amp; 0 &amp; 0 &amp; \Delta u &amp; 0 &amp; 0 \\ 0 &amp; 1 &amp; 0 &amp; 0 &amp; 0 &amp; \Delta v &amp; 0 \\ 0 &amp; 0 &amp; 1 &amp; 0 &amp; 0 &amp; 0 &amp; \Delta s \\ 0 &amp; 0 &amp; 0 &amp; 1 &amp; 0 &amp; 0 &amp; 0 \\ 0 &amp; 0 &amp; 0 &amp; 0 &amp; 1 &amp; 0 &amp; 0 \\ 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 1 &amp; 0 \\ 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 1 \end{bmatrix} F=1000000010000000100000001000Δu0001000Δv0001000Δs0001

    H = [ 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 ] H=\begin{bmatrix} 1 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 \\ 0 &amp; 1 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 \\ 0 &amp; 0 &amp; 1 &amp; 0 &amp; 0 &amp; 0 &amp; 0 \\ 0 &amp; 0 &amp; 0 &amp; 1 &amp; 0 &amp; 0 &amp; 0 \end{bmatrix} H=1000010000100001000000000000

      count = 0
      def __init__(self,bbox):
        """
        Initialises a tracker using initial bounding box.
        """
        #define constant velocity model
        self.kf = KalmanFilter(dim_x=7, dim_z=4)
        self.kf.F = np.array([
        [1,0,0,0,1,0,0],
        [0,1,0,0,0,1,0],
        [0,0,1,0,0,0,1],
        [0,0,0,1,0,0,0],  
        [0,0,0,0,1,0,0],
        [0,0,0,0,0,1,0],
        [0,0,0,0,0,0,1]])
        self.kf.H = np.array([
        [1,0,0,0,0,0,0],
        [0,1,0,0,0,0,0],
        [0,0,1,0,0,0,0],
        [0,0,0,1,0,0,0]])
    
        self.kf.R[2:,2:] *= 10.
        self.kf.P[4:,4:] *= 1000. #give high uncertainty to the unobservable initial velocities
        self.kf.P *= 10.
        self.kf.Q[-1,-1] *= 0.01
        self.kf.Q[4:,4:] *= 0.01
    
        self.kf.x[:4] = convert_bbox_to_z(bbox)
        self.time_since_update = 0
        self.id = KalmanBoxTracker.count
        KalmanBoxTracker.count += 1
        self.history = []
        self.hits = 0
        self.hit_streak = 0
        self.age = 0
    

    update

    使用观察到的目标框更新状态向量。filterpy.kalman.KalmanFilter.update 会根据观测修改内部状态估计self.kf.x
    重置self.time_since_update,清空self.history

        self.time_since_update = 0
        self.history = []
        self.hits += 1
        self.hit_streak += 1
        self.kf.update(convert_bbox_to_z(bbox))
    

    predict

    推进状态向量并返回预测的边界框估计。
    将预测结果追加到self.history。由于 get_state 直接访问 self.kf.x,所以self.history没有用到。

        if((self.kf.x[6]+self.kf.x[2])<=0):
          self.kf.x[6] *= 0.0
        self.kf.predict()
        self.age += 1
        if(self.time_since_update>0):
          self.hit_streak = 0
        self.time_since_update += 1
        self.history.append(convert_x_to_bbox(self.kf.x))
        return self.history[-1]
    

    get_state

    get_state
    convert_x_to_bbox

    返回当前边界框估计值。

        return convert_x_to_bbox(self.kf.x)
    

    iou

    @numba.jit 即时编译修饰函数以生成高效的机器代码。所有参数都是可选的。

    @jit
    def iou(bb_test,bb_gt):
      """
      Computes IUO between two bboxes in the form [x1,y1,x2,y2]
      """
      xx1 = np.maximum(bb_test[0], bb_gt[0])
      yy1 = np.maximum(bb_test[1], bb_gt[1])
      xx2 = np.minimum(bb_test[2], bb_gt[2])
      yy2 = np.minimum(bb_test[3], bb_gt[3])
      w = np.maximum(0., xx2 - xx1)
      h = np.maximum(0., yy2 - yy1)
      wh = w * h
      o = wh / ((bb_test[2]-bb_test[0])*(bb_test[3]-bb_test[1])
        + (bb_gt[2]-bb_gt[0])*(bb_gt[3]-bb_gt[1]) - wh)
      return(o)
    
    

    convert_bbox_to_z

    [x1,y1,x2,y2]形式的检测框转为滤波器的状态表示形式[x,y,s,r]。其中xy是框的中心,s是比例/区域,r是宽高比。

      w = bbox[2]-bbox[0]
      h = bbox[3]-bbox[1]
      x = bbox[0]+w/2.
      y = bbox[1]+h/2.
      s = w*h    #scale is just area
      r = w/float(h)
      return np.array([x,y,s,r]).reshape((4,1))
    

    convert_x_to_bbox

    [cx,cy,s,r]的目标框表示转为[x_min,y_min,x_max,y_max]的形式。

      w = np.sqrt(x[2]*x[3])
      h = x[2]/w
      if(score==None):
        return np.array([x[0]-w/2.,x[1]-h/2.,x[0]+w/2.,x[1]+h/2.]).reshape((1,4))
      else:
        return np.array([x[0]-w/2.,x[1]-h/2.,x[0]+w/2.,x[1]+h/2.,score]).reshape((1,5))
    

    改进思路

    Sort 算法受限于在线的定位,直接忽略了所有目标的考察期输出。这未免有些因噎废食。对于目标的甄别期较短,可以考虑延时判断后再行输出。

    参考资料:

    展开全文
  • 环境准备与编译 ...但是,编译的时候使用的是TQ提供的脚本build_sh,根据这个脚本,可以看到lunch的目标是sabresd_6dq: $ echo $TARGET_PRODUCT sabresd_6dq 即,TQIMX6的Android lunch目标其实使用的是sa

    环境准备与编译

    个人使用的是Ubuntu 12.04 X64,针对环境的配置,百度即可。板子使用的是TQIMX6Q。

    lunch目标

    但是,编译的时候使用的是TQ提供的脚本build_sh,根据这个脚本,可以看到lunch的目标是sabresd_6dq:

    $ echo $TARGET_PRODUCT 
    sabresd_6dq
    
    即,TQIMX6的Android lunch目标其实使用的是sabred板子的目标,并没有自己添加lunch target,编译完成后,也没有userdata.img:

    10:50 hexiongjun:TQIMX6_android-4.3 $ echo $OUT
    /home/hexiongjun/iMX6Q/TQIMX6_android-4.3/out/target/product/sabresd_6dq
    10:51 hexiongjun:TQIMX6_android-4.3 $ ls -l $OUT/*.img
    -rw-r--r-- 1 hexiongjun hexiongjun   5314560 Dec  4 18:37 /home/hexiongjun/iMX6Q/TQIMX6_android-4.3/out/target/product/sabresd_6dq/boot.img
    -rw-rw-r-- 1 hexiongjun hexiongjun    242287 Dec  4 18:37 /home/hexiongjun/iMX6Q/TQIMX6_android-4.3/out/target/product/sabresd_6dq/ramdisk.img
    -rw-rw-r-- 1 hexiongjun hexiongjun    794534 Dec  4 18:37 /home/hexiongjun/iMX6Q/TQIMX6_android-4.3/out/target/product/sabresd_6dq/ramdisk-recovery.img
    -rw-r--r-- 1 hexiongjun hexiongjun   5865472 Dec  4 18:37 /home/hexiongjun/iMX6Q/TQIMX6_android-4.3/out/target/product/sabresd_6dq/recovery.img
    -rw-r--r-- 1 hexiongjun hexiongjun 293601280 Dec  4 18:37 /home/hexiongjun/iMX6Q/TQIMX6_android-4.3/out/target/product/sabresd_6dq/system.img
    10:53 hexiongjun:TQIMX6_android-4.3 $ 
    
    同时也编译了uboot与uImage。

    编译可能出现的问题

    Android编译使用的是自带的ToolChain,自然不需要再自己配置。但是Host PC中的GCC也需要注意版本,否则会出现问题:
    host C: libcrypto_static <= external/openssl/crypto/bio/b_sock.c
    external/openssl/crypto/bio/b_print.c:842:2: internal compiler error: Segmentation fault
    Please submit a full bug report,
    with preprocessed source if appropriate.
    See <http://gcc.gnu.org/bugs.html> for instructions.
    make: *** [out/host/linux-x86/obj/STATIC_LIBRARIES/libcrypto_static_intermediates/crypto/bio/b_print.o] Error 1

    看log输出,还以为是Host GCC的Bug,换了多个版本的GCC之后,问题依旧,后来发现make时指定submake过多,将make -j8改成了make libcrypto就好了,比较怪异。

    HDMI硬件配置

    因为没有TFT屏幕,所以使用了以前用过的改装过的笔记本屏幕,参考我以前的博文:废物利用: 动手将笔记本的显示器改成多功能显示器 可用于电视盒子以及嵌入式开发

    HDMI显示输出的配置

    因为我们使用的是HDMI显示输出,因此需要配置参数,这个参数通过uboot的bootargs env传递到内核中去,使用的笔记本屏幕分配率是1366X768,找了一个接近的1280X720,显示部分的参数如下:

    video=mxcfb0:dev=hdmi,1366x768MM@60,if=RGB24,bpp=32 video=mxcfb1:off video=mxcfb2:off fbmem=48M

    按需更改。


    Android的NFS启动

    配置好NFS Server与TFTP Server,可以参考我以前的博文:Ubuntu下nfs server与tftp server的搭建

    Android的NFS可以先使用TQ提供的文件系统。如果需要使用自己编译出来的,请看下一篇博文。

    然后就是启动板子,在uboot中配置环境变量与启动:

    set serverip 192.168.2.100
    set ipaddr 192.168.2.111
    set bootargs 'console=ttySAC0,115200n8 root=/dev/nfs nfsroot=192.168.2.100:/home/hexiongjun/nfs-imx6/Android ip=192.168.2.120 debug ignore_loglevel init=/init vmalloc=400M androidboot.console=ttySAC0 androidboot.hardware=freescale video=mxcfb0:dev=hdmi,1280x720MM@60,if=RGB24,bpp=32 video=mxcfb1:off video=mxcfb2:off fbmem=48M'
    tftp 0x10800000 192.168.2.100:imx6/uImage;bootm 0x10800000

    启动后的效果图



    ADB的配置

    在TQIMX6上面开启开发者选项,并启用USB调试,然后在出现的运行USB调试选项中确定。

    在Linux端中,添加vendor ID到android adb配置中:

    echo "0x0451" > ~/.android/adb_usb.ini


    然后用USB线连接板子与PC,使用adb 查看是否连接成功:

    17:51 hexiongjun:Con $ adb devices
    List of devices attached 
    emulator-5554	device
    0123456789ABCDEF	device

    其中第二项,就是我们的设备。


    展开全文
  • 目标检测】RCNN算法详解

    万次阅读 多人点赞 2016-04-05 23:10:36
    深度学习用于目标检测的RCNN算法
  • YOLO全称You Only Look Once,是一个端到端(end-to-end)的目标检测算法,现在已经发展到第三个版本。由于第三个版本已经比较复杂,我们选择学习第一个版本。 github上有个同学实现了一个pytorch的版本:...
  • SPWM三相输出

    千次阅读 2019-06-29 22:19:20
    用定时器1使三路通道,作为输出用。(同时也可配置互补输出通道,可产生与其对应相位相反的一路正弦波) 关于SPWM 的配置 PA8 PA9 PA10 输出三路相位相差120度的正弦波,不过输出要经过低通滤波器滤波。 ...
  • 目标检测-RCNN系列

    万次阅读 多人点赞 2017-01-11 16:26:12
    • RCNN RCNN(Regions with CNN features)是将CNN方法应用到目标检测问题上的一个里程碑,由年轻有为的RBG大神提出,借助CNN良好的特征提取和分类性能,通过RegionProposal方法实现目标检测问题的转化。...
  • 目标检测综述

    万次阅读 多人点赞 2019-07-09 21:36:26
    这意味着,我们不仅要用算法判断图片中是不是一辆汽车, 还要在图片中标记出它的位置, 用边框或红色方框把汽车圈起来, 这就是目标检测问题。 其中“定位”的意思是判断汽车在图片中的具体位置。 近几年来,目标...
  • 目标优化详解【转载】

    万次阅读 多人点赞 2017-09-02 11:05:47
    人们会经常遇到使多个目标在给定区域同时尽可能最佳的优化问题 ,也就是多目标优化问题。优化问题存在的优化目标超过一个并需要同时处理 ,就成为多目标优化问题。 多目标优化问题在工程应用等现实生活中非常普遍...
  • C语言本身并提供输入输出语句

    千次阅读 2016-08-24 17:47:00
    C语言本身并提供输入输出语句,输入和输出操作是由函数来实现的。在C标准函数库中提供了一些输入输出函数,例如,printf函数和scanf函数。...把输入输出作为C语言提供的语句的目的是使C语言编译系统简单,...
  • 目标优化问题概述

    万次阅读 2017-08-29 20:34:16
    图片清楚请看多目标问题详解:多目标问题详解 定义:若干冲突或相互影响条件约束下在给定区域内寻找尽可能的最优解(非劣解)。 关键词:条件约束,折中最优解(解并非唯一是与单目标优化问题的本质区别) 文字...
  • 目标跟踪入门

    万次阅读 多人点赞 2019-01-02 22:17:28
    输入初始化目标框,在下一帧中产生众多候选框(Motion Model),提取这些候选框的特征(Feature Extractor),然后对这些候选框评分(Observation Model),最后在这些评分中找一个得分最高的候选框作为...
  • 将高级语言编写的源程序转换为目标程序的是什么? A)链接程序 B)解释程序 C)编译程序 D)编辑程序 答案:D   把源程序转换为目标程序的过程叫编译。所以将高级语言编写的源程序转换为目标程序的是相应的...
  • 原博主博客地址:http://blog.csdn.net/qq21497936 ... ...C++STL开发温习与总结(六): ...6.C++语言输入/输出流定义之输入/输出格式控制  本章开始正式进入标准库的温习。 1.C++语言输入/输出
  • 目标检测】Fast RCNN算法详解

    万次阅读 多人点赞 2016-04-12 13:05:42
    继2014年的RCNN之后,Ross Girshick在15年推出Fast RCNN,构思精巧,流程更为紧凑,大幅提升了目标检测的速度。
  • SAR图像舰船目标检测介绍

    万次阅读 2019-03-02 17:54:47
    作者:SIGAI人工智能平台,出处:SIGAI...合成孔径雷达(Synthetic Aperture Radar, SAR)具有全天候、全天时、受天气影响等成像特点,目前已经成为人们对地观测的重要手段之一[1]。因此,利用SAR数据进行目标检测...
  • 目标检测

    万次阅读 2019-02-26 19:22:31
    文章目录第八章 目标检测8.1 基本概念8.1.1 什么是目标检测?8.1.2 目标检测要解决的核心问题?8.1.2 目标检测算法分类?8.2 Two Stage目标检测算法8.2.1 R-CNN8.2.2 Fast R-CNN8.2.3 Faster R-CNN8.2.4 R-FCN8.2.5 ...
  • 机器视觉 OpenCV—python目标跟踪(光流)

    万次阅读 多人点赞 2018-12-05 16:59:11
    目标跟踪是对摄像头视频中的移动目标进行定位的过程。实时目标跟踪是许多计算机视觉应用的重要任务,如监控、基于感知的用户界面、增强现实、基于对象的视频压缩以及辅助驾驶等。 好久之前做过一次人脸检测,里面...
  • 目标优化

    万次阅读 多人点赞 2018-09-14 11:40:57
    最优化问题的分类 1)无约束和有约束条件;...使多个目标在给定区域同时尽可能最佳,多目标优化的解通常是一组均衡解(即一组由众多 Pareto最优解组成的最优解集合 ,集合中的各个元素称为 Pareto最优解或非劣最...
  • 带你入门多目标跟踪(二)SORT&DeepSORT

    万次阅读 多人点赞 2019-07-02 19:24:49
    上一篇文章大概给大家介绍了一下多目标跟踪MOT的一些基础知识。初次了解还是从经典的算法开始,SORT和DeepSORT是多目标跟踪中两个知名度比较高的算法。...本文将带大家解析一下SORT和DeepSORT的基本思路,废话多说...
  • 有时在查找问题时,想中断程序运行就输出一下某个条件下的函数执行顺序可以帮助定位问题。 在Xcode下可以编辑断点设置中的Action设为Debugger Command, 如果你使用GDB作为调试器(项目设置),然后输入backtrace...
  • 深度学习之目标检测与目标识别

    万次阅读 多人点赞 2018-06-05 21:58:54
    本文主要讲述了目标识别中的第一种类型---基于region proposal的目标检测和目标识别的算法, 主要主要包括R-CNN,Fast R-CNN,Faster R-CNN等网络, 揭示了基于region proposal的目标检测和目标识别的算法的发展历程....
  • Java输入/输出

    万次阅读 2018-05-06 14:29:58
    文本(Text)输入/输出 输出用PrintWriter类 try-with-resources来自动关闭资源 用Scanner来读取文本 流式处理 二进制(Binary)输入/输出 二进制输入/输出到文件 FilterInputStream/FilterOutputStream ...
  • 目标分类任务负责判断输入图像中是否有感兴趣类别的物体出现,输出一系列带分数的标签表明感兴趣类别的物体出现在输入图像的可能性.目标定位任务负责确定输入图像中感兴趣类别的物体的位置和范围,输出物体的包围盒
  • 【深度学习】目标检测算法 YOLO 最耐心细致的讲解

    万次阅读 多人点赞 2018-12-04 20:43:50
    YOLO 是 2016 年提出来的目标检测算法,在当时比较优秀的目标检测算法有 R-CNN、Fast R-CNN 等等,但 YOLO 算法还是让人感到很新奇与兴奋。 YOLO 是 You only look once 几个单词的缩写,大意是你看一次就可以预测了...
  • 目标检测——目标检测方法的综述

    千次阅读 2019-01-14 18:15:40
    一、目标检测问题的定义 1、定义: 目标检测时图片中对可变数量的目标进行查找和分类。 2、需要解决的问题 目标种类与数量问 目标尺度问题:目标稠密、目标大小等 外在环境干扰问题:遮挡、光照  二、目标检测...
  • 目标跟踪介绍(单目标

    万次阅读 多人点赞 2019-06-21 22:01:55
    随着研究人员不断地深入研究,视觉目标跟踪在近十几年里有了突破性的进展,使得视觉跟踪算法仅仅局限于传统的机器学习方法,更是结合了近些年人工智能热潮—深度学习(神经网络)和相关滤波器等方法,并取...
  • C语言:字符数组的输入输出

    万次阅读 多人点赞 2018-12-20 10:56:46
    用printf输出 用scanf输入 用gets输入 用puts输出 用printf输出 输出方法1:printf 逐个字符输出。  void main(void){  char c[ ] = "I am happy";   int i;   ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 574,219
精华内容 229,687
关键字:

不能作为查询输出目标的是