def _oneshot_forward_video(self, video_idx, save_logits): with Timer(): # finetune on first frame print("--------------------------------This mine change-------------------------") print("------------------------OnlineAdaptingForwarder finetune ---------------------") self._finetune(video_idx, n_finetune_steps=self.n_finetune_steps) network = self.engine.test_network targets = network.raw_labels ys = network.y_softmax ys = self._adjust_results_to_targets(ys, targets) data = self.val_data n, measures, ys_argmax_val, logits_val, targets_val = self._process_forward_minibatch( data, network, save_logits, self.save_oneshot, targets, ys, start_frame_idx=0) assert n == 1 n_frames = data.num_examples_per_epoch() print("-------------n_frames: ",n_frames) measures_video = [] last_mask = targets_val[0] kframe_lst=[0] for t in xrange(1, n_frames): print("frameth:",t) def get_posteriors(): n_, _, _, logits_val_, _ = self._process_forward_minibatch( data, network, save_logits=False, save_results=False, targets=targets, ys=ys, start_frame_idx=t) assert n_ == 1 return logits_val_[0] # recover annotation data with results # forward current frame using adapted model print ("-----------------adapt--------------------") negatives,kframe_lst = self._adapt(video_idx, t, last_mask, get_posteriors,kframe_lst) print kframe_lst n, measures, ys_argmax_val, posteriors_val, targets_val = self._process_forward_minibatch( data, network, save_logits, self.save_oneshot, targets, ys, start_frame_idx=t) self.train_data._videos[video_idx][t]["label"]=ys_argmax_val[0] assert n == 1 assert len(measures) == 1 measure = measures[0] print >> log.v5, "frame", t, ":", measure measures_video.append(measure) #print("measures_video",measures_video) last_mask = ys_argmax_val[0] # prune negatives from last mask # negatives are None if we think that the target is lost if negatives is not None and self.use_negatives: last_mask[negatives] = 0 measures_video[:-1] = measures_video[:-1] measures_video = average_measures(measures_video) print >> log.v1, "sequence", video_idx + 1, data.video_tag(video_idx), measures_video
def forward(self, network, data, save_results=True, save_logits=False): n_total = data.num_examples_per_epoch() n_processed = 0 targets = network.raw_labels ys = network.y_softmax # e.g. used for resizing ys = self._adjust_results_to_targets(ys, targets) measures = [] while n_processed < n_total: n, new_measures, _, _, _ = self._process_forward_minibatch(data, network, save_logits, save_results, targets, ys, n_processed) measures += new_measures n_processed += n print >> log.v5, n_processed, "/", n_total if self.ignore_first_and_last_results: measures = measures[1:-1] elif self.ignore_first_result: measures = measures[1:] measures = average_measures(measures) if hasattr(data, "video_tag"): video_idx = data.get_video_idx() print >> log.v1, "sequence", video_idx + 1, data.video_tag(video_idx), measures else: print >> log.v1, measures
def _oneshot_forward_video(self, video_idx, save_logits): with Timer(): # finetune on first frame self._finetune(video_idx, n_finetune_steps=self.n_finetune_steps) network = self.engine.test_network targets = network.raw_labels ys = network.y_softmax ys = self._adjust_results_to_targets(ys, targets) data = self.val_data n, measures, ys_argmax_val, logits_val, targets_val = self._process_forward_minibatch( data, network, save_logits, self.save_oneshot, targets, ys, start_frame_idx=0) assert n == 1 n_frames = data.num_examples_per_epoch() measures_video = [] last_mask = targets_val[0] for t in range(1, n_frames): def get_posteriors(): n_, _, _, logits_val_, _ = self._process_forward_minibatch( data, network, save_logits=False, save_results=False, targets=targets, ys=ys, start_frame_idx=t) assert n_ == 1 return logits_val_[0] # online adaptation to current frame negatives = self._adapt(video_idx, t, last_mask, get_posteriors) # forward current frame using adapted model n, measures, ys_argmax_val, posteriors_val, targets_val = self._process_forward_minibatch( data, network, save_logits, self.save_oneshot, targets, ys, start_frame_idx=t) assert n == 1 assert len(measures) == 1 measure = measures[0] print("frame", t, ":", measure, file=log.v5) measures_video.append(measure) last_mask = ys_argmax_val[0] # prune negatives from last mask # negatives are None if we think that the target is lost if negatives is not None and self.use_negatives: last_mask[negatives] = 0 measures_video[:-1] = measures_video[:-1] measures_video = average_measures(measures_video) print("sequence", video_idx + 1, data.video_tag(video_idx), measures_video, file=log.v1)
def _oneshot_forward_video(self, video_idx, save_logits): with Timer(): # Test Network Variables + Resize output to same shape of Labels network = self.engine.test_network targets = network.raw_labels ys = network.y_softmax ys = self._adjust_results_to_targets(ys, targets) data = self.val_data # Process minibatch forward for first frame n, measures, ys_argmax_val, logits_val, targets_val = self._process_forward_minibatch( data, network, save_logits, self.save_oneshot, targets, ys, start_frame_idx=0) last_mask = targets_val[0] assert n == 1 n_frames = data.num_examples_per_epoch() measures_video = [] measures_video.append(measures[0]) for t in xrange(0, n_frames): # Compute IoU measures n, measures, ys_argmax_val, posteriors_val, targets_val = self._process_forward_minibatch( data, network, save_logits, self.save_oneshot, targets, ys, start_frame_idx=t) assert n == 1 assert len(measures) == 1 measure = measures[0] print >> log.v5, "frame", t, ":", measure measures_video.append(measure) #measures_video[:-1] = measures_video[:-1] measures_video = average_measures(measures_video) print >> log.v1, "sequence", video_idx + 1, data.video_tag( video_idx), measures_video
def _oneshot_forward_video(self, video_idx, save_logits): with Timer(): # Test Network Variables + Resize output to same shape of Labels network = self.engine.test_network targets = network.raw_labels ys = network.y_softmax ys = self._adjust_results_to_targets(ys, targets) data = self.val_data # Process minibatch forward for first frame n, measures, ys_argmax_val, logits_val, targets_val = self._process_forward_minibatch( data, network, save_logits, self.save_oneshot, targets, ys, start_frame_idx=0) last_mask = targets_val[0] assert n == 1 n_frames = data.num_examples_per_epoch() measures_video = [] measures_video.append(measures[0]) dirs = sorted(os.listdir(self.mot_dir)) files_annotations = sorted( os.listdir(self.mot_dir + data.video_tag(video_idx))) # if "FBMS" in self.dataset: # files_annotations= sorted(os.listdir('/home/nray1/ms/FBMS/Annotations/480p/'+data.video_tag(video_idx) )) # elif "FORDS_Rotation" in self.dataset or \ # "PDB" in self.mot_dir or \ # "FORDS_tasks" in self.dataset: # files_annotations = sorted(os.listdir(self.mot_dir+data.video_tag(video_idx))) # elif "FORD" in self.dataset: # files_annotations = sorted(os.listdir(self.mot_dir+dirs[video_idx])) for t in xrange(0, n_frames): # Probability Map Function def get_posteriors(): n_, _, _, logits_val_, _ = self._process_forward_minibatch( data, network, save_logits=False, save_results=False, targets=targets, ys=ys, start_frame_idx=t) assert n_ == 1 return logits_val_[0] # Start Network Adaptation Only on first frame if t < self.few_shot_samples: # Read adaptation target and postprocess it # For DAVIS starts at 0, FORDS starts at 1 for frame numbers, FBMS use annotation files if "FBMS" in self.mot_dir: mask = cv2.imread( self.mot_dir + data.video_tag(video_idx) + '/' + files_annotations[t], 0) else: if "FORDS" in self.dataset: f = open( self.mot_dir + data.video_tag(video_idx) + '/' + files_annotations[t], 'rb') # elif "FORDS_Rotation" in self.dataset: # f= open(self.mot_dir+data.video_tag(video_idx)+'/'+files_annotations[t], 'rb') # elif "FORD" in self.dataset: # f= open(self.mot_dir+dirs[video_idx]+'/'+files_annotations[t], 'rb') elif "DAVIS" in self.dataset: f = open( self.mot_dir + dirs[video_idx] + '/%05d.pickle' % (t), 'rb') # else: # f= open(self.mot_dir+data.video_tag(video_idx)+'/'+files_annotations[t].split('.')[0]+'.pickle', 'rb') mask = pickle.load(f)[:, :, 1] mask = (mask - mask.min()) * 1.0 / (mask.max() - mask.min()) last_mask = np.expand_dims(mask, axis=2) self._adapt(video_idx, t, last_mask, get_posteriors) # Compute IoU measures n, measures, ys_argmax_val, posteriors_val, targets_val = self._process_forward_minibatch( data, network, save_logits, self.save_oneshot, targets, ys, start_frame_idx=t) assert n == 1 assert len(measures) == 1 measure = measures[0] print >> log.v5, "Motion Adapted frame", t, ":", measure measures_video.append(measure) measures_video = average_measures(measures_video) print >> log.v1, "sequence", video_idx + 1, data.video_tag( video_idx), measures_video