def main() -> None:
parser = argparse.ArgumentParser(description="Flower")
parser.add_argument(
"--server",
type=str,
default="[::]:6000",
help=f"gRPC server address (default: [::]:6000)",
)
parser.add_argument("--partition",
type=int,
required=True,
help="Partition index (no default)")
parser.add_argument(
"--clients",
type=int,
required=True,
help="Number of clients (no default)",
)
args = parser.parse_args()
# Load and compile Keras model
model = tf.keras.applications.MobileNetV2()
model.compile("adam",
"sparse_categorical_crossentropy",
metrics=["accuracy"])
# Load CIFAR-10 dataset
# (x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()
xy_train, xy_test = fashion_mnist.load_data(partition=args.partition,
num_partitions=args.clients)
# Define Flower client
class CifarClient(fl.client.keras_client.KerasClient):
def get_weights(self): # type: ignore
return model.get_weights()
def fit(self, weights, config): # type: ignore
x_train, y_train = xy_train
model.set_weights(weights)
model.fit(x_train, y_train,
epochs=5) #, batch_size=32, steps_per_epoch=3)
return model.get_weights(), len(x_train), len(x_train)
def evaluate(self, weights, config): # type: ignore
x_test, y_test = xy_test
model.set_weights(weights)
loss, accuracy = model.evaluate(x_test, y_test)
return len(x_test), loss, accuracy
# Start Flower client
fl.client.start_keras_client(server_address=args.server,
client=CifarClient())
def main(argv=None):
"""Run the training experiment"""
# Read fashion mnist data
mnist_train, mnist_test = fashion_mnist.load_data()
config = tf.estimator.RunConfig(
model_dir=FLAGS.log_dir,
save_summary_steps=100,
log_step_count_steps=100,
save_checkpoints_steps=500,
)
# Setup the Estimator
estimator = tf.estimator.Estimator(model_fn=model_fn, config=config)
# Start training and validation
train_spec = tf.estimator.TrainSpec(
input_fn=lambda: get_train_inputs(FLAGS.batch_size, mnist_train),
max_steps=FLAGS.steps)
eval_spec = tf.estimator.EvalSpec(
input_fn=lambda: get_eval_inputs(FLAGS.batch_size, mnist_test),
steps=None,
start_delay_secs=10, # Start evaluating after 10 sec.
throttle_secs=30 # Evaluate only every 30 sec
)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
t = now()
model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test))
print('Training time: %s' % (now() - t))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test score:', score[0])
print('Test accuracy:', score[1])
# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()
# create two datasets one with digits below 5 and one with 5 and above
x_train_lt5 = x_train[y_train < 5]
y_train_lt5 = y_train[y_train < 5]
x_test_lt5 = x_test[y_test < 5]
y_test_lt5 = y_test[y_test < 5]
x_train_gte5 = x_train[y_train >= 5]
y_train_gte5 = y_train[y_train >= 5] - 5
x_test_gte5 = x_test[y_test >= 5]
y_test_gte5 = y_test[y_test >= 5] - 5
# define two groups of layers: feature (convolutions) and classification (dense)
feature_layers = [
Conv2D(filters, kernel_size, padding='valid', input_shape=input_shape),
if keras.backend.image_data_format() == 'channels_first':
input_shape = (1, 28, 28) # image shape
else:
input_shape = (28, 28, 1) # image shape
num_class = 10 # number of class
# load and pre-process data
def preprocess_input(x):
return x.reshape((-1, ) + input_shape) / 255.
def preprocess_output(y):
return keras.utils.to_categorical(y)
(train_x, train_y), (validation_x, validation_y) = fashion_mnist.load_data()
train_x, validation_x = map(preprocess_input, [train_x, validation_x])
train_y, validation_y = map(preprocess_output, [train_y, validation_y])
print('Loading FASHION MNIST data...')
print('train_x shape:', train_x.shape, 'train_y shape:', train_y.shape)
print('validation_x shape:', validation_x.shape,
'validation_y shape', validation_y.shape)
# knowledge transfer algorithms
def wider2net_conv2d(teacher_w1, teacher_b1, teacher_w2, new_width, init):
'''Get initial weights for a wider conv2d layer with a bigger filters,
by 'random-padding' or 'net2wider'.
# Arguments
teacher_w1: `weight` of conv2d layer to become wider,
if __name__ == "__main__":
font = FontProperties(fname = r"/mnt/c/Windows/Fonts/simsun.ttc", size = 6)
data_path = '../../data/fashion'
class_names = ['短袖圆领T恤', '裤子', '套衫', '连衣裙', '外套', '凉鞋', '衬衫', '运动鞋','包', '短靴']
file_list = ['t10k-images-idx3-ubyte.gz',
't10k-labels-idx1-ubyte.gz',
'train-images-idx3-ubyte.gz',
'train-labels-idx1-ubyte.gz']
for i in file_list:
load_data(data_path, i)
#训练数据
headers, images = extract_train_img_data(os.path.join(data_path, 'train-images-idx3-ubyte.gz'))
header_array = np.frombuffer(headers, dtype = '>u4')
print(header_array)
X = np.zeros(shape = (60000, 784))
for i in range(header_array[1]):
X[i] = np.frombuffer(images[i], dtype = '>u1') / 255
labels = extract_train_label_data(os.path.join(data_path, 'train-labels-idx1-ubyte.gz'))
#测试数据
test_headers, test_images = extract_train_img_data(os.path.join(data_path, 't10k-images-idx3-ubyte.gz'))
def main() -> None:
parser = argparse.ArgumentParser(description="Flower")
parser.add_argument(
"--server_address",
type=str,
default="[::]:8080",
help=f"gRPC server address",
)
parser.add_argument("--partition",
type=int,
required=True,
help="Partition index (no default)")
parser.add_argument(
"--clients",
type=int,
required=True,
help="Number of clients (no default)",
)
args = parser.parse_args()
# Build and compile Keras model
# model = tf.keras.models.Sequential(
# [
# tf.keras.layers.Flatten(input_shape=(28, 28)),
# tf.keras.layers.Dense(128, activation="relu"),
# tf.keras.layers.Dropout(0.2),
# tf.keras.layers.Dense(10, activation="softmax"),
# ]
# )
# model.compile(
# optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"]
# )
model = fashion_mnist.load_model()
xy_train, xy_test = fashion_mnist.load_data(partition=args.partition,
num_partitions=args.clients)
# Implement a Flower client
class MnistClient(fl.client.keras_client.KerasClient):
def __init__(
self,
model: tf.keras.Model,
x_train: np.ndarray,
y_train: np.ndarray,
x_test: np.ndarray,
y_test: np.ndarray,
) -> None:
self.model = model
self.x_train, self.y_train = x_train, y_train
self.x_test, self.y_test = x_test, y_test
def get_weights(self) -> fl.common.Weights:
return cast(fl.common.Weights, self.model.get_weights())
def fit(self, weights: fl.common.Weights,
config: Dict[str, str]) -> Tuple[fl.common.Weights, int, int]:
# Use provided weights to update local model
self.model.set_weights(weights)
# Train the local model using local dataset
self.model.fit(
self.x_train,
self.y_train,
batch_size=int(config["batch_size"]),
epochs=int(config["epochs"]),
)
return self.model.get_weights(), len(self.x_train), len(
self.x_train)
def evaluate(self, weights: fl.common.Weights,
config: Dict[str, str]) -> Tuple[int, float, float]:
# Update local model and evaluate on local dataset
self.model.set_weights(weights)
loss, accuracy = self.model.evaluate(self.x_test,
self.y_test,
batch_size=len(self.x_test),
verbose=2)
# Return number of evaluation examples and evaluation result (loss/accuracy)
return len(self.x_test), float(loss), float(accuracy)
# Load MNIST data
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
# Instanstiate client
client = MnistClient(model, x_train, y_train, x_test, y_test)
# Start client
fl.client.start_keras_client(server_address=args.server_address,
client=client)
if K.backend() == 'tensorflow':
raise RuntimeError('This example can only run with the '
'Theano backend for the time being, '
'because it requires taking the gradient '
'of a gradient, which isn\'t '
'supported for all TF ops.')
# This example assume 'channels_first' data format.
K.set_image_data_format('channels_first')
# input image dimensions
img_rows, img_cols = 28, 28
# the data, shuffled and split between train and test sets
(x_train, _), (x_test, _) = fashion_mnist.load_data()
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# The size of the kernel used for the MaxPooling2D
pool_size = 2
# The total number of feature maps at each layer
nfeats = [8, 16, 32, 64, 128]
