def mean_accuracy_metric(y_true, y_pred): sum_of_accuracy = categorical_accuracy(y_true[0:lenght_of_input], y_pred[0:lenght_of_input]) for i in range(1, number_of_inputs): start_index = i * lenght_of_input end_index = (i + 1) * lenght_of_input accuracy = categorical_accuracy(y_true[start_index:end_index], y_pred[start_index:end_index]) sum_of_accuracy = sum_of_accuracy[-1] + accuracy[-1] return sum_of_accuracy
def market_attribute_accuracy(y_true, y_pred): # binary categories acc = binary_accuracy(y_true[:, binary_1], y_pred[:, binary_1]) * 0.5 acc += binary_accuracy(y_true[:, binary_2], y_pred[:, binary_2]) * 0.5 # top colors acc_top_color = categorical_accuracy(y_true[:, up_colors], y_pred[:, up_colors]) # down colors acc_down_color = categorical_accuracy(y_true[:, down_colors], y_pred[:, down_colors]) # print(acc, acc_down_color, acc_top_color) return acc * 9 / 11 + acc_down_color * 1 / 11 + acc_top_color * 1 / 11
def __init__(self, Nin, Nh_l, Nout): # Nin은 입력 크기, Nh_I는 은닉층 크기, Nout은 출력층 크기 self.X_ph = tf.placeholder(tf.float32, shape=(None, Nin)) # 입력 플레이스홀더 self.L_ph = tf.placeholder(tf.float32, shape=(None, Nout)) # 레이블 플레이스홀더 # Modeling H = Dense(Nh_l[0], activation='relu')( self.X_ph) # 입력 플레이스홀더를 넣고, 첫 번째 은닉층 크기만큼 반환하는 은닉층1 H = Dropout(0.5)(H) # 드롭아웃 H = Dense(Nh_l[1], activation='relu')( H) # 입력 플레이스홀더를 넣고, 두 번째 은닉층 크기만큼 반환하는 은닉층1 H = Dropout(0.25)(H) # 드롭아웃 self.Y_tf = Dense(Nout, activation='softmax')(H) # 출력층, 소프트맥스 # Operation self.Loss_tf = tf.reduce_mean( categorical_crossentropy(self.L_ph, self.Y_tf)) # 손실함수는 레이블과 출력 간 크로스엔트로피 self.Train_tf = tf.train.AdamOptimizer().minimize( self.Loss_tf) # 최적화함수는 에이담 self.Acc_tf = categorical_accuracy(self.L_ph, self.Y_tf) # 정확도 산출은 케라스 함수로 self.Init_tf = tf.global_variables_initializer( ) # 초기화 함수는 텐서플로 글로벌 전역 초기화 함수
def kaggle_sliced_accuracy(y_true, y_pred, slice_weights=[1.] * 11): question_slices = [ slice(0, 3), slice(3, 5), slice(5, 7), slice(7, 9), slice(9, 13), slice(13, 15), slice(15, 18), slice(18, 25), slice(25, 28), slice(28, 31), slice(31, 37) ] accuracy_slices = [ categorical_accuracy(y_true[:, question_slices[i]], y_pred[:, question_slices[i]]) * slice_weights[i] for i in range(len(question_slices)) ] accuracy_slices = T.cast(accuracy_slices, 'float32') return { 'sliced_accuracy_mean': T.mean(accuracy_slices), 'sliced_accuracy_std': T.std(accuracy_slices) }
def fnc_score(y_true, y_pred): "Assumes two outputs: related and stance" y_true_related, y_true_stance = tf.split(y_true, 2, axis=1) y_pred_related, y_pred_stance = tf.split(y_pred, 2, axis=1) print(y_true_related, y_true_stance, y_pred_related, y_pred_stance) a1 = categorical_accuracy(y_true_related, y_pred_related) a2 = categorical_accuracy(y_true_stance, y_pred_stance) print(a1, a2) return ( tf.multiply(a1, 0.25) + tf.multiply(a2, 0.75) #tf.multiply(categorical_accuracy(y_true_related, y_pred_related), 0.25) + #tf.multiply(categorical_accuracy(y_true_stance, y_pred_stance), 0.75) )
def _generic_accuracy(y_true, y_pred): if K.int_shape(y_pred)[1] == 1: return binary_accuracy(y_true, y_pred) if K.int_shape(y_true)[-1] == 1: return sparse_categorical_accuracy(y_true, y_pred) return categorical_accuracy(y_true, y_pred)
def ctm_acc1(y_true, y_pred): # print("ctm_acc1") # true = tf.split(y_true, 3, axis=-1)[0] pred_list = tf.split(y_pred, 3, axis=-1) pred = pred_list[0] + pred_list[1] + 0.1 * pred_list[2] # print(categorical_accuracy(true, pred)) return categorical_accuracy(y_true, pred)
def acc_kldiv(y_in,x): """ Corrected accuracy to be used with custom loss_kldiv """ h = y_in[:,0:NBINS] y = y_in[:,NBINS:] return categorical_accuracy(y, x)
def certain_predictions_acc(y_true, y_pred): """ accuracy of predictions that are certain """ c_pred_ind = _certain_ind(y_pred, uncertain=False) return categorical_accuracy(K.gather(y_true, c_pred_ind), K.gather(y_pred, c_pred_ind))
def trip_accuracy(y_true, y_pred): # Seperate embeddings into the triplets num_classes = y_pred._keras_shape[-1] trip_pred = K.reshape(y_pred, (-1, 3, num_classes)) trip_labels = K.reshape(y_true, (-1, 3, num_classes)) # Return correct classification return metrics.categorical_accuracy(trip_labels[:, 0], trip_pred[:, 0])
def L_acc(y_true, y_pred): # Confidence component (aka objectness) y_true_confidence = y_true[:, 0] y_pred_confidence = K.round(y_pred[:, 0]) #confidence_accuracy = K.cast(K.equal(y_true_confidence, K.round(y_pred_confidence)), K.floatx()) # Class component y_true_classes = y_true[:, 4:] y_pred_classes = y_pred[:, 4:] classes_accuracy = categorical_accuracy(y_true_classes, y_pred_classes) #y_true_coord = y_true[:, 1:4] #y_pred_coord = y_pred[:, 1:4] true_xy = y_true[:, 1:3] pred_xy = y_pred[:, 1:3] true_r = y_true[:, 3:4] pred_r = y_pred[:, 3:4] # compute IOU, using the top,left,bottom,right representation. true_mins = true_xy - true_r true_maxes = true_xy + true_r pred_mins = pred_xy - pred_r pred_maxes = pred_xy + pred_r intersect_mins = K.maximum(pred_mins, true_mins) intersect_maxes = K.minimum(pred_maxes, true_maxes) intersect_wh = K.maximum(intersect_maxes - intersect_mins, 0.) intersect_areas = intersect_wh[..., 0] * intersect_wh[..., 1] pred_areas = 4. * pred_r[..., 0] * pred_r[..., 0] # a square true_areas = 4. * true_r[..., 0] * true_r[..., 0] union_areas = pred_areas + true_areas - intersect_areas iou_scores = intersect_areas / union_areas iou_accuracy = K.cast(iou_scores > 0.6, K.floatx()) #joint_accuracy = confidence_accuracy * classes_accuracy * iou_accuracy joint_accuracy = (y_true_confidence * y_pred_confidence * classes_accuracy * iou_accuracy) + \ ((1.0 - y_true_confidence) * (1.0 - y_pred_confidence)) # if background, dont care about class or iou ''' joint_accuracy = tf.Print(joint_accuracy, [K.dtype(confidence_accuracy), K.dtype(classes_accuracy), K.dtype(iou_accuracy), K.dtype(joint_accuracy) ], message='confidence, class, iou, joint dtype: ', summarize=20) ''' return joint_accuracy
def adv_acc(y, _): # Generate adversarial examples x_adv = fgsm(model, y, eps=eps, clip_min=clip_min, clip_max=clip_max) # Consider the attack to be constant x_adv = K.stop_gradient(x_adv) # Accuracy on the adversarial examples preds_age, preds_race, preds_gender = model(x_adv) return categorical_accuracy(y, preds_race)
def test_sparse_categorical_accuracy_correctness(): y_a = K.variable(np.random.randint(0, 7, (6,)), dtype=K.floatx()) y_b = K.variable(np.random.random((6, 7)), dtype=K.floatx()) # use one_hot embedding to convert sparse labels to equivalent dense labels y_a_dense_labels = K.cast(K.one_hot(K.cast(y_a, dtype='int32'), num_classes=7), dtype=K.floatx()) sparse_categorical_acc = metrics.sparse_categorical_accuracy(y_a, y_b) categorical_acc = metrics.categorical_accuracy(y_a_dense_labels, y_b) assert np.allclose(K.eval(sparse_categorical_acc), K.eval(categorical_acc))
def true_accuracy(y_true, y_pred): ''' Ignore START_OF_SENTENCE and END_OF_SENTENCE when calculating accuracy. Also ignore zero paddings. ''' # ignore SOS, EOS trimmed_y_true = y_true[:, 1:-1, :] trimmed_y_pred = y_pred[:, 1:-1, :] return categorical_accuracy(trimmed_y_true, trimmed_y_pred)
def adv_acc(y, _): # Generate adversarial examples y_gender = tf.get_default_graph().get_tensor_by_name("gender_target:0") x_adv = fgsm(model, y_gender, eps=eps, clip_min=clip_min, clip_max=clip_max) # Consider the attack to be constant x_adv = K.stop_gradient(x_adv) # Accuracy on the adversarial examples _, preds_age = model(x_adv) return categorical_accuracy(y, preds_age)
def acc_reg(y_in,x_in): """ Corrected accuracy to be used with custom loss_reg """ h = y_in[:,0:NBINS] y = y_in[:,NBINS:] hpred = x_in[:,0:NBINS] ypred = x_in[:,NBINS:] return categorical_accuracy(y, ypred)
def accuracy2(args): y_pred, y_true = args y_pred = K.softmax(y_pred, axis=-1) match_board = [] for i in range(3): tmp = tf.ones_like(y_true) * i tmp = tf.cast(tf.equal(y_true, tmp), tf.float32) match_board.append(tmp) y_true_onehot = tf.concat(match_board, axis=1) acc = categorical_accuracy(y_true_onehot, y_pred) return acc
def evaluate(conf): _, x_test, _, _, y_test, _, _, _, _, x_test_units, y_test_units = full_data_pipeline( conf) model = build_model(conf) tu_rolls, tu_features = uncombine_features(x_test_units) tu_x = [] tu_x.append(tu_rolls) tu_x.extend(tu_features) mod_tu_x = [] for feat in tu_x: mod_tu_x.append(np.stack(feat)) tu_y = np.stack(y_test_units) print('Single sample test results : ') evaluate_model(conf, model, mod_tu_x, tu_y) print('Full track test results : ') pianos_s, feats_s = uncombine_features(x_test) y_pred = [] for s in range(len(pianos_s)): piano_s = [] piano_s.append(pianos_s[s]) feat_s = [] for ft in feats_s: feat_s.append(ft[s]) x = prediction_data(conf, piano_s, feat_s) mod_x = [] for feat in x: mod_x.append(np.stack(feat)) y = predict_model(conf, model, mod_x) y = np.argmax(y, axis=1) votes = np.bincount(y) y_pred_s = np.zeros((conf['dataset']['num_class'])) for i in range(y_pred_s.shape[0]): if (i < len(votes)): y_pred_s[i] = votes[i] else: y_pred_s[i] = 0 y_pred_s = y_pred_s / np.sum(y_pred_s) y_pred.append(y_pred_s) y_test = np.stack(y_test) y_pred = np.stack(y_pred) y_test = y_test.astype('float32') y_pred = y_pred.astype('float32') y_true = K.constant(y_test) y_pred = K.constant(y_pred) loss = K.categorical_crossentropy(target=y_true, output=y_pred) loss = K.eval(loss) loss = np.mean(loss) acc = categorical_accuracy(y_true, y_pred) acc = K.eval(acc) acc = np.mean(acc) print('Test loss:', loss) print('Test accuracy:', acc)
def target_acc(y_true, y_pred, targetCols=(59, 62), val=False): tars = y_true[:, :, targetCols[0]:targetCols[1]] preds = y_pred[:, :, targetCols[0]:targetCols[1]] if not val: return metrics.categorical_accuracy(tars, preds) else: #This only works for a single example at a time tars = tars[0, 0, :] preds = preds[0, 0, :] if np.argmax(tars) == np.argmax(preds): return 1 else: return 0
def custom_acc(self, y_true, y_pred): y_true_shape = (-1, self.grid_size, self.grid_size, self.bbox_params + len(self.classes)) y_pred_shape = (-1, self.grid_size, self.grid_size, self.bbox_count * self.bbox_params + len(self.classes)) y_true = tf.reshape(y_true, y_true_shape, name='reshape_y_true') y_pred = tf.reshape(y_pred, y_pred_shape, name='reshape_y_pred') # shape=(?, 21, 21, 10), predicted_class_prob = y_pred[:, :, :, 10:] true_class_prob = y_true[:, :, :, 5:] return categorical_accuracy(true_class_prob, predicted_class_prob)
def accuracy(package_data, p_class): from keras.metrics import categorical_accuracy g_class = tf.gather(package_data, indices=[0], axis=-1) mask = tf.reshape( tf.equal(g_class, Btype.NEG) | tf.equal(g_class, Btype.POSITIVE), [-1]) p_class = tf.boolean_mask(p_class, mask) cate = tf.cast(tf.reshape(tf.equal(g_class, Btype.POSITIVE), [-1]), tf.int32) cate = tf.boolean_mask(cate, mask) cate_one_hot = tf.reshape(tf.one_hot(cate, tf.constant(2, tf.int32)), [-1, 2]) return categorical_accuracy(cate_one_hot, tf.reshape(p_class, [-1, 2]))
def padded_categorical_accuracy(y_true, y_pred): """Accuracy of a batch, ignoring padding. >>> sh = [1, 3, 3] # 1 batch size x 3 time steps x 3 categories >>> true = tf.constant([0., 0., 1., 0., 0., 1., 1., 0., 0.], shape=sh) <[2, 2, 0 (padding)]> >>> pred = tf.constant([0, 0.7, 0.3, 0, 0.3, 0.7, 0.5, 0.3, 0.2], shape=sh) <[2, 1, 0)]> >>> padded_categorical_accuracy(true, pred).eval()) # => 0.5 """ padded = tf.squeeze(tf.slice(y_true, [0, 0, 0], [-1, -1, 1]), axis=2) mask = K.equal(padded, 0.) return categorical_accuracy(tf.boolean_mask(y_true, mask), tf.boolean_mask(y_pred, mask))
def model_eval(x, y, model, X_test, Y_test, back='th'): """ Compute the accuracy of a TF model on some data :param x: input placeholder :param y: output placeholder (for labels) :param model: model output predictions :param X_test: numpy array with training inputs :param Y_test: numpy array with training outputs :return: a float with the accuracy value """ # Define sympbolic for accuracy input_shape = (None, FLAGS.img_rows, FLAGS.img_cols) acc_value = categorical_accuracy(y, model) acc_value = K.function([x, y, K.learning_phase()], [acc_value]) # Init result var accuracy = 0.0 # Compute number of batches nb_batches = int(math.ceil(float(len(X_test)) / FLAGS.batch_size)) assert nb_batches * FLAGS.batch_size >= len(X_test) for batch in range(nb_batches): if batch % 100 == 0 and batch > 0: print("Batch " + str(batch)) # Must not use the `batch_indices` function here, because it # repeats some examples. # It's acceptable to repeat during training, but not eval. start = batch * FLAGS.batch_size end = min(len(X_test), start + FLAGS.batch_size) cur_batch_size = end - start + 1 # The last batch may be smaller than all others, so we need to # account for variable batch size here if back == 'tf': accuracy += cur_batch_size * acc_value.eval(feed_dict={ x: X_test[start:end], y: Y_test[start:end] }) elif back == 'th': accuracy += cur_batch_size * acc_value( [X_test[start:end], Y_test[start:end], 0])[0] assert end >= len(X_test) # Divide by number of examples to get final value accuracy /= len(X_test) return accuracy
def accuracy(self, x, t): x_ph = tf.placeholder(tf.float32, shape=[None, self.image_size]) t_ph = tf.placeholder(tf.float32, shape=[None, self.n_classes]) y_op = self._encode_y_given_x(x_ph) acc_value = categorical_accuracy(t_ph, y_op) with tf.Session() as sess: if self.filepath: self.saver.restore(sess, self.filepath) result = self.sess.run(acc_value, feed_dict={ x_ph: x, t_ph: t, K.learning_phase(): 1 }) return result
def evaluate_ensemble(Best=True): ''' loads and evaluates an ensemle from the models in the model folder. ''' (X_train, y_train), (X_test, y_test) = mnist.load_data() X_test = X_test.reshape(10000, 784) X_test = X_test.astype('float32') X_test /= 255 Y_test = np_utils.to_categorical(y_test, 10) model_dirs = [] for i in os.listdir('weights'): if '.h5' in i: if not Best: model_dirs.append(i) else: if 'Best' in i: model_dirs.append(i) preds = [] model = create_model() for mfile in model_dirs: print(os.path.join('weights', mfile)) model.load_weights(os.path.join('weights', mfile)) yPreds = model.predict(X_test, batch_size=128, verbose=0) preds.append(yPreds) weighted_predictions = np.zeros((X_test.shape[0], 10), dtype='float64') weight = 1. / len(preds) for prediction in preds: weighted_predictions += weight * prediction y_pred = weighted_predictions print(type(Y_test)) print(type(y_pred)) Y_test = tf.convert_to_tensor(Y_test) y_pred = tf.convert_to_tensor(y_pred) print(type(Y_test)) print(type(y_pred)) loss = metrics.categorical_crossentropy(Y_test, y_pred) acc = metrics.categorical_accuracy(Y_test, y_pred) sess = tf.Session() print('--------------------------------------') print('ensemble') print('Test loss:', loss.eval(session=sess)) print('error:', str((1. - acc.eval(session=sess)) * 100) + '%') print('--------------------------------------')
def __init__(self, Nin, Nh_l, Nout): self.X_ph = tf.placeholder(tf.float32, shape=(None, Nin)) self.L_ph = tf.placeholder(tf.float32, shape=(None, Nout)) # Modeling H = Dense(Nh_l[0], activation='relu')(self.X_ph) H = Dropout(0.5)(H) H = Dense(Nh_l[1], activation='relu')(H) H = Dropout(0.25)(H) self.Y_tf = Dense(Nout, activation='softmax')(H) # Operation self.Loss_tf = tf.reduce_mean( categorical_crossentropy(self.L_ph, self.Y_tf)) self.Train_tf = tf.train.AdamOptimizer().minimize(self.Loss_tf) self.Acc_tf = categorical_accuracy(self.L_ph, self.Y_tf) self.Init_tf = tf.global_variables_initializer()
def L_acc(y_true, y_pred): # Localization accuracy: a match is registered only if class is correctly identified with IOU > 0.6 # Confidence component (aka objectness) y_true_confidence = y_true[:, 0] y_pred_confidence = K.round(K.sigmoid(y_pred[:, 0])) # Class component y_true_classes = y_true[:, 4:] y_pred_classes = K.softmax(y_pred[:, 4:]) classes_accuracy = categorical_accuracy(y_true_classes, y_pred_classes) true_xy = y_true[:, 1:3] pred_xy = K.sigmoid(y_pred[:, 1:3]) true_r = y_true[:, 3:4] pred_r = K.exp(y_pred[:, 3:4]) # compute IOU, using the top,left,bottom,right representation. true_mins = true_xy - true_r true_maxes = true_xy + true_r pred_mins = pred_xy - pred_r pred_maxes = pred_xy + pred_r intersect_mins = K.maximum(pred_mins, true_mins) intersect_maxes = K.minimum(pred_maxes, true_maxes) intersect_wh = K.maximum(intersect_maxes - intersect_mins, 0.) intersect_areas = intersect_wh[..., 0] * intersect_wh[..., 1] pred_areas = 4. * pred_r[..., 0] * pred_r[..., 0] # a square true_areas = 4. * true_r[..., 0] * true_r[..., 0] union_areas = pred_areas + true_areas - intersect_areas iou_scores = intersect_areas / union_areas iou_accuracy = K.cast(iou_scores > 0.6, K.floatx()) joint_accuracy = (y_true_confidence * y_pred_confidence * classes_accuracy * iou_accuracy) + \ ((1.0 - y_true_confidence) * (1.0 - y_pred_confidence)) # if background, dont care about class or iou return joint_accuracy
def test_model(preds, in_images, test_files, chunk_size=64, shuffle=True): """Test the model""" import tensorflow as tf from keras import backend as K from keras.objectives import binary_crossentropy import numpy as np from keras.metrics import categorical_accuracy from tqdm import tqdm in_labels = tf.placeholder(tf.float32, shape=(None, 2)) cross_entropy = tf.reduce_mean(binary_crossentropy(in_labels, preds)) accuracy = tf.reduce_mean(categorical_accuracy(in_labels, preds)) auc = tf.metrics.auc(tf.cast(in_labels, tf.bool), preds) n_test_events = count_events(test_files) chunk_num = int(n_test_events/chunk_size)+1 preds_all = [] label_all = [] sess = tf.get_default_session() sess.run(tf.local_variables_initializer()) avg_accuracy = 0 avg_auc = 0 avg_test_loss = 0 is_training = tf.get_default_graph().get_tensor_by_name('is_training:0') for img_chunk, label_chunk, real_chunk_size in tqdm(chunks(test_files, chunk_size, shuffle=shuffle),total=chunk_num): test_loss, accuracy_result, auc_result, preds_result = sess.run([cross_entropy, accuracy, auc, preds], feed_dict={in_images: img_chunk, in_labels: label_chunk, K.learning_phase(): 0, is_training: False}) avg_test_loss += test_loss * real_chunk_size / n_test_events avg_accuracy += accuracy_result * real_chunk_size / n_test_events avg_auc += auc_result[0] * real_chunk_size / n_test_events preds_all.extend(preds_result) label_all.extend(label_chunk) print("test_loss = ", "{:.3f}".format(avg_test_loss)) print("Test Accuracy:", "{:.3f}".format(avg_accuracy), ", Area under ROC curve:", "{:.3f}".format(avg_auc)) return avg_test_loss, avg_accuracy, avg_auc, np.asarray(preds_all).reshape(n_test_events,2), np.asarray(label_all).reshape(n_test_events,2)
def recall(y_true, y_pred, num_aspect_ratios, num_classes): ''' Out of all the default boxes that are not background, how many does the model get right Parameters same as loss_with_negative_mining :param y_true: :param y_pred: :param num_aspect_ratios: :param num_classes: :return: ''' zero = tf.constant(0, dtype=tf.int32) # print "y_true", y_true, "y_pred", y_pred # remove extra zero padding y_true = tf.slice(y_true, begin=[0, 0, 0, 0], size=[-1, -1, -1, num_aspect_ratios]) y_pred_shape = tf.shape(y_pred) y_pred = tf.reshape(y_pred, shape=[ y_pred_shape[0], y_pred_shape[1], y_pred_shape[2], num_aspect_ratios, num_classes ]) # print "After reshape and slicing: y_true", y_true, "y_pred", y_pred y_pred = tf.reshape(y_pred, shape=[-1, num_classes]) y_true = tf.reshape(y_true, shape=[-1]) y_true = tf.cast(y_true, tf.int32) pos_indices = tf.squeeze(tf.where(tf.not_equal(y_true, zero))) print(pos_indices) y_true_pos = tf.gather(y_true, pos_indices) y_pred_pos = tf.gather(y_pred, pos_indices) #y_pred[pos_indices] y_true_pos_one_hot = tf.one_hot(y_true_pos, depth=num_classes) return categorical_accuracy(y_true_pos_one_hot, y_pred_pos)
def train(self): self.classifier = self.create_model() (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.reshape(-1, 28, 28, 1) x_test = x_test.reshape(-1, 28, 28, 1) y_train = to_categorical(y_train, num_classes=10) y_test = to_categorical(y_test, num_classes=10) callbacks = [ EarlyStopping(monitor='val_loss', min_delta=1e-6, patience=10) ] self.classifier.fit(x=x_train, y=y_train, batch_size=100, epochs=50, validation_split=0.1, callbacks=callbacks) self.classifier.save('classifier.h5') predictions = self.classifier.predict(x_test) y_pred = K.constant(predictions) y_true = K.constant(y_test) accuracy = np.mean(K.eval(categorical_accuracy(y_true, y_pred))) print(accuracy) return None
net = getattr(keras_helpers, args.network)() data_shape = [224, 224, 3] elif args.network == "GoogLeNet": net = getattr(keras_helpers, args.network)() data_shape = [224, 224, 3] else: sys.exit("Unknown Network") fake_data = np.random.rand(args.train_batch, data_shape[0], data_shape[1], data_shape[2]) tmp_fake_labels = np.random.randint(0, high=1000, size=args.train_batch) fake_labels = np.zeros([args.train_batch, 1000]) for i in range(args.train_batch): fake_labels[i, tmp_fake_labels[i]] = 1 loss = categorical_crossentropy(net.y_, net.y) top1 = categorical_accuracy(net.y_, net.y) top5 = top_k_categorical_accuracy(net.y_, net.y, 5) base_lr = 0.02 step = tf.Variable(0, trainable=False, name="Step") learning_rate = tf.train.exponential_decay(base_lr, step, 1, 0.999964) weight_list = [v for v in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES) if v.name[-3:] == "W:0"] bias_list = [v for v in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES) if v.name[-3:] == "b:0"] optimizer1 = tf.train.MomentumOptimizer(learning_rate, 0.9) optimizer2 = tf.train.MomentumOptimizer(tf.scalar_mul(2.0, learning_rate), 0.9) grads = optimizer1.compute_gradients(loss, var_list=weight_list+bias_list) w_grads = grads[:len(weight_list)] b_grads = grads[len(weight_list):]
def evaluate_cate(category_size, attribute_size, y_true, y_pred): return categorical_accuracy(y_true[:, :category_size], y_pred[:, :category_size])