def init_graph(self): if self.sess is not None: return self.graph = tf.Graph() with self.graph.as_default(): tf1.set_random_seed(self.random_seed) self.feat_index = tf1.placeholder(tf.int32, shape=[None, None], name="feat_index") # None * F self.feat_value = tf1.placeholder(tf.float32, shape=[None, None], name="feat_value") # None * F self.label = tf1.placeholder(tf.float32, shape=[None, 1], name="label") # None * 1 self.dropout_keep_fm = tf1.placeholder(tf.float32, shape=[None], name="dropout_keep_fm") self.dropout_keep_deep = tf1.placeholder(tf.float32, shape=[None], name="dropout_keep_deep") self.train_phase = tf1.placeholder(tf.bool, name="train_phase") self.weights = self._initialize_weights() # 每一个feature 有一个 embedding # feature_embeddings.shape=(self.feature_size, self.embedding_size) # feat_index[i,j] 存储的是 第i条样本第j个field 对应的 feature_index # 1. 如果 field_j 是非 one hot 特征,则 field_j 不需要拆成多个 feature, # feat_index[:,j] 所有样本行都是同一个值,对应同一个 feature_index。 # 2. 如果 field_j 是 one hot 特征,则 field_j 需要拆成多个 feature,每个枚举值独立成一个 feature, # 此时 feat_index[:,j] 不同行是不同值,其值表示 枚举值Value(field_j) 对应的 feature_index. # 比如,第i=3行样本,第j=5个field表示颜色,其值是红色,红色被 onehot成 feature_index=13.则 feat_index[3,5]=13 # shape=(N样本数量 * field_size * K) # N 表示样本的数量 # K 是嵌入向量的长度, # 取出所有样本,每个 feature 的嵌入向量 # 对于one_hot 的 field,相当于只取出来枚举值对应的 feature_index 的嵌入向量, # 相当于每个 field 取一个,最终每条样本嵌入向量的数量还是 field 。 self.embeddings = tf.nn.embedding_lookup( self.weights["feature_embeddings"], # shape=(self.feature_size, self.embedding_size) self.feat_index # N * field_size ) # shape=(None * F * 1) # feat_value = tf.reshape(self.feat_value, shape=[-1, self.field_size, 1]) # None * F * 1 # FM部分的公式是 (x_i * x_j)(v_i*v_j)=(x_i*v_i)(x_j*v_j) # 这里先把每个特征的向量乘上其特征值。 self.embeddings = tf.multiply(self.embeddings, feat_value) # None * F * K # ---------- first order term ---------- # 对于k维,tf.reduce_sum(x,axis=k-1)的结果是对最里面一维所有元素进行求和 self.y_first_order = tf.nn.embedding_lookup(self.weights["feature_bias"], self.feat_index) # None * F * 1 self.y_first_order = tf.reduce_sum(tf.multiply(self.y_first_order, feat_value), 2) # None * F self.y_first_order = tf.nn.dropout(self.y_first_order, rate=1 - self.dropout_keep_fm[0]) # None * F # ---------- second order term --------------- # sum_square part self.summed_features_emb = tf.reduce_sum(self.embeddings, 1) # None * K self.summed_features_emb_square = tf.square(self.summed_features_emb) # None * K # square_sum part self.squared_features_emb = tf.square(self.embeddings) self.squared_sum_features_emb = tf.reduce_sum(self.squared_features_emb, 1) # None * K # second order self.y_second_order = 0.5 * tf.subtract(self.summed_features_emb_square, self.squared_sum_features_emb) # None * K self.y_second_order = tf.nn.dropout(self.y_second_order, rate=1 - self.dropout_keep_fm[1]) # None * K # ---------- Deep component ---------- self.y_deep = tf.reshape(self.embeddings, shape=[-1, self.field_size * self.embedding_size]) # None * (F*K) self.y_deep = tf.nn.dropout(self.y_deep, rate=1 - self.dropout_keep_deep[0]) for i in range(0, len(self.deep_layers)): self.y_deep = tf.add(tf.matmul(self.y_deep, self.weights["layer_%d" % i]), self.weights["bias_%d" % i]) # None * layer[i] * 1 if self.batch_norm: self.y_deep = self.batch_norm_layer(self.y_deep, train_phase=self.train_phase, scope_bn="bn_%d" % i) # None * layer[i] * 1 self.y_deep = self.deep_layers_activation(self.y_deep) self.y_deep = tf.nn.dropout(self.y_deep, rate=1 - self.dropout_keep_deep[1 + i]) # dropout at each Deep layer # ---------- DeepFM ---------- if self.use_fm and self.use_deep: concat_input = tf.concat([self.y_first_order, self.y_second_order, self.y_deep], axis=1) elif self.use_fm: concat_input = tf.concat([self.y_first_order, self.y_second_order], axis=1) elif self.use_deep: concat_input = self.y_deep self.out = tf.add(tf.matmul(concat_input, self.weights["concat_projection"]), self.weights["concat_bias"]) # loss if self.loss_type == "logloss": self.out = tf.nn.sigmoid(self.out, name='out') self.loss = tf1.losses.log_loss(self.label, self.out) elif self.loss_type == "mse": self.loss = tf.nn.l2_loss(tf.subtract(self.label, self.out)) # l2 regularization on weights 正则 if self.l2_reg > 0: self.loss += tf.contrib.layers.l2_regularizer( self.l2_reg)(self.weights["concat_projection"]) if self.use_deep: for i in range(len(self.deep_layers)): self.loss += tf.contrib.layers.l2_regularizer( self.l2_reg)(self.weights["layer_%d" % i]) # optimizer # 这里可以使用现成的ftrl优化损失 # optimizer = tf.train.FtrlOptimizer(lr) # lr: learningRate # gradients = optimizer.compute_gradients(loss) # cost # train_op = optimizer.apply_gradients(gradients, global_step=global_step) if self.optimizer_type == "adam": self.optimizer = tf1.train.AdamOptimizer(learning_rate=self.learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-8).minimize(self.loss) elif self.optimizer_type == "adagrad": self.optimizer = tf1.train.AdagradOptimizer(learning_rate=self.learning_rate, initial_accumulator_value=1e-8).minimize(self.loss) elif self.optimizer_type == "gd": self.optimizer = tf1.train.GradientDescentOptimizer(learning_rate=self.learning_rate).minimize( self.loss) elif self.optimizer_type == "momentum": self.optimizer = tf1.train.MomentumOptimizer(learning_rate=self.learning_rate, momentum=0.95).minimize( self.loss) # elif self.optimizer_type == "yellowfin": # self.optimizer = YFOptimizer(learning_rate=self.learning_rate, momentum=0.0).minimize( # self.loss) # init self.saver = tf1.train.Saver() init = tf1.global_variables_initializer() self.sess = self._init_session() self.sess.run(init) # number of params total_parameters = 0 for variable in self.weights.values(): shape = variable.get_shape() variable_parameters = 1 for dim in shape: variable_parameters *= dim.value total_parameters += variable_parameters if self.verbose > 0: print("#params: %d" % total_parameters)
from werkzeug.utils import secure_filename import numpy import matplotlib.pyplot as plt from io import BytesIO import base64 import keras from keras.backend import clear_session from keras.models import load_model from keras.optimizers import SGD, RMSprop from keras.losses import categorical_crossentropy from tensorflow.keras.preprocessing.image import ImageDataGenerator from flask import jsonify from tensorflow.compat.v1 import set_random_seed SEED = 7 np.random.seed(SEED) set_random_seed(SEED) graph = tf.get_default_graph() session = tf.Session(graph=tf.Graph()) with session.graph.as_default(): keras.backend.set_session(session) classifier = load_model('resnet_2048.h5') classifier.load_weights('resnet_2048_weights.h5', by_name=True) classifier._make_predict_function() #Pre-processing def crop_image_from_gray(img, tol=7): if img.ndim == 2: mask = img > tol return img[np.ix_(mask.any(1), mask.any(0))]
def train_unconstrained(dataset, group_info, epsilon=0.01, loops=10000, skip_steps=400): """Train unconstrained classifier. Args: dataset: train, vali and test sets group_info: group memberships on train, vali and test sets and thresholds epsilon: constraint slack loops: number of gradient steps skip_steps: steps to skip before snapshotting metrics """ tf.set_random_seed(121212) np.random.seed(212121) random.seed(333333) x_train, y_train, _, x_vali, y_vali, _, x_test, y_test, _ = dataset (group_memberships_list_train, group_memberships_list_vali, group_memberships_list_test, _) = group_info model = create_model(x_train.shape[-1]) features_tensor = tf.constant(x_train) labels_tensor = tf.constant(y_train) predictions = lambda: model(features_tensor) predictions_vali = lambda: model(x_vali) predictions_test = lambda: model(x_test) context = tfco.rate_context(predictions, labels=lambda: labels_tensor) overall_error = tfco.error_rate(context, penalty_loss=tfco.HingeLoss()) problem = tfco.RateMinimizationProblem(overall_error) loss_fn, update_ops_fn, _ = tfco.create_lagrangian_loss(problem) optimizer = tf.keras.optimizers.Adagrad(0.1) objectives_list = [] objectives_list_test = [] objectives_list_vali = [] violations_list = [] violations_list_test = [] violations_list_vali = [] model_weights = [] for ii in range(loops): update_ops_fn() optimizer.minimize(loss_fn, var_list=model.trainable_weights) # Snapshot iterate once in 1000 loops. if ii % skip_steps == 0: pred = np.reshape(predictions(), (-1, )) err = error_rate(y_train, pred) max_viol, viol_list = violation(y_train, pred, epsilon, group_memberships_list_train) pred_test = np.reshape(predictions_test(), (-1, )) err_test = error_rate(y_test, pred_test) _, viol_list_test = violation(y_test, pred_test, epsilon, group_memberships_list_test) pred_vali = np.reshape(predictions_vali(), (-1, )) err_vali = error_rate(y_vali, pred_vali) max_viol_vali, viol_list_vali = violation( y_vali, pred_vali, epsilon, group_memberships_list_vali) objectives_list.append(err) objectives_list_test.append(err_test) objectives_list_vali.append(err_vali) violations_list.append(viol_list) violations_list_test.append(viol_list_test) violations_list_vali.append(viol_list_vali) model_weights.append(model.get_weights()) if ii % 1000 == 0: print( "Epoch %d | Error = %.3f | Viol = %.3f | Viol_vali = %.3f" % (ii, err, max_viol, max_viol_vali), flush=True) # Best candidate index. best_ind = np.argmin(objectives_list) model.set_weights(model_weights[best_ind]) print("Train:") evaluate(x_train, y_train, model, epsilon, group_memberships_list_train) print("\nVali:") evaluate(x_vali, y_vali, model, epsilon, group_memberships_list_vali) print("\nTest:") evaluate(x_test, y_test, model, epsilon, group_memberships_list_test)
40000:], df.loc[:39999, "sentiment"].values, df.loc[40000:, 'sentiment'].values # hyper-parameters for LSTM-RNN model lstm_size = 128 lstm_layers = 1 batch_size = 128 l_rate = 0.001 n_epoch = 40 # Creating LSTM based RNN model using tensorflow import tensorflow.compat.v1 as tf tf.disable_v2_behavior() tf.reset_default_graph() tf.set_random_seed(123) # input placeholders with tf.name_scope("inputs"): tf_x = tf.placeholder(dtype=tf.int32, shape=(None, avg_seq_len), name="tf_x") tf_y = tf.placeholder(dtype=tf.float32, shape=(None), name="tf_y") tf_keepprob = tf.placeholder(tf.float32, name="tf_keepprob") # Call to the tf.nn.embedding_lookup() function in order to get our word vectors from the input placeholder # The call to that function will return a 3-D Tensor of dimensionality batch size by max sequence length by word vector dimensions. # we use lookup function to loop up the row in embedding matrix for each element in the placeholder tf_x with tf.name_scope("embeddings"): embed_x = tf.nn.embedding_lookup(embeddings_vector, tf_x, name="embed_x")
default=100000, help="Train up to this number of steps.") parser.add_argument( "--preprocess_threads", type=int, default=8, help="Number of CPU threads to use for parallel decoding of training " "images.") parser.add_argument("--save_checkpoint_secs", type=int, default=300, help="Seconds elapsed b/w saving models.") parser.add_argument( "--save_summary_secs", type=int, default=60, help="Seconds elapsed b/w saving tf logging summaries.") parser.add_argument( "--log_dir", default="/tmp/tensorboard_logs", help= "Directory for storing Tensorboard logging files; set to empty string '' to disable Tensorboard logging." ) args = parser.parse_args() tf.set_random_seed(args.seed) np.random.seed(args.seed) train(args)
import numpy as np import gym import tensorflow.compat.v1 as tf tf.disable_v2_behavior() np.random.seed(2) tf.set_random_seed(2) class Actor(object): def __init__(self, sess, n_features, action_bound, lr=0.0001): self.sess = sess self.s = tf.placeholder(tf.float32, [1, n_features], "state") self.a = tf.placeholder(tf.float32, None, name="act") self.td_error = tf.placeholder(tf.float32, None, name="td_error") # TD_error l1 = tf.layers.dense( inputs=self.s, units=30, # number of hidden units activation=tf.nn.relu, kernel_initializer=tf.random_normal_initializer(0., .1), # weights bias_initializer=tf.constant_initializer(0.1), # biases name='l1') mu = tf.layers.dense( inputs=l1, units=1, # number of hidden units activation=tf.nn.tanh,
def _maybe_seed(): if tf.executing_eagerly(): tf1.set_random_seed(42) return None return 42
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, num_epochs=100, minibatch_size=64, print_cost=True, isPlot=True): ops.reset_default_graph() tf.set_random_seed(1) seed = 3 (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] # 为当前的维度创建占位符 X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) # 初始化参数 parameters = initialize_parameters() # 前向传播 Z3 = forward_propagation(X, parameters) # 计算陈本 cost = compute_cost(Z3, Y) # 反向传播,由于框架已经实现了反向传播,我们只需要选择一个优化器就可了 optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) # 全局初始化所有变量 init = tf.global_variables_initializer() # 开始运行 with tf.Session() as sess: # 初始化参数 sess.run(init) # 开始便利数据集 for epoch in range(num_epochs): minibatch_cost = 0 num_minibatches = int(m / minibatch_size) seed = seed + 1 minibatches = cnn_utils.random_mini_batches( X_train, Y_train, minibatch_size, seed) # 对每个数据块进行处理 for minibatch in minibatches: (minibatch_X, minibatch_Y) = minibatch # 最小化这个数据化的成本(这里应该是进行一次梯度下降吧) _, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) minibatch_cost += temp_cost / num_minibatches if print_cost: if epoch % 5 == 0: print("当前的成本为: ", epoch, "代,成本为:" + str(minibatch_cost)) if epoch % 5 == 0: costs.append(minibatch_cost) if isPlot: plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('daishu') plt.title("learning rate = " + str(learning_rate)) plt.show() # 开始预测数据 # 计算当前的预测情况 predict_op = tf.arg_max(Z3, 1) corrent_prediction = tf.equal(predict_op, tf.arg_max(Y, 1)) # 计算准确度 accuracy = tf.reduce_mean(tf.cast(corrent_prediction, "float")) print("corrent_prediction accuracy= " + str(accuracy)) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuracy = accuracy.eval({X: X_test, Y: Y_test}) print("训练集准确度: " + str(train_accuracy)) print("测试集准确度: " + str(test_accuracy)) return (train_accuracy, test_accuracy, parameters)
from sklearn.model_selection import train_test_split def clear(): _ = system('clear') # Implementation of a simple MLP network with one hidden layer. Tested on the iris data set. # Requires: numpy, sklearn>=0.18.1, tensorflow>=1.0 # NOTE: In order to make the code simple, we rewrite x * W_1 + b_1 = x' * W_1' # where x' = [x | 1] and W_1' is the matrix W_1 appended with a new row with elements b_1's. # Similarly, for h * W_2 + b_2 RANDOM_SEED = 42 tf.set_random_seed(RANDOM_SEED) def init_weights(shape): """ Weight initialization """ weights = tf.random_normal(shape, stddev=0.1) return tf.Variable(weights) def forwardprop(X, w_1, w_2): """ Forward-propagation. IMPORTANT: yhat is not softmax since TensorFlow's softmax_cross_entropy_with_logits() does that internally. """ h = tf.nn.sigmoid(tf.matmul(X, w_1)) # The \sigma function yhat = tf.matmul(h, w_2) # The \varphi function
def test_vimco_and_gradient(self): dims = 5 # Dimension num_draws = int(1e3) num_batch_draws = int(3) seed = test_util.test_seed() with tf.GradientTape(persistent=True) as tape: f = lambda logu: tfp.vi.kl_reverse(logu, self_normalized=False) np_f = lambda logu: -logu s = tf.constant(1.) tape.watch(s) p = tfd.MultivariateNormalFullCovariance(covariance_matrix=tridiag( dims, diag_value=1, offdiag_value=0.5)) # Variance is very high when approximating Forward KL, so we make # scale_diag large. This ensures q "covers" p and thus Var_q[p/q] is # smaller. q = tfd.MultivariateNormalDiag(scale_diag=tf.tile([s], [dims])) vimco = tfp.vi.csiszar_vimco(f=f, p_log_prob=p.log_prob, q=q, num_draws=num_draws, num_batch_draws=num_batch_draws, seed=seed) # We want the seed to be the same since we will use computations # with the same underlying sample to show correctness of vimco. if tf.executing_eagerly(): tf1.set_random_seed(seed) x = q.sample(sample_shape=[num_draws, num_batch_draws], seed=seed) x = tf.stop_gradient(x) logu = p.log_prob(x) - q.log_prob(x) f_log_sum_u = f(tfp.stats.log_soomean_exp(logu, axis=0)[::-1][0]) q_log_prob_x = q.log_prob(x) grad_vimco = tape.gradient(vimco, s) grad_mean_f_log_sum_u = tape.gradient(f_log_sum_u, s) / num_batch_draws jacobian_logqx = tape.jacobian(q_log_prob_x, s) [ logu_, jacobian_logqx_, vimco_, grad_vimco_, f_log_sum_u_, grad_mean_f_log_sum_u_, ] = self.evaluate([ logu, jacobian_logqx, vimco, grad_vimco, f_log_sum_u, grad_mean_f_log_sum_u, ]) np_log_avg_u, np_log_sooavg_u = self._csiszar_vimco_helper(logu_) # Test VIMCO loss is correct. self.assertAllClose(np_f(np_log_avg_u).mean(axis=0), vimco_, rtol=1e-4, atol=1e-5) # Test gradient of VIMCO loss is correct. # # To make this computation we'll inject two gradients from TF: # - grad[mean(f(log(sum(p(x)/q(x)))))] # - jacobian[log(q(x))]. # # We now justify why using these (and only these) TF values for # ground-truth does not undermine the completeness of this test. # # Regarding `grad_mean_f_log_sum_u_`, note that we validate the # correctness of the zero-th order derivative (for each batch member). # Since `tfp.vi.csiszar_vimco_helper` itself does not manipulate any # gradient information, we can safely rely on TF. self.assertAllClose(np_f(np_log_avg_u), f_log_sum_u_, rtol=1e-4, atol=1e-5) # # Regarding `jacobian_logqx_`, note that testing the gradient of # `q.log_prob` is outside the scope of this unit-test thus we may safely # use TF to find it. # The `mean` is across batches and the `sum` is across iid samples. np_grad_vimco = (grad_mean_f_log_sum_u_ + np.mean(np.sum( jacobian_logqx_ * (np_f(np_log_avg_u) - np_f(np_log_sooavg_u)), axis=0), axis=0)) self.assertAllClose(np_grad_vimco, grad_vimco_, rtol=0.03, atol=1e-3)
def train_a_model(input_seq, mask_seq, label_seq, vocab_size, d_model, head, init_weights, print_output=True): # Clear all stuffs in default graph, so we can start fresh tf.reset_default_graph() with tf.device(USED_DEVICE): # We want each session to have different random seed, but we need each run to have the same random sequence tf.set_random_seed(random.randint(0, 65535)) batch_size = len(input_seq[0]) seq_len = len(input_seq[0][0]) sess = setup_tensorflow_session() (input_tensor, mask_tensor, output_tensor, disagreement_cost, logprob_tensor) = build_model(batch=batch_size, seq_len=seq_len, vocab_size=vocab_size, d_model=d_model, head=head) (label_tensor, train_op, loss, classification_loss) = build_train_graph(output_tensor=output_tensor, batch=batch_size, seq_len=seq_len, d_model=d_model, additional_costs=[disagreement_cost]) sess.run(tf.global_variables_initializer()) if init_weights is not None: set_all_variables(sess, init_weights) for i in range(LOCAL_TRAIN_EPOCH): if print_output: print('EPOCH: ' + str(i)) avg_loss = 0.0 avg_disagreement_loss = 0.0 avg_classification_loss = 0.0 avg_accuracy = 0.0 for input_sample, mask_sample, label_sample in zip(input_seq, mask_seq, label_seq): [output_vals, loss_vals, disagreement_cost_vals, classification_loss_vals, logprob_vals, _] = sess.run([output_tensor, loss, disagreement_cost, classification_loss, logprob_tensor, train_op], feed_dict={input_tensor: input_sample, mask_tensor: mask_sample, label_tensor: label_sample}) avg_loss = avg_loss + loss_vals avg_disagreement_loss = avg_disagreement_loss + disagreement_cost_vals avg_classification_loss = avg_classification_loss + classification_loss_vals labels = np.array(label_sample) predictions = (logprob_vals >= 0.5).astype(int) scores = (predictions == labels).astype(int) scores = np.average(scores) avg_accuracy = avg_accuracy + scores avg_loss = avg_loss / len(input_seq) avg_disagreement_loss = avg_disagreement_loss / len(input_seq) avg_classification_loss = avg_classification_loss / len(input_seq) avg_accuracy = avg_accuracy / len(input_seq) if print_output: print('===== TRAIN STAT =====') ''' print('=== Input Values ===') print(input_seq) print('=== Label Values ===') print(label_seq) print('=== Output Values ===') print(output_vals) ''' print('=== Loss Values ===') print(avg_loss) print('=== Classification Loss Values ===') print(avg_classification_loss) ''' print('=== Disagreement Loss Values ===') print(avg_disagreement_loss) ''' print('=== Accuracy ===') print(avg_accuracy) trained_weights = get_all_variables(sess) return [avg_loss, avg_disagreement_loss, avg_classification_loss, avg_accuracy, trained_weights]
def test_a_model(input_seq, mask_seq, label_seq, var_list, d_model, head, print_output=False): # Clear all stuffs in default graph, so we can start fresh tf.reset_default_graph() with tf.device(USED_DEVICE): # We want each session to have different random seed, but we need each run to have the same random sequence tf.set_random_seed(random.randint(0, 65535)) batch_size = len(input_seq[0]) seq_len = len(input_seq[0][0]) sess = setup_tensorflow_session() (input_tensor, mask_tensor, output_tensor, disagreement_cost, logprob_tensor) = build_model(batch=batch_size, seq_len=seq_len, vocab_size=VOCAB_SIZE, d_model=d_model, head=head) (label_tensor, loss, classification_loss) = build_loss_graph( output_tensor=output_tensor, batch=batch_size, seq_len=seq_len, d_model=d_model, additional_costs=[disagreement_cost]) sess.run(tf.global_variables_initializer()) set_all_variables(sess, var_list) avg_loss = 0.0 avg_disgreement_loss = 0.0 avg_classification_loss = 0.0 avg_accuracy = 0.0 for input_sample, mask_sample, label_sample in zip( input_seq, mask_seq, label_seq): [ output_vals, loss_vals, disagreement_cost_vals, classification_loss_vals, logprob_vals ] = sess.run( [ output_tensor, loss, disagreement_cost, classification_loss, logprob_tensor ], feed_dict={ input_tensor: input_sample, mask_tensor: mask_sample, label_tensor: label_sample }) print( '----------------------------------------------------------------------' ) for input_ids, output_v, label_v in zip( input_sample, logprob_vals, label_sample): input_decoded = decode_input_ids(input_ids) print(' --> ' + str(input_decoded) + ' => ' + str(output_v) + '/' + str(label_v)) print( '----------------------------------------------------------------------' ) avg_loss = avg_loss + loss_vals avg_disgreement_loss = avg_disgreement_loss + disagreement_cost_vals avg_classification_loss = avg_classification_loss + classification_loss_vals labels = np.array(label_sample) predictions = (logprob_vals >= 0.5).astype(int) scores = (predictions == labels).astype(int) scores = np.average(scores) avg_accuracy = avg_accuracy + scores avg_loss = avg_loss / len(input_seq) avg_disgreement_loss = avg_disgreement_loss / len(input_seq) avg_classification_loss = avg_classification_loss / len(input_seq) avg_accuracy = avg_accuracy / len(input_seq) if print_output: print('=== Input Values ===') print(input_seq) print('=== Label Values ===') print(label_seq) print('=== Output Values ===') print(output_vals) print('=== Loss Values ===') print(avg_loss) print('=== Classification Loss Values ===') print(avg_classification_loss) print('=== Disagreement Loss Values ===') print(avg_disgreement_loss) print('=== Accuracy ===') print(avg_accuracy) return avg_loss, avg_disgreement_loss, avg_classification_loss, avg_accuracy
# Increase reproducibility from numpy.random import seed seed(1) from tensorflow.compat.v1 import set_random_seed set_random_seed(2) import torch torch.manual_seed(0) import tensorflow as tf import numpy as np import pandas as pd import csv import os # Own import configs import data import pos import bert import models from train import train import utils import features print(tf.__version__) print(tf.keras.__version__) # setting device on GPU if available, else CPU T_DEVICE = 'cpu' if T_DEVICE == 'cpu': device = torch.device(T_DEVICE)
# import tensorflow as tf import tensorflow.compat.v1 as tf tf.disable_v2_behavior() tf.set_random_seed(777) # for reproducibility #1. 그래프 구현# # H(x) = Wx + b # X and Y data, H(x) = Y #x_train = [1, 2, 3] #y_train = [1, 2, 3] X = tf.placeholder(tf.float32, shape=[None]) Y = tf.placeholder(tf.float32, shape=[None]) # 1차원이고 값은 마음데로 넣을 수 있다. W = tf.Variable(tf.random_normal([1]), name="weight") b = tf.Variable(tf.random_normal([1]), name="bias") # rank # Our hypothesis XW+b hypothesis = X * W + b # cost/loss function cost = tf.reduce_mean(tf.square(hypothesis - Y)) #t = [1. , 2. , 3. , 4.] #tf.reduce_mean(t) ==> 2.5 평균을 내주는 명령어 # GradientDescent (Minimize/optimizer) optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
# Paper 12 # Predicting two classes only (Normal v COVID-19) from numpy.random import seed import math seed(42) from tensorflow.compat.v1 import set_random_seed set_random_seed(42) # libraries from keras.preprocessing.image import ImageDataGenerator import keras from sklearn.metrics import classification_report, confusion_matrix import numpy as np from keras.models import Model from keras.layers import Dense, Input, Dropout, Flatten from sklearn.metrics import roc_auc_score from sklearn.metrics import roc_auc_score from sklearn.metrics import roc_curve, auc, roc_auc_score from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score # GPU from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession import tensorflow as tf tf.keras.backend.clear_session() config = ConfigProto() config.gpu_options.allow_growth = True gpu_options = tf.compat.v1.GPUOptions(per_process_gpu_memory_fraction=0.333)
def get_graph(sess, seed, edges, vertices, adj, labels, source, sink, reward_states, env, other_sources=[], other_sinks=[]): # def get_graph(seed,sess,reward_states,env,itera): row, col = env.grid.shape eachepoch = FLAGS.eachepoch # Plot the resulting VF after each epoch or not features = np.eye( len(vertices), dtype=np.int32 ) # One-hot encoding for the features (i.e. feature-less) features = sparse_to_tuple(sp.lil_matrix(features)) np.random.seed(seed) tf.set_random_seed(seed) # features, adj, labels,\ # vertices, edges, row, col, source,\ # sink, other_sinks, obs2grid, grid2obs = load_data(append=FLAGS.app) # reward_states = map(grid2obs.get,reward_states) # pdb.set_trace() y_train, y_val,\ train_mask, val_mask = get_splits(labels, source, sink, reward_states) if sink is None: print("Sink not there, skipping this seed.") return None, None # Compute some baselines # start = time.time() # sc = SpectralClustering(2, affinity='precomputed', # n_init=5, eigen_solver='arpack', assign_labels='discretize') # sc.fit(adj.toarray()) # print('Time for spectral clustering {}'.format(time.time()-start)) # start = time.time() # cut = nx.minimum_cut(G,source,sink) # print("Total time for mincut {}".format(time.time()-start)) # Some preprocessing # features = preprocess_features(features) if FLAGS.model == 'gcn': support = [preprocess_adj(adj)] num_supports = 1 model_func = GCN elif FLAGS.model == 'gcn_cheby': support = chebyshev_polynomials(adj, FLAGS.max_degree) num_supports = 1 + FLAGS.max_degree model_func = GCN elif FLAGS.model == 'dense': support = [preprocess_adj(adj)] # Not used num_supports = 1 model_func = MLP else: raise ValueError('Invalid argument for model: ' + str(FLAGS.model)) # adj=normalize_adj(adj).toarray() # pdb.set_trace() adj = adj.toarray() deg = np.diag(np.sum(adj, axis=1)) laplacian = deg - adj # Define placeholders placeholders = { 'adj': tf.placeholder(tf.float32, shape=(None, None)), #unnormalized adjancy matrix 'support': [tf.sparse_placeholder(tf.float32) for _ in range(num_supports)], 'features': tf.sparse_placeholder(tf.float32, shape=tf.constant(features[2], dtype=tf.int64)), 'labels': tf.placeholder(tf.float32, shape=(None, y_train.shape[1])), 'labels_mask': tf.placeholder(tf.int32), 'dropout': tf.placeholder_with_default(0., shape=()), 'num_features_nonzero': tf.placeholder(tf.int32), # helper variable for sparse dropout 'learning_rate': tf.placeholder(tf.float32) } model = model_func(placeholders, edges, laplacian, input_dim=features[2][1], logging=True, FLAGS=FLAGS) sess.run(tf.global_variables_initializer()) feed_dict = construct_feed_dict(adj, features, support, y_train, train_mask, placeholders) feed_dict.update({placeholders['learning_rate']: FLAGS.learning_rate}) cost_val = [] start = time.time() for epoch in range(FLAGS.epochs): if eachepoch: outputs = sess.run([tf.nn.softmax(model.outputs)], feed_dict=feed_dict)[0] X = np.ones((row * col)) * -0.11 Xround = np.ones((row * col)) * .5 X[vertices] = outputs[:, 1] walls = np.where(env.grid.flatten() == 1) X[walls] = -0.1 Xround[vertices] = np.round(X[vertices]) if (Xround[vertices] == 0.).all(): X[0] = Xround[0] = 1. X = X.reshape(row, col) Xround = Xround.reshape(row, col) # path = np.ones((row*col))*0.25 # path[vertices] = .5 # path_sources = map(obs2grid.get, other_sources) # path[path_sources] = 0. # path_sinks = map(obs2grid.get, other_sinks) # path[path_sinks] = 1. # path=path.reshape(row,col) # A=map(obs2grid.get,cut[1][0]) # B=map(obs2grid.get,cut[1][1]) # view_cut=np.ones((row*col))*0.5 # view_cut[A] = 0 # view_cut[B] = 1 # view_cut=view_cut.reshape(row,col) # pdb.set_trace() # A=map(obs2grid.get,np.argwhere(sc.labels_ ==1).flatten() ) # B=map(obs2grid.get,np.argwhere(sc.labels_ ==0).flatten() ) # n_cut=np.ones((row*col))*0.5 # n_cut[A] = 0 # n_cut[B] = 1 # n_cut=n_cut.reshape(row,col) # pdb.set_trace() # if featplot is not None: # fig, ax = plt.subplots(6,1) # ax[0].imshow(path, interpolation='nearest') # ax[1].imshow(featplot.reshape(row,col), interpolation='nearest') # ax[2].imshow(Xround, interpolation='nearest') # ax[3].imshow(X, interpolation='nearest') # ax[4].imshow(view_cut, interpolation='nearest') # ax[5].imshow(n_cut, interpolation='nearest') # else: mask_map = np.ones((row * col)) * -0.11 mask_map[vertices] = y_train[:, 1] mask_map = mask_map.reshape(row, col) # fig, ax = plt.subplots(5,1) # ax[0].imshow(path, interpolation='nearest') # ax[1].imshow(Xround, interpolation='nearest') # ax[2].imshow(X, interpolation='nearest') # ax[3].imshow(view_cut, interpolation='nearest') # ax[4].imshow(n_cut, interpolation='nearest') fig, ax = plt.subplots(2, 1) # ax[0].imshow(path, interpolation='nearest') ax[0].imshow(X, interpolation='nearest') ax[1].imshow(mask_map, interpolation='nearest', cmap=new_map) # plt.show() # plt.close() directory = "diff_{}_{}/".format(FLAGS.app, row * col) if not os.path.exists(directory): os.makedirs(directory) plt.savefig("{}seed{}_{}.png".format(directory, seed, epoch)) plt.close() plt.clf() t = time.time() # pdb.set_trace() feed_dict = construct_feed_dict(adj, features, support, y_train, train_mask, placeholders) feed_dict.update({placeholders['learning_rate']: FLAGS.learning_rate}) outs = sess.run( [model.opt_op, model.loss, model.accuracy, model.learning_rate], feed_dict=feed_dict) print("Total time for gcn {}".format(time.time() - start)) print("Optimization Finished!") if not eachepoch: outputs = sess.run([tf.nn.softmax(model.outputs)], feed_dict=feed_dict)[0] X = np.ones((row * col)) * -0.11 Xround = np.ones((row * col)) * .5 X[vertices] = outputs[:, 1] walls = np.where(env.grid.flatten() == 1) X[walls] = -0.1 Xround[vertices] = np.round(X[vertices]) if (Xround[vertices] == 0.).all(): X[0] = Xround[0] = 1. X = X.reshape(row, col) Xround = Xround.reshape(row, col) mask_map = np.ones((row * col)) * -0.11 mask_map[vertices] = y_train[:, 1] mask_map = mask_map.reshape(row, col) # fig, ax = plt.subplots(1) # ax.imshow(X, interpolation='nearest',cmap=new_map) # # ax[1].imshow(mask_map, interpolation='nearest',cmap=new_map) # # plt.show() # # plt.close() # # sys.exit() # directory = "{}_{}/".format(FLAGS.app,row*col) # if not os.path.exists(directory): # os.makedirs(directory) # if FLAGS.fig: # myfig = '_'+FLAGS.fig + "_{}".format(epoch) # else: # myfig = '' # # plt.title('Diffusion-Based Approximate Value Function') # plt.xticks([]) # plt.yticks([]) # plt.savefig("{}seed{}_{}.png".format(directory,seed,myfig),bbox_inches='tight') # plt.close() # # pdb.set_trace() # sys.exit() # pdb.set_trace() initiation_set = list(np.argwhere(Xround.flatten()[vertices] == 0)) goals = np.argwhere(Xround.flatten()[vertices] == 1) # if len(initiation_set) > 1: # initiation_set = map(obs2grid.get,initiation_set.squeeze()) # if len(goals) > 1: # goals = map(obs2grid.get,goals.squeeze()) V_weights = outputs[:, 1] # pdb.set_trace() # sinks = list(np.argsort(X.flatten())[::-1]) # sinks = [sink for sink in sinks if sink in goals] # pdb.set_trace() tf.reset_default_graph() return initiation_set, V_weights
def main(argv): if len(argv) > 1: raise app.UsageError("Too many command-line arguments.") if FLAGS.seed is None: seed = np.random.randint(low=0, high=1e5) else: seed = FLAGS.seed np.random.seed(seed) random.seed(seed) tf.set_random_seed(seed) game = pyspiel.load_game_as_turn_based(FLAGS.game_name, {"players": pyspiel.GameParameter( FLAGS.n_players)}) env = rl_environment.Environment(game,seed=seed) env.reset() if FLAGS.heuristic_list: heuristic_list = FLAGS.heuristic_list if '_strategy' in heuristic_list[0]: FLAGS.meta_strategy_method = heuristic_list[0][:heuristic_list[0].index('_strategy')] else: FLAGS.meta_strategy_method = heuristic_list[0] else: heuristic_list = ["general_nash_strategy", "uniform_strategy"] if 'sp' in FLAGS.heuristic_to_add: heuristic_list.append("self_play_strategy") if 'weighted_ne' in FLAGS.heuristic_to_add: heuristic_list.append("weighted_NE_strategy") if 'prd' in FLAGS.heuristic_to_add: heuristic_list.append("prd_strategy") if not os.path.exists(FLAGS.root_result_folder): os.makedirs(FLAGS.root_result_folder) checkpoint_dir = 'se_'+FLAGS.game_name+str(FLAGS.n_players)+'_sims_'+str(FLAGS.sims_per_entry)+'_it_'+str(FLAGS.gpsro_iterations)+'_ep_'+str(FLAGS.number_training_episodes)+'_or_'+FLAGS.oracle_type checkpoint_dir += '_msl_'+",".join(heuristic_list) if FLAGS.switch_fast_slow: checkpoint_dir += '_sfs_'+'_fp_'+str(FLAGS.fast_oracle_period)+'_sp_'+str(FLAGS.slow_oracle_period) + '_arslr_'+str(FLAGS.ars_learning_rate)+'_arsn_'+str(FLAGS.noise)+'_arsnd_'+str(FLAGS.num_directions)+'_arsbd_'+str(FLAGS.num_best_directions)+'_epars_'+str(FLAGS.number_training_episodes_ars) elif FLAGS.switch_heuristic_regardless_of_oracle: checkpoint_dir += '_switch_heuristics_' if FLAGS.oracle_type == 'BR': oracle_flag_str = '' else: oracle_flag_str = '_hl_'+str(FLAGS.hidden_layer_size)+'_bs_'+str(FLAGS.batch_size)+'_nhl_'+str(FLAGS.n_hidden_layers) if FLAGS.oracle_type == 'DQN': oracle_flag_str += '_dqnlr_'+str(FLAGS.dqn_learning_rate)+'_tnuf_'+str(FLAGS.update_target_network_every)+'_lf_'+str(FLAGS.learn_every) else: oracle_flag_str += '_ls_'+str(FLAGS.loss_str)+'_nqbp_'+str(FLAGS.num_q_before_pi)+'_ec_'+str(FLAGS.entropy_cost)+'_clr_'+str(FLAGS.critic_learning_rate)+'_pilr_'+str(FLAGS.pi_learning_rate) checkpoint_dir = checkpoint_dir + oracle_flag_str+'_se_'+str(seed)+'_'+datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S') checkpoint_dir = os.path.join(os.getcwd(),FLAGS.root_result_folder, checkpoint_dir) writer = SummaryWriter(logdir=checkpoint_dir+'/log') if FLAGS.sbatch_run: sys.stdout = open(checkpoint_dir+'/stdout.txt','w+') # Initialize oracle and agents with tf.Session() as sess: if FLAGS.oracle_type == "DQN": slow_oracle, agents, agent_kwargs = init_dqn_responder(sess, env) elif FLAGS.oracle_type == "PG": slow_oracle, agents, agent_kwargs = init_pg_responder(sess, env) elif FLAGS.oracle_type == "BR": slow_oracle, agents = init_br_responder(env) agent_kwargs = None elif FLAGS.oracle_type == "ARS": slow_oracle, agents = init_ars_responder(sess, env) agent_kwargs = None sess.run(tf.global_variables_initializer()) if FLAGS.switch_fast_slow: fast_oracle, agents = init_ars_responder(sess=None, env=env) oracle_list = [[], []] oracle_list[0].append(slow_oracle) oracle_list[0].append(fast_oracle) oracle_list[1] = [FLAGS.oracle_type,'ARS'] else: oracle_list = None gpsro_looper(env, slow_oracle, oracle_list, agents, writer, quiesce=FLAGS.quiesce, checkpoint_dir=checkpoint_dir, seed=seed, heuristic_list=heuristic_list) writer.close()
def main(argv): del argv # Unused. tf.enable_resource_variables() tf.set_random_seed(FLAGS.seed) set_lr_schedule() set_custom_sparsity_map() folder_stub = os.path.join(FLAGS.training_method, str(FLAGS.end_sparsity), str(FLAGS.maskupdate_begin_step), str(FLAGS.maskupdate_end_step), str(FLAGS.maskupdate_frequency), str(FLAGS.drop_fraction), str(FLAGS.label_smoothing), str(FLAGS.weight_decay)) output_dir = FLAGS.output_dir if FLAGS.use_folder_stub: output_dir = os.path.join(output_dir, folder_stub) export_dir = os.path.join(output_dir, 'export_dir') # we pass the updated eval and train string to the params dictionary. params = {} params['output_dir'] = output_dir params['training_method'] = FLAGS.training_method params['use_tpu'] = FLAGS.use_tpu dataset_func = functools.partial( imagenet_input.ImageNetInput, data_dir=FLAGS.data_directory, transpose_input=False, num_parallel_calls=FLAGS.num_parallel_calls, use_bfloat16=False) imagenet_train, imagenet_eval = [ dataset_func(is_training=is_training) for is_training in [True, False] ] run_config = tpu_config.RunConfig( master=FLAGS.master, model_dir=output_dir, save_checkpoints_steps=FLAGS.steps_per_checkpoint, keep_checkpoint_max=FLAGS.keep_checkpoint_max, session_config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=False), tpu_config=tpu_config.TPUConfig( iterations_per_loop=FLAGS.iterations_per_loop, num_shards=FLAGS.num_cores, tpu_job_name=FLAGS.tpu_job_name)) classifier = tpu_estimator.TPUEstimator( use_tpu=FLAGS.use_tpu, model_fn=resnet_model_fn_w_pruning, params=params, config=run_config, train_batch_size=FLAGS.train_batch_size, eval_batch_size=FLAGS.eval_batch_size) cpu_classifier = tpu_estimator.TPUEstimator( use_tpu=FLAGS.use_tpu, model_fn=resnet_model_fn_w_pruning, params=params, config=run_config, train_batch_size=FLAGS.train_batch_size, export_to_tpu=False, eval_batch_size=FLAGS.eval_batch_size) if FLAGS.num_eval_images % FLAGS.eval_batch_size != 0: raise ValueError( 'eval_batch_size (%d) must evenly divide num_eval_images(%d)!' % (FLAGS.eval_batch_size, FLAGS.num_eval_images)) eval_steps = FLAGS.num_eval_images // FLAGS.eval_batch_size if FLAGS.mode == 'eval_once': ckpt_path = os.path.join(output_dir, FLAGS.eval_once_ckpt_prefix) dataset = imagenet_train if FLAGS.eval_on_train else imagenet_eval classifier.evaluate(input_fn=dataset.input_fn, steps=eval_steps, checkpoint_path=ckpt_path, name='{0}'.format(FLAGS.eval_once_ckpt_prefix)) elif FLAGS.mode == 'eval': # Run evaluation when there's a new checkpoint for ckpt in evaluation.checkpoints_iterator(output_dir): tf.logging.info('Starting to evaluate.') try: dataset = imagenet_train if FLAGS.eval_on_train else imagenet_eval classifier.evaluate(input_fn=dataset.input_fn, steps=eval_steps, checkpoint_path=ckpt, name='eval') # Terminate eval job when final checkpoint is reached global_step = int(os.path.basename(ckpt).split('-')[1]) if global_step >= FLAGS.train_steps: tf.logging.info( 'Evaluation finished after training step %d' % global_step) break except tf.errors.NotFoundError: logging('Checkpoint no longer exists,skipping checkpoint.') else: global_step = estimator._load_global_step_from_checkpoint_dir( output_dir) # Session run hooks to export model for prediction export_hook = ExportModelHook(cpu_classifier, export_dir) hooks = [export_hook] if FLAGS.mode == 'train': tf.logging.info('start training...') classifier.train(input_fn=imagenet_train.input_fn, hooks=hooks, max_steps=FLAGS.train_steps) else: assert FLAGS.mode == 'train_and_eval' tf.logging.info('start training and eval...') while global_step < FLAGS.train_steps: next_checkpoint = min(global_step + FLAGS.steps_per_eval, FLAGS.train_steps) classifier.train(input_fn=imagenet_train.input_fn, max_steps=next_checkpoint) global_step = next_checkpoint logging('Completed training up to step :', global_step) classifier.evaluate(input_fn=imagenet_eval.input_fn, steps=eval_steps)
def score(neurones, epoques=2000, ng=1, nd=1, lr=0.001, verbose=False): scores = [] for nb_neur in neurones: couches = len(nb_neur) tf.reset_default_graph() tf.set_random_seed(1234) X = tf.placeholder(tf.float32, [None, X_size]) Z = tf.placeholder(tf.float32, [None, X_size]) gen_sample = generator(Z, nb_neurone=nb_neur, couches=couches) z_sample = encoder(X, nb_neurone=nb_neur, couches=couches) real_output = discriminator(X, z_sample, nb_neurone=nb_neur, couches=couches) fake_output = discriminator(gen_sample, Z, nb_neurone=nb_neur, couches=couches, reuse=True) #Discriminator loss disc_loss = -tf.reduce_mean( tf.log(real_output + 1e-5) + tf.log(1.0 - fake_output + 1e-5)) #Generator loss gen_loss = -tf.reduce_mean( tf.log(fake_output + 1e-5) + tf.log(1.0 - real_output + 1e-5)) #Define the Optimizer with learning rate 0.001 gen_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="BIGAN/Generator") disc_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="BIGAN/Discriminator") enc_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="BIGAN/Encoder") gen_step = tf.train.RMSPropOptimizer(learning_rate=0.001).minimize( gen_loss, var_list=gen_vars + enc_vars) disc_step = tf.train.RMSPropOptimizer(learning_rate=0.001).minimize( disc_loss, var_list=disc_vars) sess = tf.Session() sess.run(tf.global_variables_initializer()) nd_steps = 1 #entrainer plus de dis que gen ng_steps = 1 d_loss_list = [] g_loss_list = [] with tf.device('/device:GPU:0'): for i in range(epoques): Z_batch = sample_noise_Gaus(Y_size, X_size) #ind_X = random.sample(range(Y_size),Y_size) for _ in range(nd_steps): _, dloss = sess.run([disc_step, disc_loss], feed_dict={ X: X_batch, Z: Z_batch }) for _ in range(ng_steps): _, gloss = sess.run([gen_step, gen_loss], feed_dict={ X: X_batch, Z: Z_batch }) if i % 100 == 0: print("Iterations:", i, "Discriminator loss: ", dloss, "Generator loss:", gloss) d_loss_list.append(dloss) g_loss_list.append(gloss) score = 0 """ for _ in range(1000): Z_test = sample_noise_Gaus(np.shape(X_test)[0],X_size) pred_test=sess.run(gen_sample,feed_dict={Z: Z_test}) score = score + KDE(pred_test,X_test) score = score/1000 """ Z_test = sample_noise_Gaus(np.shape(X_test)[0], X_size) pred_test = sess.run(gen_sample, feed_dict={Z: Z_test}) score = KDE(pred_test, X_test) print("Score pour C:", couches, " N:", nb_neur, ", score:", score) nom = "C" + str(couches) + "N" + str(nb_neur) tmp = [nom, score] scores.append(tmp) Z_batch = sample_noise_Gaus(Y_size, X_size) pred = sess.run(gen_sample, feed_dict={Z: Z_batch}) D0 = pd.DataFrame(np.transpose((X_batch[:, 0], pred[:, 0]))) D0.columns = ['real', 'fake'] D0.plot.density() #plt.ylim((-0.05, 0.4)) #plt.xlim((-25, 25)) plt.title('return series of stock 1') return scores
def train(self): # Create session tfconfig = tf.ConfigProto(allow_soft_placement=True) tfconfig.gpu_options.allow_growth = True sess = tf.Session(config=tfconfig) with sess.graph.as_default(): tf.set_random_seed(cfg.FLAGS.rng_seed) layers = self.net.create_architecture(sess, "TRAIN", self.imdb.num_classes, tag='default') loss = layers['total_loss'] lr = tf.Variable(cfg.FLAGS.learning_rate, trainable=False) momentum = cfg.FLAGS.momentum optimizer = tf.train.MomentumOptimizer(lr, momentum) gvs = optimizer.compute_gradients(loss) # Double bias # Double the gradient of the bias if set if cfg.FLAGS.double_bias: final_gvs = [] with tf.variable_scope('Gradient_Mult'): for grad, var in gvs: scale = 1. if cfg.FLAGS.double_bias and '/biases:' in var.name: scale *= 2. if not np.allclose(scale, 1.0): grad = tf.multiply(grad, scale) final_gvs.append((grad, var)) train_op = optimizer.apply_gradients(final_gvs) else: train_op = optimizer.apply_gradients(gvs) # We will handle the snapshots ourselves self.saver = tf.train.Saver(max_to_keep=100000) # Write the train and validation information to tensorboard # writer = tf.summary.FileWriter(self.tbdir, sess.graph) # valwriter = tf.summary.FileWriter(self.tbvaldir) # Load weights # Fresh train directly from ImageNet weights print('Loading initial model weights from {:s}'.format( cfg.FLAGS.pretrained_model)) variables = tf.global_variables() # Initialize all variables first sess.run(tf.variables_initializer(variables, name='init')) var_keep_dic = self.get_variables_in_checkpoint_file( cfg.FLAGS.pretrained_model) # Get the variables to restore, ignorizing the variables to fix variables_to_restore = self.net.get_variables_to_restore( variables, var_keep_dic) restorer = tf.train.Saver(variables_to_restore) restorer.restore(sess, cfg.FLAGS.pretrained_model) print('Loaded.') # Need to fix the variables before loading, so that the RGB weights are changed to BGR # For VGG16 it also changes the convolutional weights fc6 and fc7 to # fully connected weights self.net.fix_variables(sess, cfg.FLAGS.pretrained_model) print('Fixed.') sess.run(tf.assign(lr, cfg.FLAGS.learning_rate)) last_snapshot_iter = 0 timer = Timer() #iter = last_snapshot_iter + 1 iter = last_snapshot_iter last_summary_time = time.time() while iter < cfg.FLAGS.max_iters + 1: # Learning rate if iter == cfg.FLAGS.step_size + 1: # Add snapshot here before reducing the learning rate # self.snapshot(sess, iter) sess.run( tf.assign(lr, cfg.FLAGS.learning_rate * cfg.FLAGS.gamma)) timer.tic() # Get training data, one batch at a time blobs = self.data_layer.forward() # Compute the graph without summary try: rpn_loss_cls, rpn_loss_box, loss_cls, loss_box, total_loss = self.net.train_step( sess, blobs, train_op) except Exception: # if some errors were encountered image is skipped without increasing iterations print('image invalid, skipping') continue timer.toc() #iter += 1 # Display training information if iter % (cfg.FLAGS.display) == 0: print('iter: %d / %d, total loss: %.6f\n >>> rpn_loss_cls: %.6f\n ' '>>> rpn_loss_box: %.6f\n >>> loss_cls: %.6f\n >>> loss_box: %.6f\n ' % \ (iter, cfg.FLAGS.max_iters, total_loss, rpn_loss_cls, rpn_loss_box, loss_cls, loss_box)) print('speed: {:.3f}s / iter'.format(timer.average_time)) if iter % cfg.FLAGS.snapshot_iterations == 0: self.snapshot(sess, iter) iter += 1
def main(unused_argv): # pylint:disable=unused-variable # Reason: # This training script relys on many programmatical call to function and # access to variables. Pylint cannot infer this case so it emits false alarm # of unused-variable if we do not disable this warning. # pylint:disable=invalid-name # Reason: # Following variables have their name consider to be invalid by pylint so # we disable the warning. # - Variable that in its name has A or B indictating their belonging of # one side of data. del unused_argv # Load main config config_name = FLAGS.config config = load_config(config_name) config_name_A = config['config_A'] config_name_B = config['config_B'] config_name_classifier_A = config['config_classifier_A'] config_name_classifier_B = config['config_classifier_B'] # Load dataset dataset_A = common_joint.load_dataset(config_name_A, FLAGS.exp_uid_A) (dataset_blob_A, train_data_A, train_label_A, train_mu_A, train_sigma_A, index_grouped_by_label_A) = dataset_A dataset_B = common_joint.load_dataset(config_name_B, FLAGS.exp_uid_B) (dataset_blob_B, train_data_B, train_label_B, train_mu_B, train_sigma_B, index_grouped_by_label_B) = dataset_B # Prepare directories dirs = common_joint.prepare_dirs('joint', config_name, FLAGS.exp_uid) save_dir, sample_dir = dirs # Set random seed np.random.seed(FLAGS.random_seed) tf.set_random_seed(FLAGS.random_seed) # Real Training. tf.reset_default_graph() sess = tf.Session() # Load model's architecture (= build) one_side_helper_A = common_joint.OneSideHelper(config_name_A, FLAGS.exp_uid_A, config_name_classifier_A, FLAGS.exp_uid_classifier) one_side_helper_B = common_joint.OneSideHelper(config_name_B, FLAGS.exp_uid_B, config_name_classifier_B, FLAGS.exp_uid_classifier) m = common_joint.load_model(model_joint.Model, config_name, FLAGS.exp_uid) # Prepare summary train_writer = tf.summary.FileWriter(save_dir + '/transfer_train', sess.graph) scalar_summaries = tf.summary.merge([ tf.summary.scalar(key, value) for key, value in m.get_summary_kv_dict().items() ]) manual_summary_helper = common_joint.ManualSummaryHelper() # Initialize and restore sess.run(tf.global_variables_initializer()) one_side_helper_A.restore(dataset_blob_A) one_side_helper_B.restore(dataset_blob_B) # Miscs from config batch_size = config['batch_size'] n_latent_shared = config['n_latent_shared'] pairing_number = config['pairing_number'] n_latent_A = config['vae_A']['n_latent'] n_latent_B = config['vae_B']['n_latent'] i_start = 0 # Data iterators single_data_iterator_A = common_joint.SingleDataIterator( train_mu_A, train_sigma_A, batch_size) single_data_iterator_B = common_joint.SingleDataIterator( train_mu_B, train_sigma_B, batch_size) paired_data_iterator = common_joint.PairedDataIterator( train_mu_A, train_sigma_A, train_data_A, train_label_A, index_grouped_by_label_A, train_mu_B, train_sigma_B, train_data_B, train_label_B, index_grouped_by_label_B, pairing_number, batch_size) single_data_iterator_A_for_evaluation = common_joint.SingleDataIterator( train_mu_A, train_sigma_A, batch_size) single_data_iterator_B_for_evaluation = common_joint.SingleDataIterator( train_mu_B, train_sigma_B, batch_size) # Training loop n_iters = FLAGS.n_iters for i in tqdm(list(range(i_start, n_iters)), desc='training', unit=' batch'): # Prepare data for this batch # - Unsupervised (A) x_A, _ = next(single_data_iterator_A) x_B, _ = next(single_data_iterator_B) # - Supervised (aligning) x_align_A, x_align_B, align_debug_info = next(paired_data_iterator) real_x_align_A, real_x_align_B = align_debug_info # Run training op and write summary res = sess.run( [m.train_full, scalar_summaries], { m.x_A: x_A, m.x_B: x_B, m.x_align_A: x_align_A, m.x_align_B: x_align_B, }) train_writer.add_summary(res[-1], i) if i % FLAGS.n_iters_per_save == 0: # Save the model if instructed config_name = FLAGS.config model_uid = common.get_model_uid(config_name, FLAGS.exp_uid) save_name = os.path.join(save_dir, 'transfer_%s_%d.ckpt' % (model_uid, i)) m.vae_saver.save(sess, save_name) with tf.gfile.Open(os.path.join(save_dir, 'ckpt_iters.txt'), 'w') as f: f.write('%d' % i) # Evaluate if instructed if i % FLAGS.n_iters_per_eval == 0: # Helper functions def joint_sample(sample_size): z_hat = np.random.randn(sample_size, n_latent_shared) return sess.run([m.x_joint_A, m.x_joint_B], { m.z_hat: z_hat, }) def get_x_from_prior_A(): return sess.run(m.x_from_prior_A) def get_x_from_prior_B(): return sess.run(m.x_from_prior_B) def get_x_from_posterior_A(): return next(single_data_iterator_A_for_evaluation)[0] def get_x_from_posterior_B(): return next(single_data_iterator_B_for_evaluation)[0] def get_x_prime_A(x_A): return sess.run(m.x_prime_A, {m.x_A: x_A}) def get_x_prime_B(x_B): return sess.run(m.x_prime_B, {m.x_B: x_B}) def transfer_A_to_B(x_A): return sess.run(m.x_A_to_B, {m.x_A: x_A}) def transfer_B_to_A(x_B): return sess.run(m.x_B_to_A, {m.x_B: x_B}) def manual_summary(key, value): summary = manual_summary_helper.get_summary(sess, key, value) # This [cell-var-from-loop] is intented train_writer.add_summary(summary, i) # pylint: disable=cell-var-from-loop # Classifier based evaluation sample_total_size = 10000 sample_batch_size = 100 def pred(one_side_helper, x): real_x = six.ensure_text(one_side_helper.m_helper, x) return one_side_helper.m_classifier_helper.classify( real_x, batch_size) def accuarcy(x_1, x_2, type_1, type_2): assert type_1 in ('A', 'B') and type_2 in ('A', 'B') func_A = partial(pred, one_side_helper=one_side_helper_A) func_B = partial(pred, one_side_helper=one_side_helper_B) func_1 = func_A if type_1 == 'A' else func_B func_2 = func_A if type_2 == 'A' else func_B pred_1, pred_2 = func_1(x=x_1), func_2(x=x_2) return np.mean(np.equal(pred_1, pred_2).astype('f')) def joint_sample_accuarcy(): x_A, x_B = joint_sample(sample_size=sample_total_size) # pylint: disable=cell-var-from-loop return accuarcy(x_A, x_B, 'A', 'B') def transfer_sample_accuarcy_A_B(): x_A = get_x_from_prior_A() x_B = transfer_A_to_B(x_A) return accuarcy(x_A, x_B, 'A', 'B') def transfer_sample_accuarcy_B_A(): x_B = get_x_from_prior_B() x_A = transfer_B_to_A(x_B) return accuarcy(x_A, x_B, 'A', 'B') def transfer_accuarcy_A_B(): x_A = get_x_from_posterior_A() x_B = transfer_A_to_B(x_A) return accuarcy(x_A, x_B, 'A', 'B') def transfer_accuarcy_B_A(): x_B = get_x_from_posterior_B() x_A = transfer_B_to_A(x_B) return accuarcy(x_A, x_B, 'A', 'B') def recons_accuarcy_A(): # Use x_A in outer scope # These [cell-var-from-loop]s are intended x_A_prime = get_x_prime_A(x_A) # pylint: disable=cell-var-from-loop return accuarcy(x_A, x_A_prime, 'A', 'A') # pylint: disable=cell-var-from-loop def recons_accuarcy_B(): # use x_B in outer scope # These [cell-var-from-loop]s are intended x_B_prime = get_x_prime_B(x_B) # pylint: disable=cell-var-from-loop return accuarcy(x_B, x_B_prime, 'B', 'B') # pylint: disable=cell-var-from-loop # Do all manual summary for func_name in ( 'joint_sample_accuarcy', 'transfer_sample_accuarcy_A_B', 'transfer_sample_accuarcy_B_A', 'transfer_accuarcy_A_B', 'transfer_accuarcy_B_A', 'recons_accuarcy_A', 'recons_accuarcy_B', ): func = locals()[func_name] manual_summary(func_name, func()) # Sampling based evaluation / sampling x_prime_A = get_x_prime_A(x_A) x_prime_B = get_x_prime_B(x_B) x_from_prior_A = get_x_from_prior_A() x_from_prior_B = get_x_from_prior_B() x_A_to_B = transfer_A_to_B(x_A) x_B_to_A = transfer_B_to_A(x_B) x_align_A_to_B = transfer_A_to_B(x_align_A) x_align_B_to_A = transfer_B_to_A(x_align_B) x_joint_A, x_joint_B = joint_sample(sample_size=batch_size) this_iter_sample_dir = os.path.join(sample_dir, 'transfer_train_sample', '%010d' % i) tf.gfile.MakeDirs(this_iter_sample_dir) for helper, var_names, x_is_real_x in [ (one_side_helper_A.m_helper, ('x_A', 'x_prime_A', 'x_from_prior_A', 'x_B_to_A', 'x_align_A', 'x_align_B_to_A', 'x_joint_A'), False), (one_side_helper_A.m_helper, ('real_x_align_A', ), True), (one_side_helper_B.m_helper, ('x_B', 'x_prime_B', 'x_from_prior_B', 'x_A_to_B', 'x_align_B', 'x_align_A_to_B', 'x_joint_B'), False), (one_side_helper_B.m_helper, ('real_x_align_B', ), True), ]: for var_name in var_names: # Here `var` would be None if # - there is no such variable in `locals()`, or # - such variable exists but the value is None # In both case, we would skip saving data from it. var = locals().get(var_name, None) if var is not None: helper.save_data(var, var_name, this_iter_sample_dir, x_is_real_x)
def setUp(self): super(Transformer2dTest, self).setUp() tf.set_random_seed(self.SEED) np.random.seed(self.SEED)
def main(argv): del argv # unused here gcs_root = "gs://v1net-tpu-bucket/" args = FLAGS.flag_values_dict() gcs_path = "gs://v1net-tpu-bucket/%s/" % args["base_dir"] model_dir = os.path.join(gcs_path, "model_dir_%s" % args["experiment_name"]) summaries_dir = os.path.join(gcs_path, "summaries") if not tf.gfile.Exists(model_dir): tf.gfile.MakeDirs(model_dir) if not tf.gfile.Exists(model_dir): tf.gfile.MakeDirs(summaries_dir) args["model_dir"] = model_dir args["summaries_dir"] = summaries_dir rand_seed = np.random.randint(10000) tf.set_random_seed(rand_seed) args["random_seed"] = rand_seed warm_start_settings = None args["data_dir"] = os.path.join(gcs_root, args["data_dir"]) num_train_examples, input_fn_train = get_input_fn_train(args) args["num_train_examples"] = num_train_examples * args["num_epochs"] args["num_train_steps"] = args["num_train_examples"] // args[ "train_batch_size"] num_train_steps = args["num_train_steps"] num_train_steps_per_epoch = num_train_steps // args["num_epochs"] args["num_train_steps_per_epoch"] = num_train_steps_per_epoch warm_start_settings = tf.estimator.WarmStartSettings( ckpt_to_initialize_from=args['checkpoint'], vars_to_warm_start=[ "^(?!.*side_output|.*v1net|.*Momentum|global_step|beta*|gamma*|.*Adam)" ], ) tpu_cluster_resolver = tf.distribute.cluster_resolver.TPUClusterResolver( args["tpu_name"] if args["use_tpu"] else "", zone=args["tpu_zone"], project="desalab-tpu") tpu_config = tf.estimator.tpu.TPUConfig( num_shards=args["num_cores"], iterations_per_loop=args["iterations_per_loop"]) config = tf.estimator.tpu.RunConfig( cluster=tpu_cluster_resolver, model_dir=model_dir, tpu_config=tpu_config, save_checkpoints_steps=args["iterations_per_loop"], keep_checkpoint_max=20) classifier = tf.estimator.tpu.TPUEstimator( use_tpu=args["use_tpu"], model_fn=model_fn, config=config, params=args, warm_start_from=warm_start_settings, train_batch_size=args["train_batch_size"], ) start_timestamp = time.time() classifier.train(input_fn=input_fn_train, max_steps=num_train_steps) elapsed_time = int(time.time() - start_timestamp) tf.logging.info("Finished training up to step %d. Elapsed seconds %d.", num_train_steps, elapsed_time)
def reinitialize_params(self, seed): tf.set_random_seed(seed) with self.graph.as_default(): self.sess.run(tf.global_variables_initializer()) model_params = self.get_params() return model_params
View more on my tutorial page: https://morvanzhou.github.io/tutorials/ Using: Tensorflow: 1.0 gym: 0.8.0 """ import functools import numpy as np #import tensorflow as tf import tensorflow.compat.v1 as tf tf.disable_v2_behavior() import tensorflow_probability as tfp # reproducible np.random.seed(1) tf.set_random_seed(1) class PolicyGradient: def __init__(self, n_actions, n_features, learning_rate=0.01, reward_decay=0.95, output_graph=False, policy_name='p'): self.policy_name = policy_name self.n_actions = n_actions self.n_features = n_features self.lr = learning_rate self.gamma = reward_decay
def check_and_run_attack(dataset, config, adversarial, mixed): clear_session() # Set seed tf.set_random_seed(config['random_seed']) np.random.seed(config['random_seed']) # Get model model_file = None if adversarial: if mixed: model_file = tf.train.latest_checkpoint( config['model_dir_adv_mixed']) else: model_file = tf.train.latest_checkpoint(config['model_dir_adv']) else: if mixed: model_file = tf.train.latest_checkpoint(config['model_dir_mixed']) else: model_file = tf.train.latest_checkpoint(config['model_dir']) if model_file is None: print('No model found') sys.exit() # Get adversarial dataset path = "" if adversarial: if mixed: path = "attack-adv-mixed.npy" else: path = "attack-adv.npy" else: if mixed: path = "attack-normal-mixed.npy" else: path = "attack-normal.npy" x_adv = np.load(path) clean_acc = 0 robust_acc = 0 if model_file is None: print('No checkpoint found') # elif x_adv.shape != (2000, 3): # print('Invalid shape: expected (10000,784), found {}'.format(x_adv.shape)) # elif np.amax(x_adv) > 1.0001 or \ # np.amin(x_adv) < -0.0001 or \ # np.isnan(np.amax(x_adv)): # print('Invalid pixel range. Expected [0, 1], found [{}, {}]'.format( # np.amin(x_adv), # np.amax(x_adv))) else: clean_acc = run_attack(model_file, dataset, x_adv, config, adv_testing=False, mixed_dataset=mixed) robust_acc = run_attack(model_file, dataset, x_adv, config, adv_testing=True, mixed_dataset=mixed) return (clean_acc, robust_acc)
#!/usr/local/bin/python from __future__ import division from __future__ import print_function import time import tensorflow.compat.v1 as tf from utils import * from models import BGCN # Set random seed seed = 123 np.random.seed(seed) tf.set_random_seed(seed) # Settings flags = tf.app.flags FLAGS = flags.FLAGS flags.DEFINE_string('dataset', 'citeseer', 'Dataset string.') flags.DEFINE_string('model', 'bgcn', 'Model string.') flags.DEFINE_float('learning_rate', 0.005, 'Initial learning rate.') flags.DEFINE_integer('epochs', 2000, 'Number of epochs to train.') flags.DEFINE_integer('hidden1', 16, 'Number of units in hidden layer 1.') flags.DEFINE_integer('patience', 100, 'early stop #epoch') flags.DEFINE_float('dropout', 0.6, 'Dropout rate (1 - keep probability).') flags.DEFINE_float('weight_decay', 1e-4, 'Weight for L2 loss on embedding matrix.') ''' 0.1-0.9 is the value of alpha, indicating which one is more biased when the two models are combined. For example, with alpha=0.9, the combined model means
# Purpose: Mimics a benign agent in the federated learning setting and sets up the master agent ######################## import warnings warnings.filterwarnings("ignore") import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' import tensorflow.compat.v1 as tf tf.disable_v2_behavior() import logging tf.get_logger().setLevel(logging.ERROR) import numpy as np tf.set_random_seed(777) np.random.seed(777) from utils.mnist import model_mnist from utils.census_utils import census_model_1 from utils.cifar_utils import cifar10_model from utils.eval_utils import eval_minimal import global_vars as gv # gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gv.mem_frac) def agent(i, X_shard, Y_shard, t, gpu_id, return_dict, X_test, Y_test, lr=None): tf.keras.backend.set_learning_phase(1)
def train_constrained(dataset, group_info, epsilon=0.01, learning_rate=0.1, dual_scale=5.0, loops=10000, feature_dependent_multiplier=True, hidden_layers=None, skip_steps=400): """Train constrained classifier wth Lagrangian model. Args: dataset: train, vali and test sets group_info: group memberships on train, vali and test sets and thresholds epsilon: constraint slack learning_rate: learning rate for theta dual_scale: learning rate for gamma = dual_scale * learning_rate loops: number of gradient steps feature_dependent_multiplier: should the multiplier model be feature dependent. If False, a common multipler is used for all constraints hidden_layers: list of hidden layer nodes to be used for multiplier model skip_steps: steps to skip before snapshotting metrics """ tf.set_random_seed(121212) np.random.seed(212121) random.seed(333333) x_train, y_train, z_train, x_vali, y_vali, _, x_test, y_test, _ = dataset (group_memberships_list_train, group_memberships_list_vali, group_memberships_list_test, group_memberships_thresholds_train) = group_info # Models and group thresholds tensor. model = create_model(x_train.shape[-1]) multiplier_model, multiplier_weights = create_multiplier_model( feature_dependent_multiplier=feature_dependent_multiplier, dim=3, hidden_layers=hidden_layers) group_thresholds = tf.Variable(np.ones(3) * 0.1, dtype=tf.float32) # Features, labels, predictions, multipliers. features_tensor = tf.constant(x_train) labels_tensor = tf.constant(y_train) features_tensor_vali = tf.constant(x_vali) predictions = lambda: model(features_tensor) predictions_vali = lambda: model(features_tensor_vali) predictions_test = lambda: model(x_test) def multiplier_values(): return tf.abs( multiplier_model(tf.reshape(group_thresholds, shape=(1, -1)))) # Lagrangian loss function. def lagrangian_loss(): # Separate out objective, constraints and proxy constraints. objective = problem.objective() constraints = problem.constraints() proxy_constraints = problem.proxy_constraints() # Set-up custom Lagrangian loss. primal = objective multipliers = multiplier_values() primal += tf.stop_gradient(multipliers) * proxy_constraints dual = dual_scale * multipliers * tf.stop_gradient(constraints) return primal - dual # Objective. context = tfco.rate_context(predictions, labels=lambda: labels_tensor) overall_error = tfco.error_rate(context) # Slice and subset group predictions and labels. def group_membership(): return (z_train[:, 0] > group_thresholds[0]) & ( z_train[:, 1] > group_thresholds[1]) & (z_train[:, 2] > group_thresholds[2]) def group_predictions(): pred = predictions() groups = tf.reshape(group_membership(), (-1, 1)) return pred[groups] def group_labels(): groups = tf.reshape(group_membership(), (-1, )) return labels_tensor[groups] # Constraint. group_context = tfco.rate_context(group_predictions, labels=group_labels) group_error = tfco.error_rate(group_context) constraints = [group_error <= overall_error + epsilon] # Set up constrained optimization problem and optimizer. problem = tfco.RateMinimizationProblem(overall_error, constraints) optimizer = tf.keras.optimizers.Adagrad(learning_rate) var_list = model.trainable_weights + multiplier_weights objectives_list = [] objectives_list_test = [] objectives_list_vali = [] violations_list = [] violations_list_test = [] violations_list_vali = [] model_weights = [] # Training for ii in range(loops): # Sample a group membership at random. random_index = np.random.randint( group_memberships_thresholds_train.shape[0]) group_thresholds.assign( group_memberships_thresholds_train[random_index, :]) # Gradient op. problem.update_ops() optimizer.minimize(lagrangian_loss, var_list=var_list) # Snapshot iterate once in 1000 loops. if ii % skip_steps == 0: pred = np.reshape(predictions(), (-1, )) err = error_rate(y_train, pred) max_viol, viol_list = violation(y_train, pred, epsilon, group_memberships_list_train) pred_test = np.reshape(predictions_test(), (-1, )) err_test = error_rate(y_test, pred_test) _, viol_list_test = violation(y_test, pred_test, epsilon, group_memberships_list_test) pred_vali = np.reshape(predictions_vali(), (-1, )) err_vali = error_rate(y_vali, pred_vali) max_viol_vali, viol_list_vali = violation( y_vali, pred_vali, epsilon, group_memberships_list_vali) objectives_list.append(err) objectives_list_test.append(err_test) objectives_list_vali.append(err_vali) violations_list.append(viol_list) violations_list_test.append(viol_list_test) violations_list_vali.append(viol_list_vali) model_weights.append(model.get_weights()) if ii % 1000 == 0: print( "Epoch %d | Error = %.3f | Viol = %.3f | Viol_vali = %.3f" % (ii, err, max_viol, max_viol_vali), flush=True) # Best candidate index. best_ind = tfco.find_best_candidate_index(np.array(objectives_list), np.array(violations_list), rank_objectives=False) model.set_weights(model_weights[best_ind]) print("Train:") evaluate(x_train, y_train, model, epsilon, group_memberships_list_train) print("\nVali:") evaluate(x_vali, y_vali, model, epsilon, group_memberships_list_vali) print("\nTest:") evaluate(x_test, y_test, model, epsilon, group_memberships_list_test)
import random from sklearn.model_selection import train_test_split from tensorflow.keras.optimizers import Adam, Nadam import cv2 import numpy as np import pandas as pd import multiprocessing from albumentations import Compose, VerticalFlip, HorizontalFlip, Rotate, GridDistortion import matplotlib.pyplot as plt from IPython.display import Image from tqdm import tqdm_notebook as tqdm from numpy.random import seed import argparse seed(10) from tensorflow.compat.v1 import set_random_seed set_random_seed(10) import segmentation_models as sm import util import preprocessing from datagenerator import DataGenerator import loss import matplotlib.pyplot as plt from tensorflow.keras.callbacks import Callback, ModelCheckpoint from PrAucCallback import PrAucCallback parser = argparse.ArgumentParser() parser.add_argument('--train_path',default='../data/train_images/', help='path to the train images') parser.add_argument('--test_path',default='../data/test_images/', help='path to the test images') parser.add_argument('--label_path',default='../data/train.csv', help='path to the label(trian.csv') parser.add_argument('--sub_path',default='../data/sample_submission.csv', help='path to the submission file') parser.add_argument('--out_path',default='../result/1104_efficientnetb3', help='path to the submission file')