def finish(self):
self.face_rate = float(self.face_successes)/self.faces
self.face_ci = pv.cibinom(self.faces,self.face_successes,alpha=0.05)
self.both25_rate = float(self.both25_successes)/self.faces
self.both25_ci = pv.cibinom(self.faces,self.both25_successes,alpha=0.05)
self.both10_rate = float(self.both10_successes)/self.faces
self.both10_ci = pv.cibinom(self.faces,self.both10_successes,alpha=0.05)
self.both05_rate = float(self.both05_successes)/self.faces
self.both05_ci = pv.cibinom(self.faces,self.both05_successes,alpha=0.05)
self.left25_rate = float(self.left25_successes)/self.faces
self.left25_ci = pv.cibinom(self.faces,self.left25_successes,alpha=0.05)
self.left10_rate = float(self.left10_successes)/self.faces
self.left10_ci = pv.cibinom(self.faces,self.left10_successes,alpha=0.05)
self.left05_rate = float(self.left05_successes)/self.faces
self.left05_ci = pv.cibinom(self.faces,self.left05_successes,alpha=0.05)
self.right25_rate = float(self.right25_successes)/self.faces
self.right25_ci = pv.cibinom(self.faces,self.right25_successes,alpha=0.05)
self.right10_rate = float(self.right10_successes)/self.faces
self.right10_ci = pv.cibinom(self.faces,self.right10_successes,alpha=0.05)
self.right05_rate = float(self.right05_successes)/self.faces
self.right05_ci = pv.cibinom(self.faces,self.right05_successes,alpha=0.05)
if self.face_successes > 0:
self.bothrmse = math.sqrt(self.bothsse/(2*self.face_successes))
self.leftrmse = math.sqrt(self.leftsse/self.face_successes)
self.rightrmse = math.sqrt(self.rightsse/self.face_successes)
self.elapse_time = self.stop_time - self.start_time
self.time_per_image = self.elapse_time / self.images
self.time_per_face = self.elapse_time / self.faces
def finish(self):
self.face_rate = float(self.face_successes) / self.faces
self.face_ci = pv.cibinom(self.faces, self.face_successes, alpha=0.05)
self.both25_rate = float(self.both25_successes) / self.faces
self.both25_ci = pv.cibinom(self.faces,
self.both25_successes,
alpha=0.05)
self.both10_rate = float(self.both10_successes) / self.faces
self.both10_ci = pv.cibinom(self.faces,
self.both10_successes,
alpha=0.05)
self.both05_rate = float(self.both05_successes) / self.faces
self.both05_ci = pv.cibinom(self.faces,
self.both05_successes,
alpha=0.05)
self.left25_rate = float(self.left25_successes) / self.faces
self.left25_ci = pv.cibinom(self.faces,
self.left25_successes,
alpha=0.05)
self.left10_rate = float(self.left10_successes) / self.faces
self.left10_ci = pv.cibinom(self.faces,
self.left10_successes,
alpha=0.05)
self.left05_rate = float(self.left05_successes) / self.faces
self.left05_ci = pv.cibinom(self.faces,
self.left05_successes,
alpha=0.05)
self.right25_rate = float(self.right25_successes) / self.faces
self.right25_ci = pv.cibinom(self.faces,
self.right25_successes,
alpha=0.05)
self.right10_rate = float(self.right10_successes) / self.faces
self.right10_ci = pv.cibinom(self.faces,
self.right10_successes,
alpha=0.05)
self.right05_rate = float(self.right05_successes) / self.faces
self.right05_ci = pv.cibinom(self.faces,
self.right05_successes,
alpha=0.05)
if self.face_successes > 0:
self.bothrmse = math.sqrt(self.bothsse / (2 * self.face_successes))
self.leftrmse = math.sqrt(self.leftsse / self.face_successes)
self.rightrmse = math.sqrt(self.rightsse / self.face_successes)
self.elapse_time = self.stop_time - self.start_time
self.time_per_image = self.elapse_time / self.images
self.time_per_face = self.elapse_time / self.faces
def computeRates(self, alpha=0.05):
'''
Populates the distance matrix with more information such as
recognition rates for each row. Call this only after all of the
data has been added.
'''
self.row_headers.sort()
self.col_headers.sort()
for row in self.classes:
successes = 0
total = 0
for col in self.classes:
total += self.element(row, col)
if row == col:
successes += self.element(row, col)
rate = float(successes) / total
self.setData(row, 'Rate', rate)
self.setData(row, 'Bar', "#" * int(10 * rate + 0.5))
self.setData(row, 'Lower', pv.cibinom(total, successes, alpha)[0])
self.setData(row, 'Upper', pv.cibinom(total, successes, alpha)[1])
for col in self.classes:
successes = 0
total = 0
for row in self.classes:
total += self.element(row, col)
if row == col:
successes += self.element(row, col)
rate = 'N/A'
self.setData('Total', col, "%s" % rate)
try:
rate = float(successes) / total
self.setData('Total', col, "%0.4f" % rate)
except:
pass
self.setData('Total', 'Rate', self.update_rate())
self.setData('Total', 'Bar', "#" * int(10 * self.update_rate() + 0.5))
self.setData('Total', 'Lower', self.confidenceInterval(alpha)[0])
self.setData('Total', 'Upper', self.confidenceInterval(alpha)[1])
def computeRates(self,alpha=0.05):
'''
Populates the distance matrix with more information such as
recognition rates for each row. Call this only after all of the
data has been added.
'''
self.row_headers.sort()
self.col_headers.sort()
for row in self.classes:
successes = 0
total = 0
for col in self.classes:
total += self.element(row,col)
if row == col:
successes += self.element(row,col)
rate = float(successes)/total
self.setData(row,'Rate',rate)
self.setData(row,'Bar',"#"*int(10*rate+0.5))
self.setData(row,'Lower',pv.cibinom(total,successes,alpha)[0])
self.setData(row,'Upper',pv.cibinom(total,successes,alpha)[1])
for col in self.classes:
successes = 0
total = 0
for row in self.classes:
total += self.element(row,col)
if row == col:
successes += self.element(row,col)
rate = float(successes)/total
self.setData('Total',col,"%0.4f"%rate)
self.setData('Total','Rate',self.update_rate())
self.setData('Total','Bar',"#"*int(10*self.update_rate()+0.5))
self.setData('Total','Lower',self.confidenceInterval(alpha)[0])
self.setData('Total','Upper',self.confidenceInterval(alpha)[1])
def confidenceInterval(self, alpha=0.05):
'''
Returns the estimated a confidence interval for the success update_rate by
modeling the success update_rate as a binomial distribution.
'''
return pv.cibinom(self.total, self.successes, alpha=alpha)
def confidenceInterval(self,alpha=0.05):
'''
Returns the estimated a confidence interval for the success update_rate by
modeling the success update_rate as a binomial distribution.
'''
return pv.cibinom(self.total,self.successes,alpha=alpha)
def addSample(self, truth_rects, detected_rects, im=None, annotate=False):
'''
Adds a sample to face detection test.
@param truth_rects: truth for an image.
@param detected_rects: output of the detector
@param im: the image or filename to assciate with the sample.
@param annotate: add diagnostic annotations to the images.
'''
self.images += 1
name = None
detected_rects = copy.copy(detected_rects)
if isinstance(im, pv.Image):
name = im.filename
if self.pixels != None:
self.pixels += im.asPIL().size[0] * im.asPIL().size[1]
elif isinstance(im, str):
name = im
self.pixels = None
else:
name = "%d" % self.sample_id
self.pixels = None
table = self.table
for i in range(len(truth_rects)):
truth = truth_rects[i]
self.positives += 1
success = False
best_overlap = 0.0
best_detection = None
for j in range(len(detected_rects)):
detected = detected_rects[j]
overlap = overlap_score(truth, detected)
if overlap >= self.threshold and overlap > best_overlap:
success = True
best_overlap = overlap
best_detection = j
table.setData(self.sample_id, 'id', self.sample_id)
table.setData(self.sample_id, 'name', name)
table.setData(self.sample_id, 'truth_rect', str(truth))
if best_detection != None:
table.setData(self.sample_id, 'detection_rect',
str(detected_rects[best_detection]))
else:
table.setData(self.sample_id, 'detection_rect', None)
table.setData(self.sample_id, 'success', success)
table.setData(self.sample_id, 'overlap', best_overlap)
self.sample_id += 1
if success:
self.successes += 1
if annotate and isinstance(im, pv.Image):
if success:
im.annotateEllipse(truth, color='green')
else:
im.annotateEllipse(truth, color='red')
# Remove the best detection if success
if best_detection != None:
del detected_rects[best_detection]
if annotate:
for each in detected_rects:
im.annotateRect(each, color='red')
self.negatives += len(detected_rects)
self.end_time = time.time()
self.total_time = self.end_time - self.start_time
self.image_time = self.total_time / float(self.images)
# Update summary statistics
if self.positives > 0:
self.pos_rate = float(self.successes) / self.positives
self.pos_bounds = pv.cibinom(self.positives,
self.successes,
alpha=0.05)
if self.pixels != None:
self.neg_rate = float(self.negatives) / float(1.0e-6 * self.pixels)
self.createSummary()