def get_estimator(epochs=10, batch_size=32, alpha=1.0, warmup=0, model_dir=tempfile.mkdtemp()):
(x_train, y_train), (x_eval, y_eval) = tf.keras.datasets.cifar10.load_data()
data = {"train": {"x": x_train, "y": y_train}, "eval": {"x": x_eval, "y": y_eval}}
num_classes = 10
pipeline = fe.Pipeline(batch_size=batch_size, data=data, ops=Minmax(inputs="x", outputs="x"))
model = FEModel(model_def=lambda: LeNet(input_shape=x_train.shape[1:], classes=num_classes),
model_name="LeNet",
optimizer="adam")
mixup_map = {warmup: MixUpBatch(inputs="x", outputs=["x", "lambda"], alpha=alpha, mode="train")}
mixup_loss = {
0: SparseCategoricalCrossentropy(y_true="y", y_pred="y_pred", mode="train"),
warmup: MixUpLoss(KerasCrossentropy(), lam="lambda", y_true="y", y_pred="y_pred", mode="train")
}
network = fe.Network(ops=[
Scheduler(mixup_map),
ModelOp(inputs="x", model=model, outputs="y_pred"),
Scheduler(mixup_loss),
SparseCategoricalCrossentropy(y_true="y", y_pred="y_pred", mode="eval")
])
traces = [
Accuracy(true_key="y", pred_key="y_pred"),
ConfusionMatrix(true_key="y", pred_key="y_pred", num_classes=num_classes),
ModelSaver(model_name="LeNet", save_dir=model_dir, save_best=True)
]
estimator = fe.Estimator(network=network, pipeline=pipeline, epochs=epochs, traces=traces)
return estimator
def get_estimator(epochs=2, batch_size=32, model_dir=tempfile.mkdtemp()):
# step 1. prepare data
(x_train, y_train), (x_eval, y_eval) = tf.keras.datasets.mnist.load_data()
train_data = {"x": np.expand_dims(x_train, -1), "y": y_train}
eval_data = {"x": np.expand_dims(x_eval, -1), "y": y_eval}
data = {"train": train_data, "eval": eval_data}
pipeline = fe.Pipeline(batch_size=batch_size,
data=data,
ops=Minmax(inputs="x", outputs="x"))
# step 2. prepare model
model = fe.FEModel(model_def=LeNet, model_name="lenet", optimizer="adam")
network = fe.Network(ops=[
ModelOp(inputs="x", model=model, outputs="y_pred"),
SparseCategoricalCrossentropy(inputs=("y", "y_pred"))
])
# step 3.prepare estimator
traces = [
Accuracy(true_key="y", pred_key="y_pred", output_name='acc'),
ModelSaver(model_name="lenet", save_dir=model_dir, save_best=True)
]
estimator = fe.Estimator(network=network,
pipeline=pipeline,
epochs=epochs,
traces=traces)
return estimator
def get_estimator(batch_size=8, epochs=25, steps_per_epoch=None, validation_steps=None, model_dir=tempfile.mkdtemp()):
# load CUB200 dataset.
csv_path, path = cub200.load_data()
writer = RecordWriter(
save_dir=os.path.join(path, "tfrecords"),
train_data=csv_path,
validation_data=0.2,
ops=[
ImageReader(inputs='image', parent_path=path),
Resize(target_size=(512, 512), keep_ratio=True, outputs='image'),
MatReader(inputs='annotation', parent_path=path),
SelectDictKey(),
Resize((512, 512), keep_ratio=True),
Reshape(shape=(512, 512, 1), outputs="annotation")
])
#step 1, pipeline
pipeline = fe.Pipeline(
batch_size=batch_size,
data=writer,
ops=[
Augmentation2D(inputs=("image", "annotation"),
outputs=("image", "annotation"),
mode="train",
rotation_range=15.0,
zoom_range=[0.8, 1.2],
flip_left_right=True),
Rescale(inputs='image', outputs='image')
])
#step 2, network
opt = tf.optimizers.Adam(learning_rate=0.0001)
resunet50 = fe.build(model_def=ResUnet50, model_name="resunet50", optimizer=opt, loss_name="total_loss")
uncertainty = fe.build(model_def=UncertaintyLoss, model_name="uncertainty", optimizer=opt, loss_name="total_loss")
network = fe.Network(ops=[
ModelOp(inputs='image', model=resunet50, outputs=["label_pred", "mask_pred"]),
SparseCategoricalCrossentropy(inputs=["label", "label_pred"], outputs="cls_loss"),
BinaryCrossentropy(inputs=["annotation", "mask_pred"], outputs="seg_loss"),
ModelOp(inputs=("cls_loss", "seg_loss"), model=uncertainty, outputs="total_loss"),
Loss(inputs="total_loss", outputs="total_loss")
])
#step 3, estimator
traces = [
Dice(true_key="annotation", pred_key='mask_pred'),
Accuracy(true_key="label", pred_key="label_pred"),
ModelSaver(model_name="resunet50", save_dir=model_dir, save_best=True),
LRController(model_name="resunet50", lr_schedule=CyclicLRSchedule())
]
estimator = fe.Estimator(network=network,
pipeline=pipeline,
traces=traces,
epochs=epochs,
steps_per_epoch=steps_per_epoch,
validation_steps=validation_steps)
return estimator
def get_estimator(epochs=10,
batch_size=64,
max_len=500,
steps_per_epoch=None,
validation_steps=None,
model_dir=tempfile.mkdtemp()):
# step 1. prepare data
(x_train,
y_train), (x_eval,
y_eval) = tf.keras.datasets.imdb.load_data(maxlen=max_len,
num_words=MAX_WORDS)
data = {
"train": {
"x": np.array([pad(x, max_len, 0) for x in x_train]),
"y": y_train
},
"eval": {
"x": np.array([pad(x, max_len, 0) for x in x_eval]),
"y": y_eval
}
}
pipeline = fe.Pipeline(batch_size=batch_size,
data=data,
ops=Reshape([1], inputs="y", outputs="y"))
# step 2. prepare model
model = fe.build(model_def=lambda: create_lstm(max_len),
model_name="lstm_imdb",
optimizer="adam",
loss_name="loss")
network = fe.Network(ops=[
ModelOp(inputs="x", model=model, outputs="y_pred"),
BinaryCrossentropy(y_true="y", y_pred="y_pred", outputs="loss")
])
traces = [
Accuracy(true_key="y", pred_key="y_pred"),
ModelSaver(model_name="lstm_imdb", save_dir=model_dir, save_best=True)
]
# step 3.prepare estimator
estimator = fe.Estimator(network=network,
pipeline=pipeline,
epochs=epochs,
traces=traces,
steps_per_epoch=steps_per_epoch,
validation_steps=validation_steps)
return estimator
def get_estimator(epochs=50,
batch_size=64,
steps_per_epoch=None,
validation_steps=None,
model_dir=tempfile.mkdtemp()):
# step 1. prepare data
(x_train, y_train), (x_eval,
y_eval) = tf.keras.datasets.cifar10.load_data()
data = {
"train": {
"x": x_train,
"y": y_train
},
"eval": {
"x": x_eval,
"y": y_eval
}
}
pipeline = fe.Pipeline(batch_size=batch_size,
data=data,
ops=Minmax(inputs="x", outputs="x"))
# step 2. prepare model
model = fe.build(model_def=DenseNet121_cifar10,
model_name="densenet121",
optimizer="adam",
loss_name="loss")
network = fe.Network(ops=[
ModelOp(inputs="x", model=model, outputs="y_pred"),
SparseCategoricalCrossentropy(
y_true="y", y_pred="y_pred", outputs="loss")
])
# step 3.prepare estimator
estimator = fe.Estimator(network=network,
pipeline=pipeline,
epochs=epochs,
steps_per_epoch=steps_per_epoch,
validation_steps=validation_steps,
traces=[
Accuracy(true_key="y", pred_key="y_pred"),
ModelSaver(model_name="densenet121",
save_dir=model_dir,
save_best=True),
LRController(model_name="densenet121",
reduce_on_eval=True)
])
return estimator
def get_estimator(epochs=10,
batch_size=32,
epsilon=0.01,
warmup=0,
model_dir=tempfile.mkdtemp()):
(x_train, y_train), (x_eval,
y_eval) = tf.keras.datasets.cifar10.load_data()
data = {
"train": {
"x": x_train,
"y": y_train
},
"eval": {
"x": x_eval,
"y": y_eval
}
}
num_classes = 10
pipeline = Pipeline(batch_size=batch_size,
data=data,
ops=Minmax(inputs="x", outputs="x"))
model = FEModel(model_def=lambda: LeNet(input_shape=x_train.shape[1:],
classes=num_classes),
model_name="LeNet",
optimizer="adam")
adv_img = {
warmup:
AdversarialSample(inputs=("loss", "x"),
outputs="x_adverse",
epsilon=epsilon,
mode="train")
}
adv_eval = {
warmup:
ModelOp(inputs="x_adverse",
model=model,
outputs="y_pred_adverse",
mode="train")
}
adv_loss = {
warmup:
SparseCategoricalCrossentropy(y_true="y",
y_pred="y_pred_adverse",
outputs="adverse_loss",
mode="train")
}
adv_avg = {
warmup:
Average(inputs=("loss", "adverse_loss"), outputs="loss", mode="train")
}
network = Network(ops=[
ModelOp(inputs="x", model=model, outputs="y_pred", track_input=True),
SparseCategoricalCrossentropy(
y_true="y", y_pred="y_pred", outputs="loss"),
Scheduler(adv_img),
Scheduler(adv_eval),
Scheduler(adv_loss),
Scheduler(adv_avg)
])
traces = [
Accuracy(true_key="y", pred_key="y_pred"),
ConfusionMatrix(true_key="y",
pred_key="y_pred",
num_classes=num_classes),
ModelSaver(model_name="LeNet", save_dir=model_dir, save_freq=2)
]
estimator = Estimator(network=network,
pipeline=pipeline,
epochs=epochs,
traces=traces)
return estimator