# "track_distance_projected_along_half_angle_vec_exit",
"lane_distance_along_curve_secant_entry", # Distance of lane center line to curve secant ceter point at 0 degree angle
# "lane_distance_along_curve_secant_exit", # Distance of lane center line to curve secant ceter point at 180 degree angle
# "oneway_entry", # Is entry way a oneway street?
# "oneway_exit", # Is exit way a oneway street?
"curvature_entry", # Curvature of entry way over INT_DIST
# "curvature_exit", # Curvature of exit way over INT_DIST
"vehicle_speed_entry", # Measured vehicle speed on entry way at INT_DIST
# "vehicle_speed_exit", # Measured vehicle speed on exit way at INT_DIST
# "lane_count_entry", # Total number of lanes in entry way
# "lane_count_exit", # Total number of lanes in exit way
# "has_right_of_way", # Does the vehicle with the respective manoeuver have right of way at the intersection?
"curve_secant_dist"
]
kitti_samples = automatic_test.load_samples('../data/training_data/samples_kitti/samples.pickle')
darmstadt_samples = automatic_test.load_samples('../data/training_data/samples_darmstadt/samples.pickle')
samples = kitti_samples + darmstadt_samples
select_label_method(samples, 'y_distances')
random.shuffle(samples)
sub_samples, test_samples = automatic_test.get_partitioned_samples(samples, 0.8)
train_samples, validation_samples = automatic_test.get_partitioned_samples(sub_samples, 0.75)
# train_samples, validation_samples = automatic_test.get_cross_validation_samples(sub_samples, 4)
rf_algo = regressors.RandomForestAlgorithm(feature_list, single_target_variable=False, random_state=random, n_estimators=27, max_features=12, max_leaf_nodes=5)
rf_algo2 = regressors.RandomForestAlgorithm(feature_list2, single_target_variable=False, random_state=random, n_estimators=35, max_features=5, max_leaf_nodes=8)
algos = [rf_algo, rf_algo2]
results = automatic_test.test(algos, train_samples, test_samples, cross_validation=False)
# automatic_test.show_intersection_plot(results, test_samples, which_samples="best-worst-case", orientation="curve-secant")
automatic_test.show_intersection_plot(results, validation_samples, which_samples="all", orientation="curve-secant")
#!/usr/bin/python
#coding:utf-8
# Comparing random forest and Extra Trees algorithm
import sys
sys.path.append('../')
import automatic_test
import regressors
import reference_implementations
from extract_features import _feature_types
feature_list = _feature_types
rf_algo = regressors.RandomForestAlgorithm(feature_list)
et_algo = regressors.ExtraTreesAlgorithm(feature_list)
algos = [rf_algo, et_algo]
samples = automatic_test.load_samples('../data/training_data/samples_23_09_15/samples.pickle')
samples = automatic_test.normalize_features(samples)
train_sample_sets, test_sample_sets = automatic_test.get_cross_validation_samples(samples, 0.8, 5)
automatic_test.test(algos, train_sample_sets, test_sample_sets, cross_validation=True)
# results = automatic_test.predict(algos, test_samples)
# automatic_test.show_intersection_plot(results, test_samples, which_samples="best-worst-case")
"maxspeed_entry", # Allowed maximum speed on entry way
"maxspeed_exit", # Allowed maximum speed on exit way
"lane_distance_entry_lane_center", # Distance of lane center line to curve secant ceter point at 0 degree angle
"lane_distance_exit_lane_center", # Distance of lane center line to curve secant ceter point at 180 degree angle
"oneway_entry", # Is entry way a oneway street?
"oneway_exit", # Is exit way a oneway street?
"curvature_entry", # Curvature of entry way over INT_DIST
"curvature_exit", # Curvature of exit way over INT_DIST
"bicycle_designated_entry", # Is there a designated bicycle way in the entry street?
"bicycle_designated_exit", # Is there a designated bicycle way in the exit street?
"lane_count_entry", # Total number of lanes in entry way
"lane_count_exit", # Total number of lanes in exit way
"has_right_of_way", # Does the vehicle with the respective manoeuver have right of way at the intersection?
"curve_secant_dist" # Shortest distance from curve secant to intersection center
]
rf_algo_radii = regressors.RandomForestAlgorithm(feature_list)
rf_algo_distances = regressors.RandomForestAlgorithm(feature_list)
samples_radii = automatic_test.load_samples('../data/training_data/samples.pickle')
# samples_radii = automatic_test.normalize_features(samples)
samples_distances = automatic_test.load_samples('../data/training_data/samples.pickle')
# samples_distances = automatic_test.normalize_features(samples_distances)
select_label_method(samples_distances, 'y_distances')
train_samples_radii, test_samples_radii = automatic_test.get_cross_validation_samples(samples_radii, 0.7, 5)
train_samples_distances, test_samples_distances = automatic_test.get_cross_validation_samples(samples_distances, 0.7, 5)
automatic_test.test([rf_algo_radii], train_samples_radii, test_samples_radii, cross_validation=True)
automatic_test.test([rf_algo_distances], train_samples_distances, test_samples_distances, cross_validation=True)
# automatic_test.train([rf_algo_distances], train_samples_distances)
# results = automatic_test.predict([rf_algo_distances], test_samples_distances)
# automatic_test.show_intersection_plot(results, test_samples_distances, which_samples="all")
kitti_samples = automatic_test.load_samples('../data/training_data/samples_kitti/samples.pickle')
darmstadt_samples = automatic_test.load_samples('../data/training_data/samples_darmstadt/samples.pickle')
samples = kitti_samples + darmstadt_samples
random.shuffle(samples)
sub_samples, test_samples = automatic_test.get_partitioned_samples(samples, 0.8)
# train_sample_sets, validation_sample_sets = automatic_test.get_cross_validation_samples(sub_samples, 5)
random_state = random.get_state()
whole_algo = regressors.RandomForestAlgorithm(feature_list, random_state=random, max_features= 12, max_leaf_nodes=5, n_estimators= 27)
# point_algo = regressors.RandomForestAlgorithm(feature_list, single_target_variable=True, random_state=random, max_features=11, max_leaf_nodes=27,n_estimators=174)
# select_label_method(sub_samples, 'y_radii')
# train_samples, validation_samples = automatic_test.get_cross_validation_samples(sub_samples, 4)
# train_samples, validation_samples = automatic_test.get_partitioned_samples(sub_samples, 0.75)
# Test 01 and 02
# results = automatic_test.test([whole_algo, point_algo], train_samples, validation_samples, cross_validation=False, print_results=True)
# results = automatic_test.test([whole_algo], train_samples, validation_samples, cross_validation=True, print_results=True)
# automatic_test.show_intersection_plot(results, validation_samples, orientation="curve-secant")
whole_algo = regressors.RandomForestAlgorithm(feature_list_with_path, random_state=random, max_features= min(12, len(feature_list_with_path)), max_leaf_nodes=5, n_estimators= 27)
# point_algo = regressors.RandomForestAlgorithm(feature_list, single_target_variable=True, random_state=random, max_features=11, max_leaf_nodes=27,n_estimators=174)
select_label_method(sub_samples, 'y_distances')
select_label_method(test_samples, 'y_distances')
train_samples, validation_samples = automatic_test.get_cross_validation_samples(sub_samples, 4)
# train_samples, validation_samples = automatic_test.get_partitioned_samples(sub_samples, 0.75)
# Test 03 and 04
# results = automatic_test.test([whole_algo, point_algo], train_samples, validation_samples, cross_validation=False, print_results=True)
results = automatic_test.test([whole_algo], train_samples, validation_samples, cross_validation=True, print_results=True)
# automatic_test.show_intersection_plot(results, validation_samples, orientation="curve-secant")
sys.path.append('../')
import automatic_test
import regressors
import reference_implementations
import numpy as np
import matplotlib.pyplot as plt
feature_list = [
"lane_distance_entry_exact",
"curve_secant_dist",
"lane_distance_exit_exact",
"maxspeed_entry",
"vehicle_speed_entry",
"vehicle_speed_exit",
"curvature_exit",
"oneway_exit",
"lane_count_entry",
"has_right_of_way",
"curvature_entry"
]
kitti_samples = automatic_test.load_samples('../data/training_data/samples_23_09_15/samples.pickle')
kitti_samples = automatic_test.normalize_features(kitti_samples)
cmu_samples = automatic_test.load_samples('../data/training_data/samples_CMU/samples.pickle')
cmu_samples = automatic_test.normalize_features(cmu_samples)
kitti_train_samples, kitti_test_samples = automatic_test.get_partitioned_samples(kitti_samples, 0.8)
rf_algo = regressors.RandomForestAlgorithm(feature_list)
automatic_test.test([rf_algo], kitti_train_samples, kitti_test_samples, cross_validation=False)
automatic_test.test([rf_algo], kitti_train_samples, cmu_samples, cross_validation=False)
import automatic_test
import regressors
import reference_implementations
from extract_features import _feature_types
import extract_features
import numpy as np
import plot_helper
import matplotlib.pyplot as plt
import random
import pickle
kitti_samples = automatic_test.load_samples('../data/training_data/samples_15_10_08/samples.pickle')
darmstadt_samples = automatic_test.load_samples('../data/training_data/samples_15_10_20_darmstadt/samples.pickle')
extract_features.select_label_method(kitti_samples, 'y_distances')
extract_features.select_label_method(darmstadt_samples, 'y_distances')
random.shuffle(kitti_samples)
random.shuffle(darmstadt_samples)
kitti_train_samples, kitti_test_samples = automatic_test.get_partitioned_samples(kitti_samples, 0.7)
darmstadt_train_samples, darmstadt_test_samples = automatic_test.get_partitioned_samples(darmstadt_samples, 0.7)
train_samples = kitti_train_samples + darmstadt_train_samples
test_samples = kitti_test_samples + darmstadt_test_samples
rf_algo = regressors.RandomForestAlgorithm(_feature_types)
results = automatic_test.test([rf_algo], train_samples, test_samples)
angles = np.rad2deg( np.array([s['X'][_feature_types.index('intersection_angle')] for s in test_samples]) )
plt.plot(angles, results[rf_algo]['mse'], 'r.')
plt.show(block=False)
automatic_test.show_intersection_plot(results, test_samples, which_samples="worst-case", orientation="curve-secant")
"maxspeed_entry",
"vehicle_speed_entry",
"vehicle_speed_exit",
"curvature_exit",
"oneway_exit",
"lane_count_entry",
"has_right_of_way",
"curvature_entry"
]
mse_mean = np.array([])
mse_std = np.array([])
n_est_hist = np.array([])
samples = automatic_test.load_samples('../data/training_data/samples.pickle')
samples = automatic_test.normalize_features(samples)
train_sample_sets, test_sample_sets = automatic_test.get_cross_validation_samples(samples, 0.8, 5)
for n_est in range(1,40, 2):
rf_algo = regressors.RandomForestAlgorithm(feature_list, n_estimators = n_est)
results = automatic_test.test([rf_algo], train_sample_sets, test_sample_sets, cross_validation=True)
result_statistics = automatic_test.get_result_statistics(results)
mse_mean = np.append(mse_mean, result_statistics[rf_algo]['average_mse'])
mse_std = np.append(mse_std, result_statistics[rf_algo]['std_mse'])
n_est_hist = np.append(n_est_hist, n_est)
# Plot the results
plt.hold(True)
plt.plot(n_est_hist, mse_mean)
plt.plot(n_est_hist, mse_mean + mse_std, 'r-')
plt.plot(n_est_hist, mse_mean - mse_std, 'r-')
plt.xlabel('n_estimators')
plt.ylabel('average_mse')
plt.show()
"lane_distance_along_curve_secant_entry", # Distance of lane center line to curve secant ceter point at 0 degree angle
"lane_distance_along_curve_secant_exit", # Distance of lane center line to curve secant ceter point at 180 degree angle
"oneway_entry", # Is entry way a oneway street?
"oneway_exit", # Is exit way a oneway street?
"curvature_entry", # Curvature of entry way over INT_DIST
"curvature_exit", # Curvature of exit way over INT_DIST
"bicycle_designated_entry", # Is there a designated bicycle way in the entry street?
"bicycle_designated_exit", # Is there a designated bicycle way in the exit street?
"lane_count_entry", # Total number of lanes in entry way
"lane_count_exit", # Total number of lanes in exit way
"has_right_of_way", # Does the vehicle with the respective manoeuver have right of way at the intersection?
"curve_secant_dist" # Shortest distance from curve secant to intersection center
]
kitti_samples = automatic_test.load_samples('../data/training_data/samples_kitti/samples_rectified.pickle')
darmstadt_samples = automatic_test.load_samples('../data/training_data/samples_darmstadt/samples_rectified.pickle')
random.shuffle(kitti_samples)
random.shuffle(darmstadt_samples)
extract_features.select_label_method(kitti_samples, 'y_distances')
extract_features.select_label_method(darmstadt_samples, 'y_distances')
kitti_train_samples, test_samples = automatic_test.get_partitioned_samples(kitti_samples, 0.6)
train_samples = kitti_train_samples + darmstadt_samples
rf_algo = regressors.RandomForestAlgorithm(feature_list, single_target_variable=False)
al_algo = reference_implementations.AlhajyaseenAlgorithm(allow_rectification=False)
is_algo = reference_implementations.InterpolatingSplineAlgorithm()
algos = [rf_algo, al_algo, is_algo]
results = automatic_test.test(algos, train_samples, test_samples)
# automatic_test.show_intersection_plot(results, test_samples, which_samples="best-worst-case", orientation="curve-secant")
automatic_test.show_intersection_plot(results, test_samples, which_samples="all", orientation="curve-secant")
"curve_secant_dist", # Shortest distance from curve secant to intersection center
]
kitti_samples = automatic_test.load_samples("../data/training_data/samples_15_10_08/samples.pickle")
darmstadt_samples = automatic_test.load_samples("../data/training_data/samples_15_10_20_darmstadt/samples.pickle")
extract_features.select_label_method(kitti_samples, "y_distances")
extract_features.select_label_method(darmstadt_samples, "y_distances")
train_kitti, test_kitti = automatic_test.get_partitioned_samples(kitti_samples, 0.7)
train_darmstadt, test_darmstadt = automatic_test.get_partitioned_samples(darmstadt_samples, 0.7)
train_samples = train_kitti + train_darmstadt
test_samples = test_kitti + test_darmstadt
rf_algo = regressors.RandomForestAlgorithm(feature_list)
print "###### Non-rectified data ######"
print "------ Only KITTI ------"
automatic_test.test([rf_algo], train_kitti, test_kitti, cross_validation=False)
print "------ KITTI + Darmstadt ------"
automatic_test.test([rf_algo], train_samples, test_samples, cross_validation=False)
print "###### Rectified data ######"
kitti_samples_rectified = automatic_test.load_samples("../data/training_data/samples_15_10_08_rectified/samples.pickle")
darmstadt_samples_rectified = automatic_test.load_samples(
"../data/training_data/samples_15_10_20_darmstadt_rectified/samples.pickle"
)
extract_features.select_label_method(kitti_samples_rectified, "y_distances")
extract_features.select_label_method(darmstadt_samples_rectified, "y_distances")
train_kitti_rectified, test_kitti_rectified = automatic_test.get_partitioned_samples(kitti_samples_rectified, 0.7)
train_darmstadt_rectified, test_darmstadt_rectified = automatic_test.get_partitioned_samples(
darmstadt_samples_rectified, 0.7
)
train_samples_rectified = train_kitti_rectified + train_darmstadt_rectified
