def plot_single_run():
height = 10
width = 10
m = mapgrid.generate_map(width=width, height=height)
v = vehicle.Vehicle(m, 10)
plot = plotter.LocatorPlot(v)
plot.plot_map()
# The placement of the vehicle need not be shown
# plot.plot_vehicle()
log.info("Start location:", str(v.location()))
log.info("Start color:", v.get_color())
for i in range(10):
v.move_unbound()
plot.plot_vehicle()
# found, x, y = locator.locate(v.map(), v.history(), v)
num_matches, x, y, possible_loc = locator.locate(v.map(), v.history())
log.info("End location:", v.location())
log.info("End color:", v.get_color())
if num_matches == 1:
loc_x, loc_y, dir = v.location()
log.info(
"Found on location", x, y, " and its correctness is " + str(
(num_matches == 1) and (x == loc_x) and (y == loc_y)))
else:
log.warning("Location not found!")
# Graph testing
"""
history_graphs = []
for i in range(4):
history_graph = graph_utils.history_to_digraph(v.history(), i)
history_graphs.append(history_graph)
graph_utils.digraph_history_analyzer(history_graph)
map_graph = graph_utils.map_to_digraph(m)
for i in range(4):
match = graph_utils.graph_matcher(map_graph, history_graphs[i])
print("Start direction", direction.Direction(i), "graph match:", match)
"""
# History error handling test
locator.locate_with_one_possible_error(v.map(), v.history())
locator.locate_with_one_possible_error(v.map(), v.history_error_one())
locator.locate_with_error_fallback(v.map(), v.history())
locator.locate_with_error_fallback(v.map(), v.history_error_one())
# locator.locate_with_movement_and_error_fallback(v.map(), v.history(), v, retries=10)
# locator.locate_with_movement_and_error_fallback(v.map(), v.history_error_one(), v, retries=10)
plot.show()
def test_history_error_generation(self):
m = mapgrid.generate_map(10, 10)
v = vehicle.Vehicle(m)
history_colors = v.history()[:, 1]
for i in range(10):
history_err_colors = v.history_error_one()[:, 1]
diff = np.sum(history_colors != history_err_colors)
self.assertEqual(diff, 1)
def run_MC_2(gridsize: int,
steps: int,
MC_iterations: int,
error=0.001) -> np.ndarray:
"""
Does Monte Carlo-simulation with given parametes.
Sensitivity and specificity, confusion 4-matrix,
return 2*2*2 np.ndarray, in which [0,:,:] is mean values and [1,:,:] is error
"""
# all confusion matrices (like ...0100,0010...)
results_mat = np.zeros((MC_iterations, 2, 2), dtype=int)
height = gridsize
width = gridsize
# Runs simulation in loop
for run_idx in range(MC_iterations):
m = mapgrid.generate_map(width=width, height=height)
v = vehicle.Vehicle(m)
for i in range(steps):
v.move_unbound()
num_found_exact, x, y = locator.locate(
v.map(), v.history_error(iteration_for_seed=run_idx,
error=error))[0:3]
num_found_inextact, x, y = locator.locate(v.map(), v.history())[0:3]
true_pos = 0
true_neg = 0
false_pos = 0
false_neg = 0
if (num_found_exact == 1) and (num_found_inextact == 1):
true_pos += 1
elif (num_found_exact != 1) and (num_found_inextact != 1):
true_neg += 1
elif (num_found_exact == 1) and (num_found_inextact != 1):
false_neg += 1
elif (num_found_exact != 1) and (num_found_inextact == 1):
false_pos += 1
confusion_mat = np.array(
((true_pos, false_neg), (false_pos, true_neg)))
results_mat[run_idx, :, :] = confusion_mat
#confusion mat
mean_mat = np.mean(results_mat, axis=0)
err_mat = np.std(results_mat, axis=0) / np.sqrt(MC_iterations)
return np.array((mean_mat, err_mat))
def movement_monte_carlo_plot_movenents():
start_time = time.perf_counter()
height = 20
width = 20
iterations = 10000
min_moves = 10
max_moves = 20
success = 0
wrong = 0
fail = 0
required_moves = np.zeros(max_moves + 1, dtype=int)
for i in range(iterations):
if i % 100 == 0:
log.debug("Running iteration", i)
m = mapgrid.generate_map(width=width, height=height)
v = vehicle.Vehicle(m, 10)
num_matches, x, y, possible_loc, movements = \
locator.locate_with_movement_and_error_fallback(m, v, max_moves, min_moves=min_moves)
if num_matches == 1:
correct_x, correct_y, direction = v.location()
if x == correct_x and y == correct_y:
success += 1
required_moves[movements] += 1
else:
wrong += 1
else:
fail += 1
#print("Success:", success)
#print("Wrong:", wrong)
#print("Fail", fail)
#print("Required moves", required_moves)
#print("Total time", time.perf_counter() - start_time)
x_axis = np.arange(1, 8)
y_axis = (required_moves / iterations)[10:17]
plotter.plot_histogram(x_axis,
y_axis,
xlabel="lisäaskelten lukumäärä",
ylim=None,
savename="lisa-askelten_lkm")
def run_MC(gridsize: int,
steps: int,
MC_iterations: int,
error=False) -> np.ndarray:
"""
Does Monte Carlo-simulation with given parametes.
"""
numFound_correct = 0
numFound_incorrect = 0
numNotFound = 0
height = gridsize
width = gridsize
# Runs simulation in loop
for run_idx in range(MC_iterations):
m = mapgrid.generate_map(width=width, height=height)
v = vehicle.Vehicle(m)
for i in range(steps):
v.move_unbound()
if error:
num_found, x, y = locator.locate(
v.map(), v.history_error(iteration_for_seed=run_idx))[0:3]
else:
num_found, x, y = locator.locate(v.map(), v.history())[0:3]
if num_found == 1:
loc_x, loc_y, dir = v.location()
if ((x == loc_x) and (y == loc_y)):
numFound_correct += 1
else:
numFound_incorrect += 1
elif num_found == 0:
numNotFound += 1
if not error:
log.warning("Not found!, gridsize:", gridsize, "steps", steps,
"error", error)
log.debug(" correct match:{:7.3f}".format(numFound_correct/(MC_iterations)) + \
", incorrect match:{:7.3f}".format(numFound_incorrect/(MC_iterations)) )
return np.array(
(numFound_correct / MC_iterations, numFound_incorrect / MC_iterations,
numNotFound / MC_iterations))
def movement_monte_carlo():
start_time = time.perf_counter()
height = 10
width = 10
iterations = 10000
min_moves = 9
max_moves = 30
success = 0
wrong = 0
fail = 0
required_moves = np.zeros(max_moves + 1, dtype=int)
for i in range(iterations):
if i % 100 == 0:
log.debug("Running iteration", i)
m = mapgrid.generate_map(width=width, height=height)
v = vehicle.Vehicle(m, 10)
num_matches, x, y, possible_loc, movements = \
locator.locate_with_movement_and_error_fallback(m, v, max_moves, min_moves=min_moves)
if num_matches == 1:
correct_x, correct_y, direction = v.location()
if x == correct_x and y == correct_y:
success += 1
required_moves[movements] += 1
else:
wrong += 1
else:
fail += 1
print("Success:", success)
print("Wrong:", wrong)
print("Fail", fail)
print("Required moves", required_moves)
print("Total time", time.perf_counter() - start_time)
def movement_single_run():
height = 10
width = 10
m = mapgrid.generate_map(width=width, height=height)
v = vehicle.Vehicle(m, 10)
plot = plotter.LocatorPlot(v)
plot.plot_map()
num_matches, x, y, possible_loc, movements = locator.locate_with_movement_and_error_fallback(
m, v, 20, plot)
if num_matches == 1:
loc_x, loc_y, dir = v.location()
log.info(
"Found on location", x, y, " and its correctness is " + str(
(num_matches == 1) and (x == loc_x) and (y == loc_y)))
log.info("Required movements:", movements)
else:
log.warning("Location not found!")
plot.show()
def run_MC_3(gridsize: int, steps: int, MC_iterations: int, error=0.001) -> np.ndarray:
"""
Does Monte Carlo-simulation with given parametes.
Meant fo error correction and error analysis
This time this function returns full array of results, so that can be used again
return
results_mat (N*2*2 np.ndarray) in which [n,:,:] one confusion 4-matrix of single MC_simulation n
error_info
# 0: number of found locations without error,
# 1: number of found locations with error,
# 2: if two both of those are equal to 1,
# 1 if the answer in error is correct, 0 else
results_mat_corr with error correction
"""
# all confusion matrices (like ...0100,0010...)
results_mat = np.zeros((MC_iterations, 2, 2), dtype=int)
error_info = np.zeros((MC_iterations, 3), dtype=int)
results_mat_corr = np.zeros((MC_iterations, 2, 2), dtype=int)
height = gridsize
width = gridsize
# Runs simulation in loop
for run_idx in range(MC_iterations):
m = mapgrid.generate_map(width=width, height=height)
v = vehicle.Vehicle(m)
for i in range(steps):
v.move_unbound()
err_hist = v.history_error(iteration_for_seed=run_idx, error=error)
num_found_exact, x_ext, y_ext = locator.locate(v.map(), v.history())[0:3]
num_found_inexact, x_err, y_err = locator.locate(v.map(), err_hist)[0:3]
num_found_corrected, x_corr, y_corr = locator.locate_with_error_fallback(v.map(), err_hist)[0:3]
true_pos = 0
true_neg = 0
false_pos = 0
false_neg = 0
true_pos_corr = 0
true_neg_corr = 0
false_pos_corr = 0
false_neg_corr = 0
error_info[run_idx, 0] = num_found_exact
error_info[run_idx, 1] = num_found_inexact
if (num_found_exact == 1) and (num_found_inexact == 1):
true_pos += 1
if not (x_err == x_ext) and (y_err == y_ext):
error_info[run_idx, 2] = 1
log.debug("Incorrect TP! args:", gridsize,steps,error)
elif (num_found_exact != 1) and (num_found_inexact != 1):
true_neg += 1
elif (num_found_exact == 1) and (num_found_inexact != 1):
false_neg += 1
elif (num_found_exact != 1) and (num_found_inexact == 1):
false_pos += 1
# corrected
if (num_found_exact == 1) and (num_found_corrected == 1):
true_pos_corr += 1
elif (num_found_exact != 1) and (num_found_corrected != 1):
true_neg_corr += 1
elif (num_found_exact == 1) and (num_found_corrected != 1):
false_neg_corr += 1
elif (num_found_exact != 1) and (num_found_corrected == 1):
false_pos_corr += 1
confusion_mat = np.array(((true_pos, false_neg), (false_pos, true_neg)))
results_mat[run_idx,:,:] = confusion_mat
conf_mat_corr = np.array(((true_pos_corr, false_neg_corr), (false_pos_corr, true_neg_corr)))
results_mat_corr[run_idx,:,:] = confusion_mat
return results_mat, error_info, results_mat_corr
def run_MC_4(gridsize: int, steps: int, MC_iterations: int, error=0.001) -> np.ndarray:
"""
Yet another way to run calculations. This time thi just returns all values
"""
# num found vector for every simulation in MC
num_found_exact = np.zeros((MC_iterations), dtype=int)
num_found_inexact = np.zeros((MC_iterations), dtype=int)
num_found_corrected = np.zeros((MC_iterations), dtype=int)
num_found_corrected_move = np.zeros((MC_iterations), dtype=int)
# if TP then if location correct
found_correct_exact = np.zeros((MC_iterations), dtype=int)
found_correct_inexact = np.zeros((MC_iterations), dtype=int)
found_correct_corrected = np.zeros((MC_iterations), dtype=int)
found_correct_corrected_move = np.zeros((MC_iterations), dtype=int)
min_moves = 9
max_moves = 30
required_moves = np.zeros(max_moves+1, dtype=int)
height = gridsize
width = gridsize
# Runs simulation in loop
for run_idx in range(MC_iterations):
m = mapgrid.generate_map(width=width, height=height)
v = vehicle.Vehicle(m)
for i in range(steps):
v.move_unbound()
err_hist = v.history_error(iteration_for_seed=run_idx, error=error)
num_found_exact[run_idx], x_ext, y_ext = locator.locate(v.map(), v.history())[0:3]
num_found_inexact[run_idx], x_err, y_err = locator.locate(v.map(), err_hist)[0:3]
num_found_corrected[run_idx], x_corr, y_corr = locator.locate_with_error_fallback(v.map(), err_hist)[0:3]
if num_found_exact[run_idx] == 1:
found_correct_exact[run_idx] = 1
if num_found_inexact[run_idx] == 1:
if x_err == x_ext and y_err == y_ext:
found_correct_inexact[run_idx] = 1
if num_found_corrected[run_idx] == 1:
if x_corr == x_ext and y_corr == y_ext:
found_correct_corrected[run_idx] = 1
# now the moving error correction from 'movement.py'
v2 = vehicle.Vehicle(m, 10, error=error)
num_found_corrected_move[run_idx], x_mov, y_mov, possible_loc, movements = \
locator.locate_with_movement_and_error_fallback(m, v2, max_moves, min_moves=min_moves)
if num_found_corrected_move[run_idx] == 1:
correct_x, correct_y, direction = v2.location()
if x_mov == correct_x and y_mov == correct_y:
found_correct_corrected_move[run_idx] = 1
required_moves[movements] += 1
return num_found_exact, num_found_inexact, num_found_corrected, num_found_corrected_move, \
found_correct_exact, found_correct_inexact, found_correct_corrected, found_correct_corrected_move, required_moves