if NEUTRAL_IMAGE_TEST:
fake_img = np.random.randint(0,255,size=ADVERSARIAL_IMAGE_SIZE, dtype=np.uint8).flatten()
fake_img[:] = 125
print(fake_img.shape)
print(turn(fake_img))
# ====================================
# Adversarial Image Analysis
# ====================================
if ANALYZE_EXISTING_IMAGE:
# with open("{}_random_solution_{}.pkl".format(TURN_NAME, SOLUTION_NUMBER), "rb") as f:
# output = pickle.load(f)
output = np.array(initial_solution)
p = Plot()
p.add_histogram("Adversarial Image", output)
p.plot(file_name="{}_random_solution_{}.html".format(TURN_NAME, SOLUTION_NUMBER), show=False)
print("Turn prouduced:", turn(output))
img = Image.fromarray(np.asarray(output.reshape(ADVERSARIAL_IMAGE_SIZE), dtype=np.uint8))
img.save("{}_random_solution_{}.png".format(TURN_NAME, SOLUTION_NUMBER))
exit()
# ======================================
# Adversarial Image Generation
# ======================================
if GENERATE_OPTIMIZED_ADVERSARIAL_IMAGES:
sample_img = np.ones(ADVERSARIAL_IMAGE_SIZE, dtype=np.uint8).flatten()*NEUTRAL_VALUE
print("Starting optimization.")
bounds = [(0,255)]*np.prod(ADVERSARIAL_IMAGE_SIZE)
checkpoint_file = "{}_random_solution_{}.py".format(TURN_NAME, SOLUTION_NUMBER)
def turn(addition, turn_name=TURN_NAME):
# Change the type of addition to match necessary image type
addition = np.asarray(addition, dtype=np.uint8)
# Reshape the addition to be the same shape as the image
addition = addition.reshape(ADVERSARIAL_IMAGE_SIZE)
# Collect all the deltas for this addition
all_delta = []
# print(addition.shape)
addition = Image.fromarray(addition)
# addition.save("initial_addition.png")
if USE_RANDOM_TRANSFORMATIONS:
# Cycle N random transformations
for transform in range(NUM_TRANSFORMATIONS):
print("[{:s}>{:s}]".format("-"*int(round(PROGRESS_LEN*transform/NUM_TRANSFORMATIONS)),
" "*int(PROGRESS_LEN - round(PROGRESS_LEN*transform/NUM_TRANSFORMATIONS))),end="\r")
# Train on the ability to turn
transformed_addition = generate_transformed_addition(addition)
if TRAIN_ON_REAL_IMAGES:
# Cycle all images real training images
random.shuffle(IMAGES_AND_STEERING)
for (original, sa) in IMAGES_AND_STEERING[:NUM_IMAGES]:
original = original.reshape(IMAGE_SHAPE)
# Combine the original image with the transformed addition
img = original + np.where(transformed_addition >= NEUTRAL_VALUE,
transformed_addition - NEUTRAL_VALUE, 0)
img -= np.where(transformed_addition < NEUTRAL_VALUE,
transformed_addition, 0)
# Identify the change in turning angle provided by the image
turn = float(MODEL.predict(np.array([img]), batch_size=1))
delta = turn - sa
all_delta.append(delta)
if SAVE_ALL_IMAGES:
img = Image.fromarray(np.asarray(img.reshape(IMAGE_SHAPE), dtype=np.uint8))
img_name = "{turn}_adv_imgs/({angle:+.2f})_{turn}_adversarial_{num:03d}-({orig:+.2f}).png".format(
turn=turn_name, angle=turn, num=transform, orig=sa)
img.save(img_name)
print("Saved '%s'"%img_name)
else:
# Identify the change in turning angle provided by the image
turn = float(MODEL.predict(np.array([transformed_addition]), batch_size=1))
all_delta.append(turn)
if SAVE_ALL_IMAGES:
img = Image.fromarray(np.asarray(transformed_addition.reshape(IMAGE_SHAPE), dtype=np.uint8))
img_name = "{turn}_adv_imgs/({angle:+.2f})_{turn}_adversarial_{num:03d}_NEUTRAL.png".format(
turn=turn_name, angle=turn, num=transform)
img.save(img_name)
print("Saved '%s'"%img_name)
print()
else:
# Do not use random transformations, just optimize over a
# single image that takes up the entire view field of the car.
addition = addition.resize(IMAGE_SHAPE[:-1])
adv_img = np.array(addition).reshape((1,)+IMAGE_SHAPE)
all_delta = [float(MODEL.predict(adv_img))]
if SAVE_ALL_IMAGES:
print("Done saving first round of images.")
exit()
if PLOT_DELTA_DISTRIBUTION:
print(all_delta)
p = Plot("Randomly Transformed Adversarial {:s} Turn Image (100 bins)".format(turn_name.title()),
"Normalized Turning Angle", "Probability")
p.add_histogram("Turn Angles", all_delta)
p.plot(show=False, file_name="{}_adversarial_turn_angles.html".format(turn_name),show_legend=False)
# Flip the sign if we are optimizing for right turns
avg_delta = sum(all_delta) / len(all_delta)
if TURN_NAME == "right": avg_delta = -avg_delta
# Return the average delta achieved by all transformations on all images
return avg_delta
print()
if PLOT_AGGREGATE_HISTOGRAMS:
print("Generating histograms for similarity checks...")
first = True
for test in unique["Test"]:
subset = data[data["Test"] == test]
machines = sorted(np.unique(subset["Machine"]))
p1 = Plot("Throughputs by machine for '%s' test"%test,
"Throughput", "Probability Mass")
p2 = Plot("Runtime by machine for '%s' test"%test,
"Runtime", "Probability Mass")
print("","processing test '%s'"%test)
for m in machines:
print("","","machine '%s'"%m)
p1.add_histogram(m,subset[subset["Machine"] == m]["Throughput"],
group=m)
p2.add_histogram(m,subset[subset["Machine"] == m]["Runtime"],
group=m, show_in_legend=False)
multiplot([[p1],[p2]], append=(not first), file_name=TEST_HIST_FILE)
first = False
if SHOW_COUNT_SUMMARY:
count_array = np.array(list(map(len, counts.values())))
print("Max: ", np.max(count_array))
print("Min: ", np.min(count_array))
print("Mean:", np.mean(count_array))
print()
print("# of Unique Configuraitons -- Number of trails")
for v in sorted(np.unique(count_array)):
num_configs = sum(count_array == v)