目标追踪_【MOT】详解DeepSORT多目标追踪模型

 class Net(nn.Module):

    
     def __init__(self, num_classes=751 ,reid=False):
    
     super(Net,self).__init__()
    
     # 3 128 64
    
     self.conv = nn.Sequential(
    
         nn.Conv2d(3,64,3,stride=1,padding=1),
    
         nn.BatchNorm2d(64),
    
         nn.ReLU(inplace=True),
    
         # nn.Conv2d(32,32,3,stride=1,padding=1),
    
         # nn.BatchNorm2d(32),
    
         # nn.ReLU(inplace=True),
    
         nn.MaxPool2d(3,2,padding=1),
    
     )
    
     # 32 64 32
    
     self.layer1 = make_layers(64,64,2,False)
    
     # 32 64 32
    
     self.layer2 = make_layers(64,128,2,True)
    
     # 64 32 16
    
     self.layer3 = make_layers(128,256,2,True)
    
     # 128 16 8
    
     self.layer4 = make_layers(256,512,2,True)
    
     # 256 8 4
    
     self.avgpool = nn.AvgPool2d((8,4),1)
    
     # 256 1 1 
    
     self.reid = reid
    
     self.classifier = nn.Sequential(
    
         nn.Linear(512, 256),
    
         nn.BatchNorm1d(256),
    
         nn.ReLU(inplace=True),
    
         nn.Dropout(),
    
         nn.Linear(256, num_classes),
    
     )
    
     
    
     def forward(self, x):
    
     x = self.conv(x)
    
     x = self.layer1(x)
    
     x = self.layer2(x)
    
     x = self.layer3(x)
    
     x = self.layer4(x)
    
     x = self.avgpool(x)
    
     x = x.view(x.size(0),-1)
    
     # B x 128
    
     if self.reid:
    
         x = x.div(x.norm(p=2,dim=1,keepdim=True))
    
         return x
    
     # classifier
    
     x = self.classifier(x)
    
     return x

     def gating_distance(self, mean, covariance, measurements,

    
                     only_position=False):
    
     """Compute gating distance between state distribution and measurements.
    
   5.         A suitable distance threshold can be obtained from `chi2inv95`. If
    
     `only_position` is False, the chi-square distribution has 4 degrees of
    
     freedom, otherwise 2.
    
   9.         Parameters
    
     ----------
    
     mean : ndarray
    
         Mean vector over the state distribution (8 dimensional).
    
     covariance : ndarray
    
         Covariance of the state distribution (8x8 dimensional).
    
     measurements : ndarray
    
         An Nx4 dimensional matrix of N measurements, each in
    
         format (x, y, a, h) where (x, y) is the bounding box center
    
         position, a the aspect ratio, and h the height.
    
     only_position : Optional[bool]
    
         If True, distance computation is done with respect to the bounding
    
         box center position only.
    
   23.         Returns
    
     -------
    
     ndarray
    
         Returns an array of length N, where the i-th element contains the
    
         squared Mahalanobis distance between (mean, covariance) and
    
         `measurements[i]`.
    
   30.         """
    
     mean, covariance = self.project(mean, covariance)
    
     if only_position:
    
         mean, covariance = mean[:2], covariance[:2, :2]
    
         measurements = measurements[:, :2]
    
  
    
     cholesky_factor = np.linalg.cholesky(covariance)
    
     d = measurements - mean
    
     z = scipy.linalg.solve_triangular(
    
         cholesky_factor, d.T, lower=True, check_finite=False,
    
         overwrite_b=True)
    
     squared_maha = np.sum(z * z, axis=0)
    
     return squared_maha

 def min_cost_matching(

    
     distance_metric, max_distance, tracks, detections, track_indices=None,
    
     detection_indices=None):
    
     """Solve linear assignment problem.
    
   6.     Parameters
    
     ----------
    
     distance_metric : Callable[List[Track], List[Detection], List[int], List[int]) -> ndarray
    
     The distance metric is given a list of tracks and detections as well as
    
     a list of N track indices and M detection indices. The metric should
    
     return the NxM dimensional cost matrix, where element (i, j) is the
    
     association cost between the i-th track in the given track indices and
    
     the j-th detection in the given detection_indices.
    
     max_distance : float
    
     Gating threshold. Associations with cost larger than this value are
    
     disregarded.
    
     tracks : List[track.Track]
    
     A list of predicted tracks at the current time step.
    
     detections : List[detection.Detection]
    
     A list of detections at the current time step.
    
     track_indices : List[int]
    
     List of track indices that maps rows in `cost_matrix` to tracks in
    
     `tracks` (see description above).
    
     detection_indices : List[int]
    
     List of detection indices that maps columns in `cost_matrix` to
    
     detections in `detections` (see description above).
    
   28.     Returns
    
     -------
    
     (List[(int, int)], List[int], List[int])
    
     Returns a tuple with the following three entries:
    
     * A list of matched track and detection indices.
    
     * A list of unmatched track indices.
    
     * A list of unmatched detection indices.
    
   36.     """
    
     if track_indices is None:
    
     track_indices = np.arange(len(tracks))
    
     if detection_indices is None:
    
     detection_indices = np.arange(len(detections))
    
  
    
     if len(detection_indices) == 0 or len(track_indices) == 0:
    
     return [], track_indices, detection_indices  # Nothing to match.
    
  
    
     cost_matrix = distance_metric(
    
     tracks, detections, track_indices, detection_indices)
    
     cost_matrix[cost_matrix > max_distance] = max_distance + 1e-5
    
  
    
     row_indices, col_indices = linear_assignment(cost_matrix)
    
  
    
     matches, unmatched_tracks, unmatched_detections = [], [], []
    
     for col, detection_idx in enumerate(detection_indices):
    
     if col not in col_indices:
    
         unmatched_detections.append(detection_idx)
    
     for row, track_idx in enumerate(track_indices):
    
     if row not in row_indices:
    
         unmatched_tracks.append(track_idx)
    
     for row, col in zip(row_indices, col_indices):
    
     track_idx = track_indices[row]
    
     detection_idx = detection_indices[col]
    
     if cost_matrix[row, col] > max_distance:
    
         unmatched_tracks.append(track_idx)
    
         unmatched_detections.append(detection_idx)
    
     else:
    
         matches.append((track_idx, detection_idx))
    
     return matches, unmatched_tracks, unmatched_detections