from utils.utils import * from model import * import sys import os import math import time from utils.data_helper import data_loader from model import xavier_init, he_normal_init dataset = sys.argv[1] init_epsilon = float(sys.argv[2]) init_delta = float(sys.argv[3]) model_name = sys.argv[4] prev_iter = int(sys.argv[5]) mb_size, X_dim, width, height, channels, len_x_train, x_train, len_x_test, x_test = data_loader( dataset) graph = tf.Graph() with graph.as_default(): session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess = tf.Session(config=session_conf) with sess.as_default(): #input placeholder input_shape = [None, width, height, channels] filter_sizes = [5, 5, 5, 5, 5] hidden = 128 z_dim = 128 if dataset == 'celebA' or dataset == 'lsun':
def classifier_multi(): pathes = os.listdir("results/generated/") original = ["mnist", "fmnist", "cifar10", "svhn"] """ for dataset in original: _, X_dim, width, height, channels,len_x_train, x_train, y_train, len_x_test, x_test, y_test = data_loader(dataset) classifier_one(dataset, "original", x_train, y_train, len_x_train) tf.reset_default_graph() for path in pathes: info = path.split('_') dataset = info[0] model_name = path _, X_dim, width, height, channels,len_x_train, x_train, y_train, len_x_test, x_test, y_test = data_loader(dataset) data = np.load('results/generated/{}'.format(path)) x_target = data['x'] y_target = data['y'] classifier_one(dataset, model_name, x_target, y_target, len_x_train) tf.reset_default_graph() for path in pathes: info = path.split('_') dataset = info[0] model_name = path _, X_dim, width, height, channels,len_x_train, x_train, y_train, len_x_test, x_test, y_test = data_loader(dataset) data = np.load('results/generated/{}'.format(path)) x_target = data['x'] y_target = data['y'] x_target = np.append(x_target,x_train,axis=0) y_target = np.append(y_target,y_train,axis=0) model_name = model_name+"_augmented" classifier_one(dataset, model_name, x_target, y_target, len_x_train) tf.reset_default_graph() """ pathes = os.listdir("results_pure_noise/generated/") for path in pathes: info = path.split('_') dataset = info[0] model_name = path print(info) _, X_dim, width, height, channels, len_x_train, x_train, y_train, len_x_test, x_test, y_test = data_loader( dataset) data = np.load('results_pure_noise/generated/{}'.format(path)) x_target = data['x'] y_target = data['y'] #classifier_one(dataset, model_name, x_target, y_target, len_x_train) tf.reset_default_graph() for path in pathes: info = path.split('_') dataset = info[0] model_name = path _, X_dim, width, height, channels, len_x_train, x_train, y_train, len_x_test, x_test, y_test = data_loader( dataset) data = np.load('results_pure_noise/generated/{}'.format(path)) x_target = data['x'] y_target = data['y'] x_target = np.append(x_target, x_train, axis=0) y_target = np.append(y_target, y_train, axis=0) model_name = model_name + "_augmented" classifier_one(dataset, model_name, x_target, y_target, len_x_train) tf.reset_default_graph()
def classifier_one(dataset, model_name, x_target, y_target, len_x_target): NUM_CLASSES = 10 fp = open("classifier_result.txt", 'a') print("dataset: {}; model name: {} Evaluation start.".format( dataset, model_name)) _, X_dim, width, height, channels, len_x_train, x_train, y_train, len_x_test, x_test, y_test = data_loader( dataset) graph = tf.Graph() with graph.as_default(): session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess = tf.Session(config=session_conf) with sess.as_default(): #input placeholder input_shape = [None, width, height, channels] filter_sizes = [5, 5, 5, 5, 5] hidden = 128 n_filters = [channels, hidden, hidden * 2, hidden * 4] X = tf.placeholder(tf.float32, shape=[None, width, height, channels]) Y = tf.placeholder(tf.float32, shape=[None, NUM_CLASSES]) #discriminator variables W1 = tf.Variable(he_normal_init([5, 5, channels, hidden // 2])) W2 = tf.Variable(he_normal_init([5, 5, hidden // 2, hidden])) W3 = tf.Variable(he_normal_init([5, 5, hidden, hidden * 2])) W4 = tf.Variable(xavier_init([4 * 4 * hidden * 2, NUM_CLASSES])) b4 = tf.Variable(tf.zeros(shape=[NUM_CLASSES])) var_C = [W1, W2, W3, W4, b4] global_step = tf.Variable(0, name="global_step", trainable=False) C_real_logits = classifier(X, var_C) C_loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits_v2( labels=Y, logits=C_real_logits)) num_batches_per_epoch = int((len_x_target - 1) / mb_size) + 1 C_solver = tf.contrib.opt.AdamWOptimizer( weight_decay=1e-4, learning_rate=1e-3, beta1=0.5, beta2=0.9).minimize(C_loss, var_list=var_C, global_step=global_step) timestamp = str(int(time.time())) sess.run(tf.global_variables_initializer()) x_temp = np.append(x_test, x_test[:mb_size], axis=0) y_temp = np.append(y_test, y_test[:mb_size], axis=0) best_accuracy = 0.0 for it in range(num_batches_per_epoch * 500): X_mb, Y_mb = next_batch(mb_size, x_target, y_target) _, C_curr = sess.run([C_solver, C_loss], feed_dict={ X: X_mb, Y: Y_mb }) if it % 100 == 0: print('Iter: {}; C_loss: {:.4};'.format(it, C_curr)) if it % 1000 == 0: predictions = [] for jt in range(len_x_test // mb_size + 1): Xt_mb, Yt_mb = next_test_batch(jt, mb_size, x_temp, y_temp) _, C_pred = sess.run([C_solver, C_real_logits], feed_dict={ X: Xt_mb, Y: Yt_mb }) if len(predictions) == 0: predictions = C_pred else: predictions = np.append(predictions, C_pred, axis=0) predictions = predictions[:len_x_test] predictions = np.argmax(predictions, axis=1) correct_y = np.argmax(y_test, axis=1) correct_predictions = sum(predictions == correct_y) accuracy = correct_predictions / float(len_x_test) print('Iter: {}; accuracy: {:.4}; best accuracy: {:.4}'. format(it, accuracy, best_accuracy)) if accuracy > best_accuracy: best_accuracy = accuracy print("dataset: {} model name: {} with best accuracy: {:.4} fin.". format(dataset, model_name, best_accuracy)) print("dataset: {} model name: {} with best accuracy: {:.4} fin.". format(dataset, model_name, best_accuracy), file=fp) fp.close() sess.close() return
def classifier_multi(): pathes = os.listdir("results/generated/") original = ["mnist", "fmnist", "cifar10", "svhn"] for dataset in original: _, X_dim, width, height, channels, len_x_train, x_train, y_train, len_x_test, x_test, y_test = data_loader( dataset) for sigma in range(1, 16): x_target = gaussian_filter(x_train, sigma) classifier_one(dataset, "gaussian_sigma_{}".format(sigma), x_target, y_train, len_x_train) tf.reset_default_graph() for sigma in range(1, 16): x_target = gaussian_laplace(x_train, sigma) classifier_one(dataset, "laplace_sigma_{}".format(sigma), x_target, y_train, len_x_train) tf.reset_default_graph() for sigma in range(1, 16): sigma = sigma / 10.0 noise = np.random.normal(0.0, sigma, (x_train.shape)) noise = noise.reshape(x_train.shape) x_target = x_train + noise classifier_one(dataset, "gaussian_noise_sigma_{}".format(sigma), x_target, y_train, len_x_train) tf.reset_default_graph() for sigma in range(1, 16): sigma = sigma / 10.0 noise = np.random.laplace(0.0, sigma, (x_train.shape)) noise = noise.reshape(x_train.shape) x_target = x_train + noise classifier_one(dataset, "laplace_noise_scale_{}".format(sigma), x_target, y_train, len_x_train) tf.reset_default_graph() for sigma in [2, 3, 5, 7, 9]: x_target = uniform_filter(x_train, sigma) classifier_one(dataset, "uniform_filter_size_{}".format(sigma), x_target, y_train, len_x_train) tf.reset_default_graph() for sigma in [2, 3, 5, 7, 9]: x_target = median_filter(x_train, size=sigma) classifier_one(dataset, "median_filter_size_{}".format(sigma), x_target, y_train, len_x_train) tf.reset_default_graph()
config_gpu() params = get_params() if params['model'] == 'TextCNN': model_params = TextCNN_params.get_params() elif params['model'] == 'FastText': model_params = FastText_params.get_params() elif params['model'] == 'transformer': model_params = transformer_params.get_params() elif params['model'] == 'gcn': model_params = gcn_params.get_params() gcn_train.train_model(model_params) else: pass x_train, x_test, y_train, y_test, vocab, mlb = data_loader( params, is_rebuild_dataset=False) if params['model'] == 'FastText': x_train = [[i for i in x if i > 0] for x in x_train.tolist()] x_test = [[i for i in x if i > 0] for x in x_test.tolist()] x_train, x_test, vocab_size = add_ngram_features( model_params['ngram_range'], x_train, x_test, model_params['vocab_size']) x_train = tf.keras.preprocessing.sequence.pad_sequences( x_train, maxlen=model_params['maxlen'], padding='post', truncating='post') x_test = tf.keras.preprocessing.sequence.pad_sequences( x_test, maxlen=model_params['maxlen'],
from utils.params import get_params import model.FastText.FastText_params as FastText_params import model.TextCNN.TextCNN_params as TextCNN_params app = Flask(__name__) app.config['JSON_AS_ASCII'] = False err_result = {"errCode": "", "errMsg": "", "status": False} FastText_model = tf.keras.models.load_model( './results/FastText/2020-03-27-15-01') # FastText_model = tf.keras.models.load_model('./results/FastText/model.h5') TextCNN_model = tf.keras.models.load_model( './results/TextCNN/2020-03-27-21-41') _, _, _, _, vocab, mlb = data_loader(get_params()) labels = np.array(mlb.classes_) fastText_params = FastText_params.get_params() textCNN_params = TextCNN_params.get_params() @app.route("/FastText_service/", methods=['GET', 'POST']) def FastText_service(): try: text_list = request.json predict_data = convert(text_list, fastText_params) except Exception as e: return jsonify(err_result) else: preds = FastText_model.predict(predict_data)
def generate_one(dataset,model_name, z_dim,USE_DELTA): NUM_CLASSES = 10 mb_size, X_dim, width, height, channels,len_x_train, x_train, y_train, len_x_test, x_test, y_test = data_loader(dataset) graph = tf.Graph() with graph.as_default(): session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess = tf.Session(config=session_conf) with sess.as_default(): #input placeholder input_shape=[None, width, height, channels] filter_sizes=[5, 5, 5, 5, 5] hidden = 128 n_filters=[channels, hidden, hidden*2, hidden*4] X = tf.placeholder(tf.float32, shape=[None, width, height,channels]) Z_S = tf.placeholder(tf.float32, shape=[None, z_dim]) Z_noise = tf.placeholder(tf.float32, shape=[None, z_dim]) Y = tf.placeholder(tf.float32, shape=[None, NUM_CLASSES]) A_true_flat = X #generator variables var_G = [] #discriminator variables W1 = tf.Variable(he_normal_init([5,5,channels, hidden//2])) W2 = tf.Variable(he_normal_init([5,5, hidden//2,hidden])) W3 = tf.Variable(he_normal_init([5,5,hidden,hidden*2])) W4 = tf.Variable(xavier_init([4*4*hidden*2, 1])) b4 = tf.Variable(tf.zeros(shape=[1])) var_D = [W1,W2,W3,W4,b4] #classifier variables W4_c = tf.Variable(xavier_init([4*4*hidden*2, NUM_CLASSES])) b4_c = tf.Variable(tf.zeros(shape=[NUM_CLASSES])) var_C = [W1,W2,W3,W4_c,b4_c] var_D_C = [W1,W2,W3,W4,b4,W4_c,b4_c] global_step = tf.Variable(0, name="global_step", trainable=False) G_sample, G_zero, z_original, z_noise, z_noised = generator(input_shape, n_filters, filter_sizes, X, Z_noise, var_G, z_dim, Z_S, USE_DELTA) D_real, D_real_logits = discriminator(X, var_D) D_fake, D_fake_logits = discriminator(G_sample, var_D) C_real_logits = classifier(X, var_C) C_fake_logits = classifier(G_sample, var_C) D_real_loss = tf.nn.sigmoid_cross_entropy_with_logits( logits=D_real_logits, labels=tf.ones_like(D_real)) D_fake_loss = tf.nn.sigmoid_cross_entropy_with_logits( logits=D_fake_logits, labels=tf.zeros_like(D_fake)) D_S_loss = tf.reduce_mean(D_real_loss) + tf.reduce_mean(D_fake_loss) D_C_loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits_v2(labels = Y, logits = C_real_logits)) G_zero_loss = tf.reduce_mean(tf.pow(X - G_zero,2)) G_S_loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(logits=D_fake_logits, labels=tf.ones_like(D_fake))) G_C_loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits_v2(labels = Y, logits = C_fake_logits)) D_loss = D_S_loss + D_C_loss G_loss = G_S_loss + G_C_loss + G_zero_loss #sensitivity estimation latent_max = tf.reduce_max(z_original, axis = 0) latent_min = tf.reduce_min(z_original, axis = 0) tf.summary.image('Original',X) tf.summary.image('fake',G_sample) tf.summary.image('fake_zero', G_zero) tf.summary.scalar('D_loss', D_loss) tf.summary.scalar('D_S_loss',D_S_loss) tf.summary.scalar('D_C_loss',D_C_loss) tf.summary.scalar('G_zero_loss',G_zero_loss) tf.summary.scalar('G_S_loss',G_S_loss) tf.summary.scalar('G_C_loss',G_C_loss) tf.summary.scalar('G_loss',G_loss) tf.summary.histogram('z_original',z_original) tf.summary.histogram('z_noise',z_noise) tf.summary.histogram('z_noised',z_noised) merged = tf.summary.merge_all() num_batches_per_epoch = int((len_x_train-1)/mb_size) + 1 A_solver = tf.contrib.opt.AdamWOptimizer(weight_decay=1e-4,learning_rate=1e-4,beta1=0.5, beta2=0.9).minimize(G_zero_loss,var_list=var_G, global_step=global_step) D_solver = tf.contrib.opt.AdamWOptimizer(weight_decay=1e-4,learning_rate=1e-4,beta1=0.5, beta2=0.9).minimize(D_loss,var_list=var_D_C, global_step=global_step) G_solver = tf.contrib.opt.AdamWOptimizer(weight_decay=1e-4,learning_rate=1e-4,beta1=0.5, beta2=0.9).minimize(G_loss,var_list=var_G, global_step=global_step) timestamp = str(int(time.time())) out_dir = os.path.abspath(os.path.join(os.path.curdir, "results/models/"+ model_name)) checkpoint_dir = os.path.abspath(os.path.join(out_dir, "checkpoints")) checkpoint_prefix = os.path.join(checkpoint_dir, "model") if not os.path.exists("results/generated/"): os.makedirs("results/generated/") saver = tf.train.Saver(tf.global_variables()) sess.run(tf.global_variables_initializer()) saver.restore(sess,tf.train.latest_checkpoint(checkpoint_dir)) #calculate approximated global sensitivity for idx in range(num_batches_per_epoch): X_mb, Y_mb = next_batch(mb_size, x_train, y_train) enc_zero = np.zeros([mb_size,z_dim]).astype(np.float32) if USE_DELTA: enc_noise = np.random.normal(0.0,1.0,[mb_size,z_dim]).astype(np.float32) else: enc_noise = np.random.laplace(0.0,1.0,[mb_size,z_dim]).astype(np.float32) max_curr, min_curr = sess.run([latent_max,latent_min], feed_dict={ X: X_mb, Y: Y_mb, Z_noise: enc_zero, Z_S: enc_zero}) if idx == 0: z_max = max_curr z_min = min_curr else: z_max = np.maximum(z_max,max_curr) z_min = np.minimum(z_min,min_curr) z_sensitivity = np.abs(np.subtract(z_max,z_min)) #print("Approximated Global Sensitivity:") #print(z_sensitivity) z_sensitivity = np.tile(z_sensitivity,(mb_size,1)) x_train = np.append(x_train, X_mb, axis=0) y_train = np.append(y_train, Y_mb, axis=0) for i in range(num_batches_per_epoch): X_mb, Y_mb = next_test_batch(i, mb_size, x_train, y_train) enc_zero = np.zeros([mb_size,z_dim]).astype(np.float32) if USE_DELTA: enc_noise = np.random.normal(0.0,1.0,[mb_size,z_dim]).astype(np.float32) else: enc_noise = np.random.laplace(0.0,1.0,[mb_size,z_dim]).astype(np.float32) G_sample_curr = sess.run(G_sample, feed_dict={X: X_mb, Y: Y_mb, Z_noise: enc_noise, Z_S: z_sensitivity}) samples_flat = tf.reshape(G_sample_curr,[mb_size,width,height,channels]).eval() if i == 0: img_set = samples_flat label_set = Y_mb else: img_set = np.append(img_set, samples_flat, axis=0) label_set = np.append(label_set, Y_mb, axis=0) x_generated = img_set[:len_x_train] y_generated = label_set[:len_x_train] outfile = "results/generated/{}".format(model_name) np.savez(outfile, x=x_generated, y=y_generated) print("dataset: {} model name: {} fin.".format(dataset, model_name)) print("dataset: {} model name: {} fin.".format(dataset, model_name), file = fp) sess.close() return x_train, img_set
def fid_is_eval(): pathes = os.listdir("results_pure_noise/generated/") finished = [] tmp_path = [] for path in pathes: if path not in finished: tmp_path.append(path) pathes = tmp_path for path in pathes: fp = open("FID_IS_result.txt", 'a') info = path.split('_') dataset = info[0] model_name = path if dataset == "cifar10": data = np.load('results_pure_noise/generated/{}'.format(path)) mb_size, X_dim, width, height, channels, len_x_train, x_train, y_train, len_x_test, x_test, y_test = data_loader( dataset) real_set = x_train img_set = data['x'] print("Calculating Fréchet Inception Distance for {}".format( model_name)) print("Calculating Fréchet Inception Distance for {}".format( model_name), file=fp) fid_set_r = real_set * 255.0 fid_set_r = fid_set_r.astype(np.uint8) fid_set_r = np.transpose(fid_set_r, (0, 3, 1, 2)) fid_set_i = img_set * 255.0 fid_set_i = fid_set_i.astype(np.uint8) fid_set_i = np.transpose(fid_set_i, (0, 3, 1, 2)) #fid_set_i = fid_set_i[:256] #fid_set_r = fid_set_r[:256] fid_score = get_fid(fid_set_r, fid_set_i) print("FID: {}".format(fid_score)) print("FID: {}".format(fid_score), file=fp) tf.reset_default_graph() fp.close() fp = open("FID_IS_result.txt", 'a') print("Calculating inception score for {}".format(model_name)) print("Calculating inception score for {}".format(model_name), file=fp) is_set = img_set * 2.0 - 1.0 is_set = np.transpose(is_set, (0, 3, 1, 2)) #is_set = is_set[:256] mean, std = get_inception_score(is_set) print("mean: {} std: {}".format(mean, std)) print("mean: {} std: {}".format(mean, std), file=fp) tf.reset_default_graph() fp.close()