def enforce_maximum_profit(categorical_results): mp_data = {} thresholds = {} for key, value in categorical_results.items(): li = [] max_acc = 0 threshold = 0 max_range_thresh = max(value, key=lambda x: x[0]) min_range_thresh = min(value, key=lambda x: x[0]) for thresh in np.arange(min_range_thresh[0], max_range_thresh[0], 0.01): result = utils.apply_threshold(value, thresh) total_num_cases = 0 total_correct = 0 for prediction, label in result: total_num_cases += 1.0 if prediction == label: total_correct += 1.0 acc = total_correct / total_num_cases # print(key, thresh, acc) if acc > max_acc: max_acc = acc threshold = thresh thresholds[key] = threshold for key, value in categorical_results.items(): result = utils.apply_threshold(value, thresholds[key]) mp_data[key] = result acc = utils.get_total_accuracy(mp_data) # print(acc) # Must complete this function! # return mp_data, thresholds return mp_data, thresholds
def enforce_single_threshold(categorical_results): single_threshold_data = {} thresholds = {} single_thresh = 0 merged = [] max_acc = 0 for k, v in categorical_results.items(): merged.extend(v) max_range_thresh = max(merged, key=lambda x: x[0]) min_range_thresh = min(merged, key=lambda x: x[0]) for thresh in np.arange(min_range_thresh[0], max_range_thresh[0], 0.01): for key, value in categorical_results.items(): result = utils.apply_threshold(value, thresh) single_threshold_data[key] = result acc = utils.get_total_accuracy(single_threshold_data) if (acc > max_acc): max_acc = acc single_thresh = thresh for key, value in categorical_results.items(): thresholds[key] = single_thresh result = utils.apply_threshold(value, thresholds[key]) single_threshold_data[key] = result # Must complete this function! #return single_threshold_data, thresholds return single_threshold_data, thresholds
def enforce_single_threshold(categorical_results): # Shamus O'Connor import numpy as np import utils single_threshold_data = {} thresholds = {} full_list = [] max_index = 0 # Index that returns max accuracy acc = [] univ_thresh = 0 thresh_num = 500 # Num of thresholds to try thresh = np.linspace(0, 1, thresh_num) for group in categorical_results.keys(): full_list += categorical_results[group] for t in thresh: proc_data = [] # Data of each race sample for thresholding proc_data = utils.apply_threshold(full_list, t) acc.append(utils.get_num_correct(proc_data) / len(proc_data)) # ACCURACY # acc.append(utils.apply_financials(proc_data)) # COST max_index = acc.index(max(acc)) univ_thresh = thresh[max_index] for race in categorical_results: subset = categorical_results[race] thresholds[race] = univ_thresh single_threshold_data[race] = utils.apply_threshold( subset, thresholds[race]) return single_threshold_data, thresholds
def enforce_maximum_profit(categorical_results): # Shamus O'Connor import numpy as np import utils mp_data = {} thresholds = {} for race in categorical_results: subset = categorical_results[race] max_index = 0 # Index that returns max accuracy acc = [] thresh_num = len(subset) # Num of thresholds to try thresh = np.linspace(0, 1, thresh_num) for t in thresh: proc_data = [] # Data of each race sample for thresholding proc_data = utils.apply_threshold(subset, t) acc.append(utils.get_num_correct(proc_data) / len(proc_data)) # ACCURACY # acc.append(utils.apply_financials(proc_data,True)) # COST max_index = acc.index(max(acc)) thresholds[race] = thresh[max_index] mp_data[race] = utils.apply_threshold(subset, thresholds[race]) return mp_data, thresholds
def enforce_equal_opportunity(categorical_results, epsilon): thresholds = {} equal_opportunity_data = {} tpr_data = {} for threshold in np.arange(0, 1, 0.01): for key, value in categorical_results.items(): t_data = utils.apply_threshold(value, threshold) tpr = utils.get_true_positive_rate(t_data) if (key not in tpr_data): tpr_data[key] = [] tpr_data[key].append([tpr, threshold]) keys = [*tpr_data] tpr_data_refined = [] for tpr_d_0 in tpr_data[keys[0]]: for tpr_d_1 in tpr_data[keys[1]]: if (abs(tpr_d_0[0] - tpr_d_1[0]) <= epsilon): tpr_data_refined.append([tpr_d_0, tpr_d_1]) tpr_data_refined_2 = [] for val in tpr_data_refined: for tpr_d_2 in tpr_data[keys[2]]: if (abs(tpr_d_2[0] - val[0][0]) <= epsilon): if (abs(tpr_d_2[0] - val[1][0]) <= epsilon): tpr_data_refined_2.append([val[0], val[1], tpr_d_2]) tpr_data_refined_3 = [] for val in tpr_data_refined_2: for tpr_d_3 in tpr_data[keys[3]]: if (abs(tpr_d_3[0] - val[0][0]) <= epsilon): if (abs(tpr_d_3[0] - val[1][0]) <= epsilon): if (abs(tpr_d_3[0] - val[2][0]) <= epsilon): tpr_data_refined_3.append( [val[0], val[1], val[2], tpr_d_3]) #print(len(tpr_data_refined_3)) max_acc = 0 temp = {} for thresh in tpr_data_refined_3: temp['African-American'] = utils.apply_threshold( categorical_results['African-American'], thresh[0][1]) temp['Caucasian'] = utils.apply_threshold( categorical_results['Caucasian'], thresh[1][1]) temp['Hispanic'] = utils.apply_threshold( categorical_results['Hispanic'], thresh[2][1]) temp['Other'] = utils.apply_threshold(categorical_results['Other'], thresh[3][1]) acc = utils.get_total_accuracy(temp) if (acc > max_acc): max_acc = acc thresholds['African-American'] = thresh[0][1] thresholds['Caucasian'] = thresh[1][1] thresholds['Hispanic'] = thresh[2][1] thresholds['Other'] = thresh[3][1] equal_opportunity_data = temp.copy() return equal_opportunity_data, thresholds
def enforce_demographic_parity(categorical_results, epsilon): demographic_parity_data = {} thresholds = {} npp = [] npp_data = {} for threshold in np.arange(0, 1, 0.01): for key, value in categorical_results.items(): t_data = utils.apply_threshold(value, threshold) npp = (utils.get_num_predicted_positives(t_data) / len(t_data)) if (key not in npp_data): npp_data[key] = [] npp_data[key].append([npp, threshold]) keys = [*npp_data] npp_data_refined = [] for npp_d_0 in npp_data[keys[0]]: for npp_d_1 in npp_data[keys[1]]: if (abs(npp_d_0[0] - npp_d_1[0]) <= epsilon): npp_data_refined.append([npp_d_0, npp_d_1]) npp_data_refined_2 = [] for val in npp_data_refined: for npp_d_2 in npp_data[keys[2]]: if (abs(npp_d_2[0] - val[0][0]) <= epsilon): if (abs(npp_d_2[0] - val[1][0]) <= epsilon): npp_data_refined_2.append([val[0], val[1], npp_d_2]) npp_data_refined_3 = [] for val in npp_data_refined_2: for npp_d_3 in npp_data[keys[3]]: if (abs(npp_d_3[0] - val[0][0]) <= epsilon): if (abs(npp_d_3[0] - val[1][0]) <= epsilon): if (abs(npp_d_3[0] - val[2][0]) <= epsilon): npp_data_refined_3.append( [val[0], val[1], val[2], npp_d_3]) max_acc = 0 temp = {} for thresh in npp_data_refined_3: temp['African-American'] = utils.apply_threshold( categorical_results['African-American'], thresh[0][1]) temp['Caucasian'] = utils.apply_threshold( categorical_results['Caucasian'], thresh[1][1]) temp['Hispanic'] = utils.apply_threshold( categorical_results['Hispanic'], thresh[2][1]) temp['Other'] = utils.apply_threshold(categorical_results['Other'], thresh[3][1]) acc = utils.get_total_accuracy(temp) if (acc > max_acc): max_acc = acc thresholds['African-American'] = thresh[0][1] thresholds['Caucasian'] = thresh[1][1] thresholds['Hispanic'] = thresh[2][1] thresholds['Other'] = thresh[3][1] demographic_parity_data = temp.copy() max_acc = 0 return demographic_parity_data, thresholds
def enforce_maximum_profit(categorical_results): mp_data = {} thresholds = {} a=categorical_results['African-American'] b=categorical_results['Caucasian'] c=categorical_results['Hispanic'] d=categorical_results['Other'] best_accuracy=0 best_threshold=None l1=l2=l3=l4=[] for i in range(10): l1.append(i/10) l2=l3=l4=l1 for i in (itertools.product(l1,l2,l3,l4)): arr1=u.apply_threshold(a, i[0]) arr2=u.apply_threshold(b, i[1]) arr3=u.apply_threshold(c, i[2]) arr4=u.apply_threshold(d, i[3]) d9={'African-American':arr1,'Caucasian':arr2,'Hispanic':arr3,'Other':arr4} acc=u.get_total_accuracy(d9) if(best_accuracy<acc): best_accuracy=acc best_threshold=[i[0],i[1],i[2],i[3]] mp_data={} mp_data=d9 d9={} ''' if(acc>=0.63): break ''' thresholds={'African-American':best_threshold[0], 'Caucasian':best_threshold[1], 'Hispanic':best_threshold[2], 'Other':best_threshold[3]} # Must complete this function! return mp_data, thresholds
def enforce_single_threshold(categorical_results): single_threshold_data = {} thresholds = {} a=categorical_results['African-American'] b=categorical_results['Caucasian'] c=categorical_results['Hispanic'] d=categorical_results['Other'] best_accuracy=0 best_threshold=None for i in range(100): theshold=i/100 arr1=u.apply_threshold(a, theshold) arr2=u.apply_threshold(b, theshold) arr3=u.apply_threshold(c, theshold) arr4=u.apply_threshold(d, theshold) d9={'African-American':arr1, 'Caucasian':arr2, 'Hispanic':arr3, 'Other':arr4} acc=u.get_total_accuracy(d9) if(best_accuracy<acc): best_accuracy=acc best_threshold=theshold single_threshold_data={} single_threshold_data =d9 d9={} thresholds={'African-American':best_threshold, 'Caucasian':best_threshold, 'Hispanic':best_threshold, 'Other':best_threshold} #Must complete this function! return single_threshold_data, thresholds #return None, None
def heat_and_threshold(self, image, box_list, rolling_threshold=1, current_threshold=1): heat = np.zeros_like(image[:, :, 0]).astype(np.float) # Add heat to each box in box list raw_heat = add_heat(heat, box_list) # Smoothen out heated windows based on time-averaging avg_heat = self.rolling_sum([heat])['heat'] # Apply threshold to help remove false positives raw_heat = apply_threshold(raw_heat, CURRENT_FRAME_HEAT_THRESHOLD ) # SETTINGS.CURRENT_FRAME_HEAT_THRESHOLD avg_heat = apply_threshold( avg_heat, ROLLING_SUM_HEAT_THRESHOLD) # SETTINGS.ROLLING_SUM_HEAT_THRESHOLD # Visualize the heatmap when displaying # TODO: if VideoMode; else (255) raw_heatmap = np.clip(raw_heat, 0, 255) avg_heatmap = np.clip(avg_heat, 0, 255) image = self.add_to_debugbar(image, avg_heatmap, 'Rolling Sum Heatmap', position='right') image = self.add_to_debugbar(image, raw_heatmap, 'Current Fr. Heatmap', position='left') # Find final boxes from heatmap using label function raw_labels = label(raw_heatmap) avg_labels = label(avg_heatmap) # Overlap Raw with Avg draw_img = draw_labeled_bboxes(image, raw_labels, color=(1, 0, 0), thickness=2, meta=False) # red draw_img = draw_labeled_bboxes(draw_img, avg_labels, meta=HEATMAP_METRICS) return draw_img, avg_heatmap, avg_labels
def process(image, svc, X_scaler): # Test the result on one single image image = mpimg.imread(image) draw_image = np.copy(image) windows = utils.slide_window(image, x_start_stop=x_start_stop, y_start_stop=y_start_stop, xy_window=(96, 96), xy_overlap=(0.75, 0.75)) hot_windows = utils.search_windows(image, windows, svc, X_scaler, color_space=color_space, spatial_size=spatial_size, hist_bins=hist_bins, orient=orient, pix_per_cell=pix_per_cell, cell_per_block=cell_per_block, hog_channel=hog_channel, spatial_feat=spatial_feat, hist_feat=hist_feat, hog_feat=hog_feat) window_img = utils.draw_boxes(draw_image, hot_windows, color=(0, 0, 255), thick=6) # Find the place were is the most overlapping boxes by drawing a Heatmap heat = np.zeros_like(window_img[:,:,0]).astype(np.float) heat = utils.add_heat(heat, hot_windows) heat = utils.apply_threshold(heat, 1) heatmap = np.clip(heat, 0, 255) labels = label(heatmap) draw_img = utils.draw_labeled_bboxes(image, labels) return draw_img
def process_video(img): global previous_heatmap global previous_states windows1, _ = utils.find_cars(img, 400, 656, 2.0, clf, scaler, p['orient'], p['pix_per_cell'], p['cell_per_block'], p['spatial_size'], p['hist_bins']) hot_windows = windows1 windows2, _ = utils.find_cars(img, 350, 550, 1.2, clf, scaler, p['orient'], p['pix_per_cell'], p['cell_per_block'], p['spatial_size'], p['hist_bins']) # hot_windows = windows1 + windows2 # windows3, _ = utils.find_cars(img, 350, 500, 0.8, clf, scaler, p['orient'], p['pix_per_cell'], p['cell_per_block'], # p['spatial_size'], p['hist_bins']) # hot_windows = windows1 + windows2 + windows3 # hot_windows = windows1 + windows2 heatmap = utils.add_heat(previous_heatmap, hot_windows) previous_heatmap = heatmap * 0.5 heatmap = utils.apply_threshold(heatmap, 10) img, states = utils.draw_labeled_bboxes(img, heatmap, previous_states) # Add new state, and remove last if bigger than 3 previous_states.append(states) number_of_states_to_keep = 10 if len(previous_states) > number_of_states_to_keep: previous_states = previous_states[-number_of_states_to_keep:] return img
def getThreshBuffHeatMap(self, thresh = 2): """ Return thresholded buffered heat map results. Existing maps are added together. Then threshold is applied :param: threshold to use :return: """ heatmap_cum = np.sum(self.heatmaps, axis=0) return apply_threshold(heatmap_cum, threshold=thresh)
def draw_heatmap_labels(self, shape): all_windows = [] for w in self.windows: all_windows.extend(w) heatmap = np.zeros(shape) heatmap = add_heat(heatmap, all_windows) heatmap = apply_threshold(heatmap, self.threshold) labels = label(heatmap) return labels, heatmap
def func(prediction_label_pairs): true_positives = [] for i in range(1, 101): threshold = float(i) / 100.0 eval_copy = list.copy(prediction_label_pairs) eval_copy = u.apply_threshold(eval_copy, threshold) TPR = u.get_positive_predictive_value(eval_copy) true_positives.append(TPR) return (true_positives)
def pipeline(img): img_draw_search = img.copy() img_draw_cars = img.copy() img_processed = process_image(img) img_search = img_processed[p_search.ystart:p_search.ystop, :, :] shape = img_search.shape img_search = cv2.resize( img_search, (np.int(shape[1] / p_search.scale), np.int(shape[0] / p_search.scale))) hog_features = get_hog_features(img_search, p_features)[0] heatmap = slide_and_search(img_search, img_draw_search, hog_features, classifier, p_search, p_features) heatmaps.update(heatmap) heatmap_sum = heatmaps.get_sum() heatmap_thresh = heatmap_sum.copy() apply_threshold(heatmap_thresh, 25) boxes = scipy_label(heatmap_thresh) draw_car_boxes(img_draw_cars, boxes) return img_draw_search, img_draw_cars, heatmap_sum
def detect(self, image, do_hog_once=True): out_windows = [] if do_hog_once: out_windows = self.find_multiscale(image) heatmap = utils.get_heatmap(image, out_windows) heatmap = self.smoother(heatmap) heatmap = utils.apply_threshold(heatmap,3) boxes = utils.get_labeled_boxes(heatmap) else: windows = utils.slide_window(image, x_start_stop=[None, None], y_start_stop=self.y_start_stop, xy_window=(64, 64), xy_overlap=(0.85, 0.85)) boxes = self.search_windows(image, windows) final_image = utils.draw_boxes(image, boxes, color=(0, 0, 255), thick=6) return final_image
def enforce_maximum_profit(categorical_results): # Must complete this function! mp_data = {} thresholds = {} for key in categorical_results.keys(): max_profit = float("-inf") data = categorical_results[key] thresholdList = [round(x[0], 2) for x in data] thresholdList = set(thresholdList) for t in thresholdList: threshed = apply_threshold(data, t) profit = apply_financials(threshed, True) if max_profit < profit: max_profit = profit mp_data[key] = threshed thresholds[key] = t return mp_data, thresholds
def enforce_predictive_parity(categorical_results, epsilon): # Kedaar Raghavendra Rao import utils as u predictive_parity_data = {} thresholds = {} max_total_acc = 0 temp_thresh = {} # {race, [thresh]} max_thresh = {} # {race, [thresh]} max_thresh_pred = {} # {race, [thresholded_pred]} temp_thresh_pred = {} # {race, [thresholded_pred]} race_cases = categorical_results #categorical_results contains [predicted value, actual label] for p in range(1, 100): prob = p / 100 temp_thresh_pred = {} temp_thresh = {} for race in race_cases: for thresh in range(1, 100): t = thresh / 100 x = {} x[race] = u.apply_threshold(race_cases[race], t) #thresholded_pred r_prob = u.get_positive_predictive_value( x[race] ) # u.get_num_predicted_positives(x[race]) / len(x[race]) if (compare_probs(r_prob, prob, epsilon)): temp_thresh[race] = [t] temp_thresh_pred[race] = x[race] break if len(temp_thresh_pred) == len(race_cases): total_accuracy = u.get_total_accuracy(temp_thresh_pred) if total_accuracy > max_total_acc: max_total_acc = total_accuracy max_thresh_pred = temp_thresh_pred max_thresh = temp_thresh predictive_parity_data = max_thresh_pred thresholds = max_thresh return predictive_parity_data, thresholds
def process_image(img): '''Pipeline to prepare video images with vehicle detection''' boxes = find_cars_multiscale(img, multiscale, clf, X_scaler, cspace, spatial_size, hist_bins, orient, pix_per_cell, cell_per_block, hog_channel) if len(Box_mem.boxes) >= n: Box_mem.boxes.pop(0) Box_mem.boxes.append(boxes) box_with_mem = [] for box in Box_mem.boxes: box_with_mem.extend(box) heat = np.zeros_like(img[:, :, 0]).astype(np.float) heat = add_heat(heat, box_with_mem) heat = apply_threshold(heat, 5) heatmap = np.clip(heat, 0, 255) labels = label(heatmap) heatmap_small = cv2.resize(heatmap, (320, 180)).astype(np.float32) norm = Normalize(vmin=0, vmax=24) heatmap_small = np.delete(cm.hot(norm(heatmap_small))*255.0, 3, 2) draw_img = draw_labeled_bboxes(np.copy(img), labels) draw_img[50:50+180, 50:50+320] = heatmap_small return draw_img # , heat
def enforce_equal_opportunity(categorical_results, epsilon): # Rishabh Sharma import utils as u thresholds = {} equal_opportunity_data = {} max_total_acc = 0 temp_thresh = {} # {race, [thresh]} max_thresh = {} # {race, [thresh]} max_thresh_pred = {} # {race, [thresholded_pred]} temp_thresh_pred = {} # {race, [thresholded_pred]} race_cases = categorical_results # categorical_results contains [predicted value, actual label] for p in range(1, 100): prob = p / 100 temp_thresh_pred = {} temp_thresh = {} for race in race_cases: for thresh in range(1, 100): t = thresh / 100 x = {} x[race] = u.apply_threshold(race_cases[race], t) #thresholded_pred r_prob = u.get_true_positive_rate(x[race]) if (compare_probs(r_prob, prob, epsilon)): temp_thresh[race] = t temp_thresh_pred[race] = x[race] break if len(temp_thresh_pred) == len(race_cases): total_accuracy = u.get_total_accuracy(temp_thresh_pred) if total_accuracy > max_total_acc: max_total_acc = total_accuracy max_thresh_pred = temp_thresh_pred max_thresh = temp_thresh equal_opportunity_data = max_thresh_pred thresholds = max_thresh return equal_opportunity_data, thresholds
def enforce_single_threshold(categorical_results): single_threshold_data = {} thresholds = {} thresholdList = [] for key in categorical_results.keys(): list = [round(x[0], 2) for x in categorical_results[key]] thresholdList += list thresholdList = set(thresholdList) max_profit = float("-inf") for t in thresholdList: dummy_data = {} for key in categorical_results.keys(): data = categorical_results[key] threshed = apply_threshold(data, t) dummy_data[key] = threshed profit = apply_financials(dummy_data) if max_profit < profit: max_profit = profit single_threshold_data = dummy_data for key in categorical_results.keys(): thresholds[key] = t return single_threshold_data, thresholds
def enforce_predictive_parity(categorical_results, epsilon): predictive_parity_data = {} thresholds = {} a=categorical_results['African-American'] b=categorical_results['Caucasian'] c=categorical_results['Hispanic'] d=categorical_results['Other'] a1=func(a) b1=func(b) c1=func(c) d1=func(d) best_accuracy=0 best_threshold=None arr=[] for i in range(100): n1=a1[i]-0.01 n2=a1[i]+0.01 for j in range(100): if(b1[j]>=n1 and b1[j]<=n2): for k in range(100): if(c1[k]>=n1 and c1[k]<=n2): for l in range(100): if(d1[l]>=n1 and d1[l]<=n2): p=[i/100,j/100,k/100,l/100] arr.append(p) best_accuracy=0 best_threshold=None testdata = list(set(tuple(x) for x in arr)) myarray = np.asarray(arr) unique_dict_a={} unique_dict_b={} unique_dict_c={} unique_dict_d={} uniqueValues=np.unique(myarray) for i in range(len(uniqueValues)): i1 = uniqueValues[i] unique_dict_a.update({ i1 : u.apply_threshold(a, i1) } ) unique_dict_b.update({ i1 : u.apply_threshold(b, i1) } ) unique_dict_c.update({ i1 : u.apply_threshold(c, i1) } ) unique_dict_d.update({ i1 : u.apply_threshold(d, i1) } ) for i in range(10000): if(arr[i][0] in unique_dict_a.keys()): arr1=unique_dict_a[arr[i][0]] else: arr1=u.apply_threshold(a, arr[i][0]) if(arr[i][0] in unique_dict_a.keys()): arr2=unique_dict_b[arr[i][1]] else: arr2=u.apply_threshold(b, arr[i][1]) if(arr[i][0] in unique_dict_a.keys()): arr3=unique_dict_c[arr[i][2]] else: arr3=u.apply_threshold(c, arr[i][2]) if(arr[i][0] in unique_dict_a.keys()): arr4=unique_dict_d[arr[i][3]] else: arr4=u.apply_threshold(d, arr[i][3]) d9={'African-American':arr1, 'Caucasian':arr2, 'Hispanic':arr3, 'Other':arr4} acc=u.get_total_accuracy(d9) if(best_accuracy<acc): best_accuracy=acc best_threshold=arr[i] predictive_parity_data={} predictive_parity_data =d9 d9={} thresholds={'African-American':best_threshold[0], 'Caucasian':best_threshold[1], 'Hispanic':best_threshold[2], 'Other':best_threshold[3]} # Must complete this function! return predictive_parity_data, thresholds
def search_car(img, dist_pickle): svc = dist_pickle["clf"] X_scaler = dist_pickle["scaler"] orient = dist_pickle["orient"] pix_per_cell = dist_pickle["pix_per_cell"] cell_per_block = dist_pickle["cell_per_block"] spatial_size = dist_pickle["spatial_size"] hist_bins = dist_pickle["hist_bins"] ystart = 400 ystop = 656 scale = 1.5 test_imgs = [] out_imgs = [] #plt.figure(figsize=(20,68)) draw_img = np.copy(img) windows = [] colorspace = 'YUV' # Can be RGB, HSV, LUV, HLS, YUV, YCrCb orient = 11 pix_per_cell = 16 cell_per_block = 2 hog_channel = 'ALL' # Can be 0, 1, 2, or "ALL" ystart = 400 ystop = 464 scale = 1.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 416 ystop = 480 scale = 1.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 496 scale = 1.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 432 ystop = 528 scale = 1.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 528 scale = 2.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 432 ystop = 560 scale = 2.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 596 scale = 3.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 464 ystop = 660 scale = 3.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) # window_list = utils.slide_window(img) heat_map = np.zeros(img.shape[:2]) heat_map = utils.add_heat(heat_map, windows) heat_map_thresholded = utils.apply_threshold(heat_map, 1) labels = label(heat_map_thresholded) draw_img = utils.draw_labeled_bboxes(draw_img, labels) return draw_img
def search_car(img): draw_img = np.copy(img) windows = [] colorspace = 'YUV' # Can be RGB, HSV, LUV, HLS, YUV, YCrCb orient = 11 pix_per_cell = 16 cell_per_block = 2 hog_channel = 'ALL' # Can be 0, 1, 2, or "ALL" ystart = 400 ystop = 464 scale = 1.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 416 ystop = 480 scale = 1.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 496 scale = 1.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 432 ystop = 528 scale = 1.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 528 scale = 2.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 432 ystop = 560 scale = 2.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 596 scale = 3.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 464 ystop = 660 scale = 3.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) # window_list = utils.slide_window(img) heat_map = np.zeros(img.shape[:2]) heat_map = utils.add_heat(heat_map, windows) heat_map_thresholded = utils.apply_threshold(heat_map, 1) labels = label(heat_map_thresholded) draw_img = utils.draw_labeled_bboxes(draw_img, labels) return draw_img
vis=True, feature_vec=True) plt.imsave(r"./output_images/" + str(i) + "_3_hog.jpg", hog_im, cmap='gray') for fname in images: print('processing ', fname, '...') img = mpimg.imread(fname) boxes = find_cars_multiscale(img, multiscale, clf, X_scaler, cspace, spatial_size, hist_bins, orient, pix_per_cell, cell_per_block, hog_channel) out_img = draw_boxes(img, boxes) plt.imsave(r"./output_images/" + fname.split('\\')[-1].split('.')[0] + "_5_bbox.jpg", out_img) heat = np.zeros_like(img[:, :, 0]).astype(np.float) # Add heat to each box in box list heat = add_heat(heat, boxes) # Apply threshold to help remove false positives heat = apply_threshold(heat, 2) # Visualize the heatmap when displaying heatmap = np.clip(heat, 0, 255) # Find final boxes from heatmap using label function labels = label(heatmap) # Prepare heatmap image overlay heatmap_small = cv2.resize(heatmap, (320, 180)).astype(np.float32) norm = Normalize(vmin=0, vmax=12) heatmap_small = np.delete(cm.hot(norm(heatmap_small))*255.0, 3, 2) draw_img = draw_labeled_bboxes(np.copy(img), labels) # Insert heatmap image overlay draw_img[50:50+180, 50:50+320] = heatmap_small plt.imsave(r"./output_images/" + fname.split('\\')[-1].split('.')[0] + "_6_heat.jpg", draw_img) # class to contain last n batch of boxes
def search_car(img): draw_img = np.copy(img) # img = img.astype(np.float32) / 255 # all_windows = [] # X_start_stop = [[None, None], [None, None], [None, None], [None, None]] # w0, w1, w2, w3 = 64, 96, 128, 196 # o0, o1, o2, o3 = 0.75, 0.75, 0.75, 0.75 # XY_window = [(w0, w0), (w1, w1), (w2, w2), (w3, w3)] # XY_overlap = [(o0, o0), (o1, o1), (o2, o2), (o3, o3)] # yi0, yi1, yi2, yi3 = 400, 400, 400, 400 # Y_start_stop = [[yi0, yi0 + w0 * 1.25], [yi1, yi1 + w1 * 1.25], [yi2, yi2 + w2 * 1.25], [yi3, yi3 + w3 * 1.25]] # # # # for i in range(len(Y_start_stop)): # windows = utils.slide_window(img, x_start_stop=X_start_stop[i], y_start_stop=Y_start_stop[i], # xy_window=XY_window[i], xy_overlap=XY_overlap[i]) # # all_windows += windows # on_windows = utils.search_windows(img, all_windows, svc, X_scaler, spatial_feat=True, hist_feat=True, # hog_channel='ALL') windows = [] colorspace = 'YUV' # Can be RGB, HSV, LUV, HLS, YUV, YCrCb orient = 11 pix_per_cell = 16 cell_per_block = 2 hog_channel = 'ALL' # Can be 0, 1, 2, or "ALL" ystart = 400 ystop = 464 scale = 1.0 windows+=(find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 416 ystop = 480 scale = 1.0 windows+=(find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 496 scale = 1.5 windows+=(find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 432 ystop = 528 scale = 1.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 528 scale = 2.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 432 ystop = 560 scale = 2.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 596 scale = 3.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 464 ystop = 660 scale = 3.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) # window_list = utils.slide_window(img) heat_map = np.zeros(img.shape[:2]) heat_map = utils.add_heat(heat_map,windows) heat_map_thresholded = utils.apply_threshold(heat_map,1) labels = label(heat_map_thresholded) draw_img = utils.draw_labeled_bboxes(draw_img,labels) # draw_img = utils.draw_windows(draw_img,on_windows) return draw_img
def enforce_predictive_parity(categorical_results, epsilon): predictive_parity_data = {} thresholds = {} thresholds_new = {} ppv = [] max_range_thresh = [1, 1, 1, 1] min_range_thresh = [0, 0, 0, 0] threshold_set = [] for key, val in categorical_results.items(): max_range_thresh.append( max(categorical_results[key], key=lambda x: x[0])[0]) min_range_thresh.append( min(categorical_results[key], key=lambda x: x[0])[0]) ppv_data = {} for threshold in np.arange(0, 1, 0.01): for key, value in categorical_results.items(): t_data = utils.apply_threshold(value, threshold) ppv = utils.get_positive_predictive_value(t_data) if (key not in ppv_data): ppv_data[key] = [] ppv_data[key].append([ppv, threshold]) keys = [*ppv_data] ppv_data_refined = [] for ppv_d_0 in ppv_data[keys[0]]: for ppv_d_1 in ppv_data[keys[1]]: if (abs(ppv_d_0[0] - ppv_d_1[0]) <= epsilon): ppv_data_refined.append([ppv_d_0, ppv_d_1]) ppv_data_refined_2 = [] for val in ppv_data_refined: for ppv_d_2 in ppv_data[keys[2]]: if (abs(ppv_d_2[0] - val[0][0]) <= epsilon): if (abs(ppv_d_2[0] - val[1][0]) <= epsilon): ppv_data_refined_2.append([val[0], val[1], ppv_d_2]) ppv_data_refined_3 = [] for val in ppv_data_refined_2: for ppv_d_3 in ppv_data[keys[3]]: if (abs(ppv_d_3[0] - val[0][0]) <= epsilon): if (abs(ppv_d_3[0] - val[1][0]) <= epsilon): if (abs(ppv_d_3[0] - val[2][0]) <= epsilon): ppv_data_refined_3.append( [val[0], val[1], val[2], ppv_d_3]) #print(len(ppv_data_refined_3)) max_acc = 0 temp = {} for thresh in ppv_data_refined_3: temp['African-American'] = utils.apply_threshold( categorical_results['African-American'], thresh[0][1]) temp['Caucasian'] = utils.apply_threshold( categorical_results['Caucasian'], thresh[1][1]) temp['Hispanic'] = utils.apply_threshold( categorical_results['Hispanic'], thresh[2][1]) temp['Other'] = utils.apply_threshold(categorical_results['Other'], thresh[3][1]) acc = utils.get_total_accuracy(temp) if (acc > max_acc): max_acc = acc thresholds['African-American'] = thresh[0][1] thresholds['Caucasian'] = thresh[1][1] thresholds['Hispanic'] = thresh[2][1] thresholds['Other'] = thresh[3][1] predictive_parity_data = temp.copy() max_acc = 0 return predictive_parity_data, thresholds
def search_car(img, framecount): draw_img = np.copy(img) windows = [] colorspace = 'YUV' # Can be RGB, HSV, LUV, HLS, YUV, YCrCb orient = 11 pix_per_cell = 16 cell_per_block = 2 hog_channel = 'ALL' # Can be 0, 1, 2, or "ALL" ystart = 400 ystop = 464 scale = 1.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 416 ystop = 480 scale = 1.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 496 scale = 1.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 432 ystop = 528 scale = 1.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 528 scale = 2.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 432 ystop = 560 scale = 2.0 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 400 ystop = 596 scale = 3.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) ystart = 464 ystop = 660 scale = 3.5 windows += (find_cars(img, ystart, ystop, scale, colorspace, hog_channel, svc, None, orient, pix_per_cell, cell_per_block, None, None)) # window_list = utils.slide_window(img) heat_map = np.zeros(img.shape[:2]) heat_map = utils.add_heat(heat_map, windows) heat_map_thresholded = utils.apply_threshold(heat_map, 1) labels = label(heat_map_thresholded) i = 0 VehicalPath = "./capture" if not os.path.exists(VehicalPath): os.makedirs(VehicalPath) draw_img, bboxlist = utils.draw_labeled_bboxes(draw_img, labels) for bbox in bboxlist: x1, y1 = bbox[0] x2, y2 = bbox[1] i = i + 1 if (x2 - x1 > 96) and (y2 - y1) > 96: cv2.imwrite("./capture/Vehical{}_{}.jpg".format(framecount, i), draw_img[x1:x2, y1:y2]) return VehicalPath
ystart = 300 ystop = 680 y_start_stop = [(350, 500), (400, 550), (350, 650)] scale = [1, 2, 3] cells_per_step = [1, 1, 1] t = time.time() hot_windows = detector.search_windows(image, y_start_stop=y_start_stop, scale=scale, cells_per_step=cells_per_step) t2 = time.time() print(round(t2 - t, 2), 'Seconds to search and identify {} windows'.format(len(hot_windows))) draw_heatmap = False if draw_heatmap: heatmap = np.zeros(draw_image.shape[:2]) heatmap = add_heat(heatmap, hot_windows) heatmap = apply_threshold(heatmap, 2) labels = label(heatmap) window_img = draw_labeled_bboxes(draw_image, labels) else: window_img = draw_boxes(draw_image, hot_windows, color=(0, 0, 255), thick=6) plt.imshow(window_img) # plt.savefig(ROOT + 'output_images/car/{}_labeled.jpg'.format(test_img)) plt.show()
def enforce_equal_opportunity(categorical_results, epsilon): thresholds = {} equal_opportunity_data = {} a=categorical_results['African-American'] b=categorical_results['Caucasian'] c=categorical_results['Hispanic'] d=categorical_results['Other'] (c1,d1,b1)=u.get_ROC_data(a, 'African-American') (c2,d2,b2)=u.get_ROC_data(b, 'Caucasian') (c3,d3,b3)=u.get_ROC_data(c, 'Hispanic') (c4,d4,b4)=u.get_ROC_data(d, 'Other') arr=[] for i in range(100): n1=c1[i]-0.01 n2=c1[i]+0.01 for j in range(100): if(c2[j]>=n1 and c2[j]<=n2): for k in range(100): if(c3[k]>=n1 and c3[k]<=n2): for l in range(100): if(c4[l]>=n1 and c4[l]<=n2): #print("i am coming here") p=[i/100.,j/100.,k/100.,l/100.] arr.append(p) accValue=0 thresholdList=None abc = arr.copy() for i in range(len(arr)): arr1=u.apply_threshold(a, abc[i][0]) arr2=u.apply_threshold(b, abc[i][1]) arr3=u.apply_threshold(c, abc[i][2]) arr4=u.apply_threshold(d, abc[i][3]) d9={'African-American':arr1, 'Caucasian':arr2, 'Hispanic':arr3, 'Other':arr4} acc=u.get_total_accuracy(d9) if(accValue<acc): accValue=acc thresholdList=arr[i] equal_opportunity_data={} equal_opportunity_data =d9 d9={} thresholds={'African-American':thresholdList[0], 'Caucasian':thresholdList[1], 'Hispanic':thresholdList[2], 'Other':thresholdList[3]} # Must complete this function! return equal_opportunity_data, thresholds