def testCreateTPUEstimatorSpec(self):
"""Tests that an Estimator built with this head works."""
train_features, train_labels = test_utils.make_input_data(256, 2)
feature_columns = []
for key in train_features:
feature_columns.append(tf.feature_column.numeric_column(key=key))
head = binary_class_head.DPBinaryClassHead()
optimizer = DPKerasSGDOptimizer(learning_rate=0.5,
l2_norm_clip=1.0,
noise_multiplier=0.0,
num_microbatches=2)
model_fn = test_utils.make_model_fn(head, optimizer, feature_columns)
classifier = tf.estimator.Estimator(model_fn=model_fn)
classifier.train(input_fn=test_utils.make_input_fn(
train_features, train_labels, True),
steps=4)
test_features, test_labels = test_utils.make_input_data(64, 2)
classifier.evaluate(input_fn=test_utils.make_input_fn(
test_features, test_labels, False),
steps=4)
predict_features, predict_labels_ = test_utils.make_input_data(64, 2)
classifier.predict(input_fn=test_utils.make_input_fn(
predict_features, predict_labels_, False))
def create_dp_optimizer(l2_clip, noise_multi, micro_batches, learning_rate):
optimizer = DPKerasSGDOptimizer(l2_norm_clip=l2_clip,
noise_multiplier=noise_multi,
num_microbatches=micro_batches,
learning_rate=learning_rate)
return optimizer
def main(unused_argv):
logging.set_verbosity(logging.INFO)
if FLAGS.dpsgd and FLAGS.batch_size % FLAGS.microbatches != 0:
raise ValueError(
'Number of microbatches should divide evenly batch_size')
# Load training and test data.
train_data, train_labels, test_data, test_labels = load_mnist()
# Define a sequential Keras model
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(16,
8,
strides=2,
padding='same',
activation='relu',
input_shape=(28, 28, 1)),
tf.keras.layers.MaxPool2D(2, 1),
tf.keras.layers.Conv2D(32,
4,
strides=2,
padding='valid',
activation='relu'),
tf.keras.layers.MaxPool2D(2, 1),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(32, activation='relu'),
tf.keras.layers.Dense(10)
])
if FLAGS.dpsgd:
optimizer = DPKerasSGDOptimizer(
l2_norm_clip=FLAGS.l2_norm_clip,
noise_multiplier=FLAGS.noise_multiplier,
num_microbatches=FLAGS.microbatches,
learning_rate=FLAGS.learning_rate)
# Compute vector of per-example loss rather than its mean over a minibatch.
loss = tf.keras.losses.CategoricalCrossentropy(
from_logits=True, reduction=tf.losses.Reduction.NONE)
else:
optimizer = tf.keras.optimizers.SGD(learning_rate=FLAGS.learning_rate)
loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
# Compile model with Keras
model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])
# Train model with Keras
model.fit(train_data,
train_labels,
epochs=FLAGS.epochs,
validation_data=(test_data, test_labels),
batch_size=FLAGS.batch_size)
# Compute the privacy budget expended.
if FLAGS.dpsgd:
eps = compute_epsilon(FLAGS.epochs * 60000 // FLAGS.batch_size)
print('For delta=1e-5, the current epsilon is: %.2f' % eps)
else:
print('Trained with vanilla non-private SGD optimizer')
def __init__(self,
num_epoch=60,
dp_flag=0,
l2_norm_clip=1.0,
noise_multiplier=1.3,
num_microbatches=25,
learning_rate=0.01,
data_size=10000,
verbos=1,
reduce=1):
self.nm = noise_multiplier
self.l2 = l2_norm_clip
self.dp = dp_flag
self.num_epoch = num_epoch
self.batch_size = num_microbatches
self.data_size = data_size
self.verbos = verbos
self.t_model = tf.keras.Sequential([
tf.keras.layers.Dense(512, activation='relu'),
tf.keras.layers.Dense(256, activation='relu'),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(2, activation='softmax')
])
if reduce:
self.lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
learning_rate,
decay_steps=1000,
decay_rate=0.96,
staircase=True)
else:
self.lr_schedule = learning_rate
if self.dp:
self.opt = DPKerasSGDOptimizer(l2_norm_clip=self.l2,
noise_multiplier=self.nm,
num_microbatches=self.batch_size,
learning_rate=self.lr_schedule)
else:
self.opt = tf.keras.optimizers.SGD(learning_rate=self.lr_schedule)
self.loss = tf.keras.losses.SparseCategoricalCrossentropy(
from_logits=True, reduction=tf.keras.losses.Reduction.NONE)
self.t_model.compile(optimizer=self.opt,
loss=self.loss,
metrics=['accuracy'])
def star_train(self):
train_data, train_labels, val_data, val_labels, test_data, test_labels = self.load_candlestick(
)
optimizer = DPKerasSGDOptimizer(l2_norm_clip=self.l2_norm_clip,
noise_multiplier=self.noise_multiplier,
num_microbatches=30,
learning_rate=self.learning_rate,
momentum=0.9)
loss = tf.keras.losses.CategoricalCrossentropy(
from_logits=True, reduction=tf.losses.Reduction.NONE)
model = self.create_model()
model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])
self.history = model.fit(train_data.astype(np.float32),
train_labels.astype(np.float32),
epochs=self.epochs,
validation_data=(val_data.astype(np.float32),
val_labels.astype(
np.float32)),
batch_size=30)
test_pred = model.predict(test_data)
test_pred = np.argmax(test_pred, axis=1)
test_true = np.argmax(test_labels, axis=1)
test_result_cm = confusion_matrix(test_true,
test_pred,
labels=range(8))
print(test_result_cm)
count = 0
for r in range(8):
count += test_result_cm[r, r]
print('testing accuracy:', count / np.sum(test_result_cm))
self.eps = self.compute_epsilon(self.epochs * train_data.shape[0] //
100)
print('For delta=1e-5, the current epsilon is: %.2f' % self.eps)