def train(model_name: str, name: str = "nofolds") -> None:
""" Loads model from file and trains it. """
model = keras.models.load_model(model_name)
model.summary()
map3 = Map3Metric(x_val, y_val, name)
# early_stopping = keras.callbacks.EarlyStopping(monitor='val_loss',
# min_delta=0.01, patience=10, verbose=1)
lr_shed = keras.callbacks.LearningRateScheduler(cyclic_lr, verbose=1)
# time_stopping = TimedStopping(timeout=15*60*60, verbose=1)
datagen = keras.preprocessing.image.ImageDataGenerator(
width_shift_range=
0, # randomly shift images horizontally (fraction of total width)
horizontal_flip=False, # randomly flip images
preprocessing_function=get_random_eraser(
v_l=np.min(x_train), v_h=np.max(x_train)) # random eraser
)
datagen = MixupGenerator(x_train,
y_train,
alpha=1.0,
batch_size=BATCH_SIZE,
datagen=datagen)
# datagen = AugGenerator(x_train, y_train, alpha=1.0, batch_size=BATCH_SIZE,
# datagen=None, shuffle=False)
model.fit_generator(datagen,
epochs=NUM_EPOCHS,
verbose=1,
validation_data=[x_val, y_val],
use_multiprocessing=True,
workers=12,
callbacks=[map3, lr_shed])
print("best MAP@3 value: %.04f at epoch %d" %
(map3.best_map3, map3.best_epoch))
def train_model(params: Dict[str, Any], name: str ="nofolds") -> float:
""" Creates model and trains it. Returns MAP@3 metric. """
print("training with params", params)
shift = float(params["shift"])
flip = bool(params["flip"])
erase = bool(params["erase"])
alpha = float(params["alpha"])
mixup = bool(params["mixup"])
x = inp = keras.layers.Input(shape=x_train.shape[1:])
x = keras.layers.Reshape((x_train.shape[1], x_train.shape[2], 1))(x)
x = keras.layers.Convolution2D(32, (4, 10), padding="same")(x)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Activation("relu")(x)
x = keras.layers.MaxPool2D()(x)
x = keras.layers.Convolution2D(32, (4, 10), padding="same")(x)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Activation("relu")(x)
x = keras.layers.MaxPool2D()(x)
x = keras.layers.Convolution2D(32, (4, 10), padding="same")(x)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Activation("relu")(x)
x = keras.layers.MaxPool2D()(x)
x = keras.layers.Convolution2D(32, (4, 10), padding="same")(x)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Activation("relu")(x)
x = keras.layers.MaxPool2D()(x)
x = keras.layers.Flatten()(x)
x = keras.layers.Dense(64)(x)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Activation("relu")(x)
out = keras.layers.Dense(NUM_CLASSES, activation="softmax")(x)
model = keras.models.Model(inputs=inp, outputs=out)
model.summary()
model.compile(loss="categorical_crossentropy", optimizer="adam",
metrics=["accuracy"])
map3 = Map3Metric(x_val, y_val, name)
reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='val_loss',
factor=0.33, patience=7, verbose=1, min_lr=3e-6)
datagen = keras.preprocessing.image.ImageDataGenerator(
width_shift_range=shift, # 0.4, # randomly shift images horizontally (fraction of total width)
horizontal_flip=flip, # randomly flip images
preprocessing_function=
# random eraser
get_random_eraser(v_l=np.min(x_train), v_h=np.max(x_train)) if erase else None
)
if mixup:
mixupgen = MixupGenerator(x_train, y_train, alpha=alpha,
batch_size=BATCH_SIZE, datagen=datagen)
else:
mixupgen = AugGenerator(x_train, y_train, alpha=alpha,
batch_size=BATCH_SIZE, datagen=datagen)
model.fit_generator(mixupgen,
epochs=NUM_EPOCHS, verbose=1,
validation_data=[x_val, y_val],
use_multiprocessing=True, workers=12,
callbacks=[map3, reduce_lr])
print("best MAP@3 value: %.04f at epoch %d" % (map3.best_map3, map3.best_epoch))
return map3.best_map3
def train_model(params: Dict[str, Any], name: str ="nofolds") -> float:
""" Creates model and trains it. Returns MAP@3 metric. """
cnn_dropout = float(params["cnn_dropout"])
dropout_coeff = float(params["dropout_coeff"])
reg_coeff = float(params["reg_coeff"])
reg_coeff2 = reg_coeff
conv_depth = 27 # int(params["conv_depth"])
num_hidden = int(params["num_hidden"])
conv_width = 4 # int(params["conv_width"])
conv_height = 6 # int(params["conv_height"])
conv_count = 4 # int(params["conv_count"])
# TODO: search for the best pooling size
shift = float(params["shift"])
flip = False # bool(params["flip"])
erase = bool(params["erase"])
alpha = float(params["alpha"])
mixup = True # bool(params["mixup"])
print("training with params", params)
reg = keras.regularizers.l2(10 ** reg_coeff)
reg2 = keras.regularizers.l2(10 ** reg_coeff2)
x = inp = keras.layers.Input(shape=x_train.shape[1:])
x = keras.layers.Reshape((x_train.shape[1], x_train.shape[2], 1))(x)
for _ in range(conv_count):
x = keras.layers.Convolution2D(conv_depth, (conv_width, conv_height),
padding="same")(x)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Activation("relu")(x)
x = keras.layers.MaxPool2D()(x)
if cnn_dropout > 0.001:
x = keras.layers.Dropout(cnn_dropout)(x)
x = keras.layers.Flatten()(x)
x = keras.layers.Dense(num_hidden,
kernel_regularizer=reg,
bias_regularizer=reg,
activity_regularizer=reg,
)(x)
if dropout_coeff > 0.001:
x = keras.layers.Dropout(dropout_coeff)(x)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Activation("relu")(x)
out = keras.layers.Dense(NUM_CLASSES,
kernel_regularizer=reg2,
bias_regularizer=reg2,
activity_regularizer=reg2,
activation="softmax")(x)
model = keras.models.Model(inputs=inp, outputs=out)
model.summary()
model.compile(loss="categorical_crossentropy", optimizer="adam",
metrics=["accuracy"])
map3 = Map3Metric(x_val, y_val, name)
reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='val_loss',
factor=0.33, patience=7, verbose=1, min_lr=3e-6)
datagen = keras.preprocessing.image.ImageDataGenerator(
width_shift_range=shift, # 0.4, # randomly shift images horizontally (fraction of total width)
horizontal_flip=flip, # randomly flip images
preprocessing_function=
# random eraser
get_random_eraser(v_l=np.min(x_train), v_h=np.max(x_train)) if erase else None
)
if mixup:
mixupgen = MixupGenerator(x_train, y_train, alpha=alpha,
batch_size=BATCH_SIZE, datagen=datagen)
else:
mixupgen = AugGenerator(x_train, y_train, alpha=alpha,
batch_size=BATCH_SIZE, datagen=datagen)
model.fit_generator(mixupgen,
epochs=NUM_EPOCHS, verbose=1,
validation_data=[x_val, y_val],
use_multiprocessing=True, workers=12,
callbacks=[map3, reduce_lr])
print("best MAP@3 value: %.04f at epoch %d" % (map3.best_map3,
map3.best_epoch + 1))
return map3.best_map3
def train_model_with_params(params: Dict[str, str],
name: str = "nofolds") -> float:
""" Creates model with given parameters. """
print("training with params", params)
batch_size = int(params["batch_size"])
num_hidden = int(params["num_hidden"])
num_fc_layers = int(params["num_fc_layers"])
num_conv_layers = int(params["num_conv_layers"])
conv_depth = int(params["conv_depth"])
conv_depth_mul = float(params["conv_depth_mul"])
conv_width = int(params["conv_width"])
conv_height = int(params["conv_height"])
pooling_size = int(params["pooling_size"])
pooling_type = params["pooling_type"]
dropout_coeff = float(params["dropout_coeff"])
reg_coeff = float(params["reg_coeff"])
residuals = "" # params["residuals"]
shift = float(params["shift"])
flip = bool(params["flip"])
erase = False # bool(params["erase"])
alpha = float(params["alpha"])
if residuals is not "":
conv_depth_mul = 1
fc_bias_reg = fc_activity_reg = fc_kernel_reg = make_reg(reg_coeff)
print("x_train:", x_train.shape)
x = inp = keras.layers.Input(shape=x_train.shape[1:])
# x = keras.layers.Reshape((x_train.shape[1], x_train.shape[2], 1))(x)
w, h = x_train.shape[1], x_train.shape[2]
conv_layers = []
for L in range(num_conv_layers):
if pooling_type.startswith("local"):
w, h = (w + 1) / pooling_size, (h + 1) / pooling_size
if w < 2 or h < 2:
break
conv_layers.append(x)
if L % 2 == 0:
prev = x
d = min(int(conv_depth * (conv_depth_mul**L)), 100)
x = keras.layers.Convolution2D(d, (conv_width, conv_height),
padding="same")(x)
x = keras.layers.BatchNormalization()(x)
if pooling_type.startswith("global"):
if residuals == "resnet" and L % 2 == 1:
x = keras.layers.Add()([prev, x])
elif residuals == "densenet":
# print("conv_layers", conv_layers)
x = keras.layers.Add()(conv_layers + [x])
x = keras.layers.Activation("relu")(x)
if pooling_type == "local_max":
x = keras.layers.MaxPooling2D((pooling_size, pooling_size))(x)
elif pooling_type == "local_avg":
x = keras.layers.AveragePooling2D((pooling_size, pooling_size))(x)
if pooling_type == "global_max":
x = keras.layers.GlobalMaxPooling2D()(x)
elif pooling_type == "global_avg":
x = keras.layers.GlobalAveragePooling2D()(x)
else:
x = keras.layers.Flatten()(x)
for _ in range(num_fc_layers):
x = keras.layers.Dense(num_hidden,
kernel_regularizer=fc_kernel_reg,
bias_regularizer=fc_bias_reg,
activity_regularizer=fc_activity_reg)(x)
x = keras.layers.Dropout(dropout_coeff)(x)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Activation("relu")(x)
out = keras.layers.Dense(NUM_CLASSES,
kernel_regularizer=fc_kernel_reg,
bias_regularizer=fc_bias_reg,
activity_regularizer=fc_activity_reg,
activation="softmax")(x)
model = keras.models.Model(inputs=inp, outputs=out)
model.summary()
model.compile(loss="categorical_crossentropy",
optimizer="adam",
metrics=["accuracy"])
if model.count_params() >= 4 * 10**6:
return 0.5
map3 = Map3Metric(x_val, y_val, name)
# early_stopping = keras.callbacks.EarlyStopping(monitor='val_loss',
# min_delta=0.01, patience=10, verbose=1)
lr_shed = keras.callbacks.LearningRateScheduler(cyclic_lr, verbose=1)
time_stopping = TimedStopping(timeout=15 * 60 * 60, verbose=1)
datagen = keras.preprocessing.image.ImageDataGenerator(
width_shift_range=
shift, # 0.4, # randomly shift images horizontally (fraction of total width)
horizontal_flip=flip, # randomly flip images
preprocessing_function=get_random_eraser(v_l=np.min(x_train),
v_h=np.max(x_train))
if erase else None # random eraser
)
mixupgen = MixupGenerator(x_train,
y_train,
alpha=alpha,
batch_size=batch_size,
datagen=datagen)
model.fit_generator(mixupgen,
epochs=NUM_EPOCHS,
verbose=1,
validation_data=[x_val, y_val],
use_multiprocessing=True,
workers=12,
callbacks=[map3, lr_shed, time_stopping])
print("best MAP@3 value: %.04f at epoch %d" %
(map3.best_map3, map3.best_epoch))
return map3.last_map3