model.compile(loss='poisson', optimizer=adam) model.fit(C, Y, nb_epoch=10, batch_size=100, show_accuracy=True, verbose=0, validation_data=(C, Y)) # ----------------------------------------------------- pred_class = model.predict_classes(C, batch_size=200, verbose=0) s_nn_hat = hstack((zeros(k), pred_class, zeros(k))) x_nn_hat = N_DUDE.denoise_with_s(z[i], s_nn_hat, k) error_nn = N_DUDE.error_rate(x, x_nn_hat) print '1-D N-DUDE=', error_nn Error_One_NN_DUDE[i, k] = error_nn X_hat_One_NN_DUDE[k_max * i + k - 1, :] = x_nn_hat s_class = 3 s_nn_hat_cat = np_utils.to_categorical(s_nn_hat, s_class) emp_dist = dot(Z[i * n:(i + 1) * n, ], L[i * alpha_size:(i + 1) * alpha_size, ]) est_loss_nn_dude = mean(sum(emp_dist * s_nn_hat_cat, axis=1)) Est_Loss_One_NN_DUDE[i, k] = est_loss_nn_dude One_NN_End = time.time() One_NN_Duration = One_NN_End - One_NN_Start
verbose=0, validation_data=(C_Bind_Bound, Y_Bind_Bound)) Hist_Bind_Bound[4 * k - 4] = hist.history['acc'] Hist_Bind_Bound[4 * k - 3] = hist.history['loss'] Hist_Bind_Bound[4 * k - 2] = hist.history['val_acc'] Hist_Bind_Bound[4 * k - 1] = hist.history['val_loss'] # ----------------------------------------------------- pred_class_Bind_Bound = model.predict_classes(C, batch_size=200, verbose=0) s_nn_hat_Bind_Bound = hstack( (zeros(k), pred_class_Bind_Bound, zeros(k))) x_nn_hat_Bind_Bound = N_DUDE.denoise_with_s(z[i], s_nn_hat_Bind_Bound, k) error_nn_Bind_Bound = N_DUDE.error_rate(x, x_nn_hat_Bind_Bound) print '1-D N-DUDE Context Bind Bound=', error_nn_Bind_Bound Error_One_NN_DUDE_Bind_Bound[i, k] = error_nn_Bind_Bound X_hat_One_NN_DUDE_Bind_Bound[i * k_max + k - 1] = x_nn_hat_Bind_Bound One_NN_Bind_Bound_End = time.time() One_NN_Bind_Bound_Duration = One_NN_Bind_Bound_End - One_NN_Bind_Bound_Start ### 1-D N-DUDE Context Bind Normalization Bound ### One_NN_Bind_Norm_Bound_Start = time.time() model = Sequential() model.add(Dense(40, input_dim=2 * k * nb_classes, init='he_normal')) model.add(Activation('relu')) model.add(Dense(40, init='he_normal'))
model.fit(C_two, Y_two, nb_epoch=10, batch_size=100, show_accuracy=True, verbose=0, validation_data=(C_two, Y_two)) # ----------------------------------------------------- pred_class_two = model.predict_classes(C_two, batch_size=200, verbose=0) s_nn_hat_two = N_DUDE.mapping_mat_resize(pred_class_two, k, n) x_nn_hat_two = N_DUDE.denoise_with_s_Two_NN_DUDE(z[i], s_nn_hat_two) error_nn_two = N_DUDE.error_rate(x, x_nn_hat_two) print '2-D N-DUDE=', error_nn_two Error_Two_NN_DUDE_Pre[i, k] = error_nn_two X_hat_Two_NN_DUDE_Pre[k_max * i + k - 1, :] = x_nn_hat_two s_class_two = 3 s_nn_hat_cat_two = np_utils.to_categorical(s_nn_hat_two, s_class_two) emp_dist_two = dot(Z[i * n:(i + 1) * n, ], L[i * alpha_size:(i + 1) * alpha_size, ]) est_loss_nn_dude_two = mean( sum(emp_dist_two * s_nn_hat_cat_two, axis=1)) Est_Loss_Two_NN_DUDE_Pre[i, k] = est_loss_nn_dude_two ### Save the model & weights ### model_json = model.to_json()
model.compile(loss='poisson', optimizer=adam) model.fit(C, Y, nb_epoch=10, batch_size=100, show_accuracy=True, verbose=0, validation_data=(C, Y)) # ----------------------------------------------------- proba = model.predict_proba(C, batch_size=200, verbose=0) proba_new = RD.rand_new(proba) class_new = RD.make_new_class(proba_new) s_nn_hat = hstack((zeros(k), class_new, zeros(k))) x_nn_hat = N_DUDE.denoise_with_s(z[i], s_nn_hat, k) error_nn = N_DUDE.error_rate(x, x_nn_hat) print '1-D N-DUDE=', error_nn Error_One_NN_DUDE_RD[i, k] = error_nn X_hat_One_NN_DUDE_RD[k_max * i + k - 1, :] = x_nn_hat s_class = 3 s_nn_hat_cat = np_utils.to_categorical(s_nn_hat, s_class) emp_dist = dot(Z[i * n:(i + 1) * n, ], L[i * alpha_size:(i + 1) * alpha_size, ]) est_loss_nn_dude = mean(sum(emp_dist * s_nn_hat_cat, axis=1)) Est_Loss_NN_DUDE[i, k] = est_loss_nn_dude ### 1-D N-DUDE Context Bind ###
Y2, nb_epoch=1, batch_size=128, show_accuracy=False, verbose=1) model.fit(C1, Y1, nb_epoch=1, batch_size=128, show_accuracy=False, verbose=1) pred_class = model.predict_classes(C1, batch_size=128, verbose=0) s_nn_hat = hstack((zeros(k), pred_class, zeros(k))) x_nn_hat = N_DUDE.denoise_with_s(z[0], s_nn_hat, k) error_nn = N_DUDE.error_rate(x, x_nn_hat) print '1-D N-DUDE trained =', error_nn Error_One_NN_DUDE[0, k] = error_nn X_hat_One_NN_DUDE[k_max * 0, :] = x_nn_hat One_NN_End = time.time() One_NN_Duration = One_NN_End - One_NN_Start print 'Time =', One_NN_Duration print "---------------------------------------------------" res_file = '/HDD/user/yoon/Yoon_SV4/N-DUDE_SV4/NeuralDUDE_Delta_Variation/Result_Plot/Fine_Tune_One_ver5_28' np.savez(res_file, Error_One_DUDE=Error_One_DUDE, Error_One_NN_DUDE=Error_One_NN_DUDE, X_hat_One_NN_DUDE=X_hat_One_NN_DUDE)
model.compile(loss='poisson', optimizer=adam) model.fit(C, Y, nb_epoch=10, batch_size=100, show_accuracy=True, verbose=0, validation_data=(C, Y)) # ----------------------------------------------------- pred_class = model.predict_classes(C, batch_size=200, verbose=0) s_nn_hat = hstack((zeros(k), pred_class, zeros(k))) x_nn_hat = N_DUDE.denoise_with_s(z[i], s_nn_hat, k) error_nn = N_DUDE.error_rate(x, x_nn_hat) print '1-D N-DUDE=', error_nn Error_One_NN_DUDE[i, k] = error_nn X_hat_One_NN_DUDE[k_max * i + k - 1, :] = x_nn_hat s_class = 3 s_nn_hat_cat = np_utils.to_categorical(s_nn_hat, s_class) emp_dist = dot(Z[i * n:(i + 1) * n, ], L[i * alpha_size:(i + 1) * alpha_size, ]) est_loss_nn_dude = mean(sum(emp_dist * s_nn_hat_cat, axis=1)) Est_Loss_One_NN_DUDE[i, k] = est_loss_nn_dude ### 1-D N-DUDE Padding ### C_PD, Y_PD = N_DUDE.make_data_for_One_NN_DUDE_PD(
rms=RMSprop(lr=0.001, rho=0.9, epsilon=1e-06,clipnorm=1.5) adagrad=Adagrad(clipnorm=1.5) adam=Adam() adadelta=Adadelta() sgd=SGD(lr=0.01,decay=1e-6,momentum=0.95, nesterov=True, clipnorm=1.0) model.compile(loss='poisson', optimizer=adam) model.fit(C,Y,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C, Y)) # ----------------------------------------------------- pred_class=model.predict_classes(C, batch_size=200, verbose=0) s_nn_hat=hstack((zeros(k),pred_class,zeros(k))) x_nn_hat=N_DUDE.denoise_with_s(z[i],s_nn_hat,k) error_nn=N_DUDE.error_rate(x,x_nn_hat) print '1-D N-DUDE=', error_nn Error_One_NN_DUDE[i,k]=error_nn X_hat_One_NN_DUDE[k_max*i+k-1,:]=x_nn_hat s_class=3 s_nn_hat_cat=np_utils.to_categorical(s_nn_hat,s_class) emp_dist=dot(Z[i*n:(i+1)*n,],L[i*alpha_size:(i+1)*alpha_size,]) est_loss_nn_dude=mean(sum(emp_dist*s_nn_hat_cat,axis=1)) Est_Loss_One_NN_DUDE[i,k]=est_loss_nn_dude One_NN_End=time.time() One_NN_Duration=One_NN_End-One_NN_Start
model.fit(C_two2,Y_two2,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two2, Y_two2)) model.fit(C_two1,Y_two1,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two1, Y_two1)) model.fit(C_two10,Y_two10,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two10, Y_two10)) model.fit(C_two9,Y_two9,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two9, Y_two9)) model.fit(C_two8,Y_two8,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two8, Y_two8)) model.fit(C_two7,Y_two7,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two7, Y_two7)) model.fit(C_two6,Y_two6,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two6, Y_two6)) model.fit(C_two5,Y_two5,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two5, Y_two5)) model.fit(C_two4,Y_two4,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two4, Y_two4)) model.fit(C_two3,Y_two3,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two3, Y_two3)) model.fit(C_two2,Y_two2,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two2, Y_two2)) model.fit(C_two1,Y_two1,nb_epoch=10,batch_size=100,show_accuracy=True, verbose=0, validation_data=(C_two1, Y_two1)) pred_class_two=model.predict_classes(C_two1, batch_size=200, verbose=0) s_nn_hat_two=N_DUDE.mapping_mat_resize(pred_class_two,k,n) x_nn_hat_two=N_DUDE.denoise_with_s_Two_NN_DUDE(z[i],s_nn_hat_two) error_nn_two=N_DUDE.error_rate(x,x_nn_hat_two) print '2-D N-DUDE =', error_nn_two Error_Two_NN_DUDE[0,k]=error_nn_two X_hat_Two_NN_DUDE[k_max*0+k-1,:]=x_nn_hat_two One_NN_End=time.time() One_NN_Duration=One_NN_End-One_NN_Start print 'Time =', One_NN_Duration print "---------------------------------------------------" res_file='/HDD/user/yoon/Yoon_SV4/N-DUDE_SV4/NeuralDUDE_Delta_Variation/Result_Plot/Fine_Tune_Two_ver5_6' np.savez(res_file, Error_Two_DUDE=Error_Two_DUDE, Error_Two_NN_DUDE=Error_Two_NN_DUDE, X_hat_Two_NN_DUDE=X_hat_Two_NN_DUDE)
model.compile(loss='poisson', optimizer=adam) model.fit(C_Bind, Y_Bind, nb_epoch=10, show_accuracy=True, verbose=0, validation_data=(C_Bind, Y_Bind)) # ----------------------------------------------------- proba_bind = model.predict_proba(C, batch_size=200, verbose=0) proba_bind_new = RD.rand_new(proba_bind, delta[i]) class_bind_new = RD.make_new_class(proba_bind_new) s_nn_hat_Bind = hstack((zeros(k), class_bind_new, zeros(k))) x_nn_hat_Bind = N_DUDE.denoise_with_s(z[i], s_nn_hat_Bind, k) error_nn_Bind = N_DUDE.error_rate(x, x_nn_hat_Bind) print '1-D N-DUDE Context Bind=', error_nn_Bind Error_One_NN_DUDE_Bind_RD[i, k] = error_nn_Bind X_hat_One_NN_DUDE_Bind_RD[k_max * i + k - 1, :] = x_nn_hat_Bind s_class = 3 s_nn_hat_cat_Bind = np_utils.to_categorical(s_nn_hat_Bind, s_class) emp_dist = dot(Z[i * n:(i + 1) * n, ], L[i * alpha_size:(i + 1) * alpha_size, ]) est_loss_nn_dude_Bind = mean(sum(emp_dist * s_nn_hat_cat_Bind, axis=1)) Est_Loss_NN_DUDE_RD[i, k] = est_loss_nn_dude_Bind One_End = time.time() One = One_End - One_Start