def plot_hamming_distance(prog_num):
plt.cla()
X_prog, y_prog = ascdata.get_bp_data(prog_num, 0, X, y)
ips = X_prog.T[1]
hamming_distances = X_prog.T[7]
plt.plot(ips, hamming_distances, "bx")
plt.savefig("stats" + "_" + str(prog_num) + "_" + "ips" + "_" + "hamming-distances" + "_" + "notcrazy" + ".png")
def plot_ir_percents(prog_num):
plt.cla()
X_prog, y_prog = ascdata.get_bp_data(prog_num, 0, X, y)
ips = X_prog.T[1]
ir_percents = X_prog.T[304]
plt.plot(ips, ir_percents, "bx")
plt.savefig("stats" + "_" + str(prog_num) + "_" + "ips" + "_" + "ir-percents" + "_" + "notcrazy" + ".png")
def plot_loss_value(prog_num):
plt.cla()
X_prog, y_prog = ascdata.get_bp_data(prog_num, 0, X, y)
ips = X_prog.T[1]
loss_values = y_prog
plt.plot(ips, loss_values, "bx")
plt.savefig("stats" + "_" + str(prog_num) + "_" + "ips" + "_" + "loss-values" + "_" + "notcrazy" + ".png")
def plot_target_histogram(prog_num):
print "target histogram for prog num", prog_num
plt.cla()
if prog_num == 0:
plt.hist(y)
else:
X_prog, y_prog = ascdata.get_bp_data(prog_num, 0, X, y)
plt.hist(y_prog)
plt.xlim([0, 100000])
plt.savefig("stats" + "_" + str(prog_num) + "_" + "target_hist" + "_" + "rawlim" + ".png")
def plot_predictions(prog_num, bp, inX, iny, wridge, all, test):
plt.cla()
X_bp, y_bp = ascdata.get_bp_data(prog_num, bp, inX, iny)
y_bp_pred = np.dot(X_bp, wridge)
plot_inputs = X_bp.T[2]
plt.plot(plot_inputs, y_bp, "b^")
plt.plot(plot_inputs, y_bp_pred, "go")
plt.savefig("bayes1" + "_" + str(prog_num) + "_" + str(bp) + "_" + test + "_" + all + ".png")
rms_bp = ascdata.RMSE(y_bp, y_bp_pred)
print "rms for prognum", prog_num, "at breakpoint", bp, rms_bp
r2_bp = ascdata.r2(y_bp, y_bp_pred)
print "r2 score for prognum", prog_num, "at breakpoint", bp, r2_bp
def plot_predictions(prog_num, bp, inX, iny):
plt.cla()
X_bp, y_bp = ascdata.get_bp_data(prog_num, bp, inX, iny)
iny_pred = clf.predict(X_bp)
plot_inputs = range(1,11)
plt.plot(plot_inputs, y_bp.flatten(), 'bx')
plt.plot(plot_inputs, iny_pred.flatten(),'ro')
plt.savefig("multitask_" + str(prog_num) + "_" + str(bp) + ".png")
bp_rms = ascdata.multi_RMSE(y_bp, iny_pred)
bp_r2 = ascdata.multi_r2(y_bp, iny_pred)
print "rms total for prognum", prog_num, "at breakpoint", bp, bp_rms
print "r2 total for prognum", prog_num, "at breakpoint", bp, bp_r2
### PLOT PREDICTIONS ###
print "PLOTTING PREDICTIONS"
def plot_predictions(inX, iny, iny_pred, prog_num, bp, test):
plt.cla()
plot_inputs = inX.T[2]
plt.plot(plot_inputs, iny, 'bx')
plt.plot(plot_inputs, iny_pred, 'ro')
plt.savefig("gaussianprocess_" + str(prog_num) + "_" + str(bp) + "_" + test +".png")
bp_rms = ascdata.RMSE(iny, iny_pred)
print "rms total for prognum", prog_num, "at breakpoint", bp, bp_rms
bp_r2 = ascdata.r2(iny, iny_pred)
print "r2 total for prognum", prog_num, "at breakpoint", bp, bp_r2
print "Predictions trained on all data"
# # good ip
X_bp1, y_bp1 = ascdata.get_bp_data(5, int("40024f",16), X, y)
# # bad ip
X_bp2, y_bp2 = ascdata.get_bp_data(1, int("4014d2",16), X, y)
y_pred_bp1 = get_predictions(X_bp1)
y_pred_bp2 = get_predictions(X_bp2)
plot_predictions(X_bp1, y_bp1, y_pred_bp1, 5, int("40024f",16), "total")
plot_predictions(X_bp2, y_bp2, y_pred_bp2, 1, int("4014d2",16), "total")
# # y_pred_bp2 = get_predictions(X_bp2)
# # y_pred_bp2_test = get_predictions(X_bp2_test)
# # y_pred_bp3 = get_predictions(X_bp3)
# #y_pred_bp3_test = get_predictions(X_bp3_test)
#
def plot_program(prog_num, bp, inX, iny, type):
plt.cla()
X_bp, y_bp = ascdata.get_bp_data(prog_num, bp, inX, iny)
plot_inputs = X_bp.T[2]
plt.plot(plot_inputs, y_bp, "b^")
plt.savefig("stats" + "_" + "lossvalues" + "_" + type + ".png")
import ascdata
import numpy as np
# ascdata.save_asc_data()
X, y = ascdata.load_nonzero_asc_data()
# X_prog1, y_prog1, X_prog2, y_prog2 = ascdata.load_shrunken_noprogs()
X_prog1, y_prog1 = ascdata.get_bp_data(5, 0, X, y)
X_prog2, y_prog2 = ascdata.get_bp_data(1, 0, X, y)
X_prog3, y_prog3 = ascdata.get_bp_data(4, 0, X, y)
X_notprog1, y_notprog1 = ascdata.get_all_but_prog_data(5, X, y)
X_notprog2, y_notprog2 = ascdata.get_all_but_prog_data(1, X, y)
X_notprog3, y_notprog3 = ascdata.get_all_but_prog_data(4, X, y)
print "prog 1 y lengths", y_prog1.shape, y_notprog1.shape
print "prog 2 y lengths", y_prog2.shape, y_notprog2.shape
print "prog 3 y lengths", y_prog3.shape, y_notprog3.shape
np.save("X_good_nonzero.npy",X_prog1)
np.save("y_good_nonzero.npy",y_prog1)
np.save("X_bad_nonzero.npy",X_prog2)
np.save("y_bad_nonzero.npy",y_prog2)
np.save("X_superbad_nonzero.npy",X_prog3)
np.save("y_superbad_nonzero.npy",y_prog3)
np.save("X_good_noprog_nonzero.npy",X_notprog1)
np.save("y_good_noprog_nonzero.npy",y_notprog1)
relu = lambda x: np.maximum(x, 0.0)
# Implement a 3-hidden layer neural network.
num_weights, predictions, logprob = \
make_nn_funs(layer_sizes=[34, 100, 100, 100, 1], nonlinearity=rbf)
# inputs, targets = build_toy_dataset()
inputs, targets = ascdata.get_asc_data()
objective = lambda weights, t: -logprob(weights, inputs, targets)
def plot_initial_data(inX, iny, ax):
plot_inputs = inX.T[2]
ax.plot(plot_inputs, iny.ravel(), 'bx')
X_bp1, y_bp1 = ascdata.get_bp_data(1, 4194659, inputs, targets)
X_bp2, y_bp2 = ascdata.get_bp_data(3, 4194873, inputs, targets)
# Set up figure.
fig = plt.figure(1, facecolor='white')
ax1 = fig.add_subplot(211, frameon=False)
ax2 = fig.add_subplot(212, frameon=False)
plot_initial_data(X_bp1, y_bp1, ax1)
plot_initial_data(X_bp2, y_bp2, ax2)
plt.show(block=False)
def plot_prediction_data(inX, iny, params, ax, subplot_no):
ax.cla()
