Kaggle competition: Quick, Draw! Doodle Recognition Challenge
<SOS> metric: MAP@{K} Kaggle data source: quick,-draw!-doodle-recognition-challenge<import_modules>
BASE_SIZE = 256
DP_DIR = '.. /input/shuffle-csvs/'
INPUT_DIR = '.. /input/quickdraw-doodle-recognition/'
NCSVS = 100
NCATS = 340
print(os.listdir(".. /input"))
BASE_WEIGHTS_PATH = 'https://storage.googleapis.com/keras-applications/'
WEIGHTS_HASHES = {
'b0':('902e53a9f72be733fc0bcb005b3ebbac',
'50bc09e76180e00e4465e1a485ddc09d'),
'b1':('1d254153d4ab51201f1646940f018540',
'74c4e6b3e1f6a1eea24c589628592432'),
'b2':('b15cce36ff4dcbd00b6dd88e7857a6ad',
'111f8e2ac8aa800a7a99e3239f7bfb39'),
'b3':('ffd1fdc53d0ce67064dc6a9c7960ede0',
'af6d107764bb5b1abb91932881670226'),
'b4':('18c95ad55216b8f92d7e70b3a046e2fc',
'ebc24e6d6c33eaebbd558eafbeedf1ba'),
'b5':('ace28f2a6363774853a83a0b21b9421a',
'38879255a25d3c92d5e44e04ae6cec6f'),
'b6':('165f6e37dce68623721b423839de8be5',
'9ecce42647a20130c1f39a5d4cb75743'),
'b7':('8c03f828fec3ef71311cd463b6759d99',
'cbcfe4450ddf6f3ad90b1b398090fe4a'),
}
DEFAULT_BLOCKS_ARGS = [{
'kernel_size': 3,
'repeats': 1,
'filters_in': 32,
'filters_out': 16,
'expand_ratio': 1,
'id_skip': True,
'strides': 1,
'se_ratio': 0.25
}, {
'kernel_size': 3,
'repeats': 2,
'filters_in': 16,
'filters_out': 24,
'expand_ratio': 6,
'id_skip': True,
'strides': 2,
'se_ratio': 0.25
}, {
'kernel_size': 5,
'repeats': 2,
'filters_in': 24,
'filters_out': 40,
'expand_ratio': 6,
'id_skip': True,
'strides': 2,
'se_ratio': 0.25
}, {
'kernel_size': 3,
'repeats': 3,
'filters_in': 40,
'filters_out': 80,
'expand_ratio': 6,
'id_skip': True,
'strides': 2,
'se_ratio': 0.25
}, {
'kernel_size': 5,
'repeats': 3,
'filters_in': 80,
'filters_out': 112,
'expand_ratio': 6,
'id_skip': True,
'strides': 1,
'se_ratio': 0.25
}, {
'kernel_size': 5,
'repeats': 4,
'filters_in': 112,
'filters_out': 192,
'expand_ratio': 6,
'id_skip': True,
'strides': 2,
'se_ratio': 0.25
}, {
'kernel_size': 3,
'repeats': 1,
'filters_in': 192,
'filters_out': 320,
'expand_ratio': 6,
'id_skip': True,
'strides': 1,
'se_ratio': 0.25
}]
CONV_KERNEL_INITIALIZER = {
'class_name': 'VarianceScaling',
'config': {
'scale': 2.0,
'mode': 'fan_out',
'distribution': 'truncated_normal'
}
}
DENSE_KERNEL_INITIALIZER = {
'class_name': 'VarianceScaling',
'config': {
'scale': 1./ 3.,
'mode': 'fan_out',
'distribution': 'uniform'
}
}
def EfficientNet(
 width_coefficient,
depth_coefficient,
default_size,
dropout_rate=0.2,
drop_connect_rate=0.2,
depth_divisor=8,
activation='swish',
blocks_args='default',
model_name='efficientnet',
include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation='softmax', 
):

 if blocks_args == 'default':
blocks_args = DEFAULT_BLOCKS_ARGS
if not(weights in {'imagenet', None} or os.path.exists(weights)) :
raise ValueError('The `weights` argument should be either '
'`None`(random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
 if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as `"imagenet"` with `include_top`'
' as true, `classes` should be 1000')
 input_shape = imagenet_utils.obtain_input_shape(
 input_shape,
default_size=default_size,
min_size=32,
data_format=backend.image_data_format() ,
require_flatten=include_top,
weights=weights)
 if input_tensor is None:
img_input = layers.Input(shape=input_shape)
 else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
 else:
img_input = input_tensor
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
def round_filters(filters, divisor=depth_divisor):

 filters *= width_coefficient
new_filters = max(divisor, int(filters + divisor / 2)// divisor * divisor)
 if new_filters < 0.9 * filters:
new_filters += divisor
return int(new_filters)
 def round_repeats(repeats):

 return int(math.ceil(depth_coefficient * repeats))
x = img_input
x = layers.Normalization(axis=bn_axis )(x)
 x = layers.ZeroPadding2D(
 padding=imagenet_utils.correct_pad(x, 3),
name='stem_conv_pad' )(x)
 x = layers.Conv2D(
 round_filters(32),
3,
strides=2,
padding='valid',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='stem_conv' )(x)
 x = layers.BatchNormalization(axis=bn_axis, name='stem_bn' )(x)
 x = layers.Activation(activation, name='stem_activation' )(x)
 blocks_args = copy.deepcopy(blocks_args)
 b = 0
blocks = float(sum(args['repeats'] for args in blocks_args))
for(i, args)in enumerate(blocks_args):
assert args['repeats'] > 0
args['filters_in'] = round_filters(args['filters_in'])
 args['filters_out'] = round_filters(args['filters_out'])
 for j in range(round_repeats(args.pop('repeats'))):
if j > 0:
args['strides'] = 1
args['filters_in'] = args['filters_out']
x = block(
 x,
activation,
drop_connect_rate * b / blocks,
name='block{}{}_'.format(i + 1, chr(j + 97)) ,
**args)
 b += 1
x = layers.Conv2D(
 round_filters(1280),
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='top_conv' )(x)
 x = layers.BatchNormalization(axis=bn_axis, name='top_bn' )(x)
 x = layers.Activation(activation, name='top_activation' )(x)
 if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool' )(x)
 if dropout_rate > 0:
x = layers.Dropout(dropout_rate, name='top_dropout' )(x)
 imagenet_utils.validate_activation(classifier_activation, weights)
 x = layers.Dense(
 classes,
activation=classifier_activation,
kernel_initializer=DENSE_KERNEL_INITIALIZER,
name='predictions' )(x)
 else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D(name='avg_pool' )(x)
 elif pooling == 'max':
x = layers.GlobalMaxPooling2D(name='max_pool' )(x)
 if input_tensor is not None:
inputs = layer_utils.get_source_inputs(input_tensor)
 else:
inputs = img_input
model = training.Model(inputs, x, name=model_name)
 if weights == 'imagenet':
if include_top:
file_suffix = '.h5'
file_hash = WEIGHTS_HASHES[model_name[-2:]][0]
else:
file_suffix = '_notop.h5'
file_hash = WEIGHTS_HASHES[model_name[-2:]][1]
file_name = model_name + file_suffix
weights_path = data_utils.get_file(
 file_name,
BASE_WEIGHTS_PATH + file_name,
cache_subdir='models',
file_hash=file_hash)
 model.load_weights(weights_path)
 elif weights is not None:
model.load_weights(weights)
 return model
def block(inputs,
activation='swish',
drop_rate=0.,
name='',
filters_in=32,
filters_out=16,
kernel_size=3,
strides=1,
expand_ratio=1,
se_ratio=0.,
id_skip=True):

 bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
filters = filters_in * expand_ratio
if expand_ratio != 1:
x = layers.Conv2D(
 filters,
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=name + 'expand_conv' )(
 inputs)
 x = layers.BatchNormalization(axis=bn_axis, name=name + 'expand_bn' )(x)
 x = layers.Activation(activation, name=name + 'expand_activation' )(x)
 else:
x = inputs
if strides == 2:
x = layers.ZeroPadding2D(
 padding=imagenet_utils.correct_pad(x, kernel_size),
name=name + 'dwconv_pad' )(x)
 conv_pad = 'valid'
else:
conv_pad = 'same'
x = layers.DepthwiseConv2D(
 kernel_size,
strides=strides,
padding=conv_pad,
use_bias=False,
depthwise_initializer=CONV_KERNEL_INITIALIZER,
name=name + 'dwconv' )(x)
 x = layers.BatchNormalization(axis=bn_axis, name=name + 'bn' )(x)
 x = layers.Activation(activation, name=name + 'activation' )(x)
 if 0 < se_ratio <= 1:
filters_se = max(1, int(filters_in * se_ratio))
se = layers.GlobalAveragePooling2D(name=name + 'se_squeeze' )(x)
 se = layers.Reshape(( 1, 1, filters), name=name + 'se_reshape' )(se)
 se = layers.Conv2D(
 filters_se,
1,
padding='same',
activation=activation,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=name + 'se_reduce' )(
 se)
 se = layers.Conv2D(
 filters,
1,
padding='same',
activation='sigmoid',
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=name + 'se_expand' )(se)
 x = layers.multiply([x, se], name=name + 'se_excite')
 x = layers.Conv2D(
 filters_out,
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=name + 'project_conv' )(x)
 x = layers.BatchNormalization(axis=bn_axis, name=name + 'project_bn' )(x)
 if id_skip and strides == 1 and filters_in == filters_out:
if drop_rate > 0:
x = layers.Dropout(
 drop_rate, noise_shape=(None, 1, 1, 1), name=name + 'drop' )(x)
 x = layers.add([x, inputs], name=name + 'add')
 return x
@keras_export('keras.applications.efficientnet.EfficientNetB0',
'keras.applications.EfficientNetB0')
 def EfficientNetB0(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
return EfficientNet(
 1.0,
1.0,
224,
0.2,
model_name='efficientnetb0',
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
**kwargs)
 @keras_export('keras.applications.efficientnet.EfficientNetB1',
'keras.applications.EfficientNetB1')
 def EfficientNetB1(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
return EfficientNet(
 1.0,
1.1,
240,
0.2,
model_name='efficientnetb1',
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
**kwargs)
 @keras_export('keras.applications.efficientnet.EfficientNetB2',
'keras.applications.EfficientNetB2')
 def EfficientNetB2(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
return EfficientNet(
 1.1,
1.2,
260,
0.3,
model_name='efficientnetb2',
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
**kwargs)
 @keras_export('keras.applications.efficientnet.EfficientNetB3',
'keras.applications.EfficientNetB3')
 def EfficientNetB3(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
return EfficientNet(
 1.2,
1.4,
300,
0.3,
model_name='efficientnetb3',
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
**kwargs)
 @keras_export('keras.applications.efficientnet.EfficientNetB4',
'keras.applications.EfficientNetB4')
 def EfficientNetB4(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
return EfficientNet(
 1.4,
1.8,
380,
0.4,
model_name='efficientnetb4',
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
**kwargs)
 @keras_export('keras.applications.efficientnet.EfficientNetB5',
'keras.applications.EfficientNetB5')
 def EfficientNetB5(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
return EfficientNet(
 1.6,
2.2,
456,
0.4,
model_name='efficientnetb5',
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
**kwargs)
 @keras_export('keras.applications.efficientnet.EfficientNetB6',
'keras.applications.EfficientNetB6')
 def EfficientNetB6(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
return EfficientNet(
 1.8,
2.6,
528,
0.5,
model_name='efficientnetb6',
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
**kwargs)
 @keras_export('keras.applications.efficientnet.EfficientNetB7',
'keras.applications.EfficientNetB7')
 def EfficientNetB7(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
return EfficientNet(
 2.0,
3.1,
600,
0.5,
model_name='efficientnetb7',
include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes,
**kwargs)
 @keras_export('keras.applications.efficientnet.preprocess_input')
 def preprocess_input(x, data_format=None):
return x
@keras_export('keras.applications.efficientnet.decode_predictions')
 def decode_predictions(preds, top=5):

 return imagenet_utils.decode_predictions(preds, top=top )<choose_model_class>
startTime = time.time()
def get_model(weights='imagenet'):
inp = tf.keras.layers.Input(shape=(DIM,DIM,3))
base = EfficientNetB0(input_shape=(DIM,DIM,3),weights=None,include_top=False)
 x = base(inp)
 x = tf.keras.layers.GlobalAveragePooling2D()(x)
 x = tf.keras.layers.Flatten()(x)
 x = tf.keras.layers.Dense(5,activation='softmax' )(x)
 model = tf.keras.Model(inputs=inp, outputs=x)
 opt = tf.keras.optimizers.Adam(learning_rate=0.001)
 loss = tf.keras.losses.CategoricalCrossentropy(
 from_logits=False, label_smoothing=0.0001,
name='categorical_crossentropy' 
)
 model.compile(optimizer=opt,loss=loss,metrics=['categorical_accuracy'])
 return model<split>
classes_path = os.listdir(INPUT_DIR + 'train_simplified/')
 classes_path = sorted(classes_path, key=lambda s: s.lower())
 class_dict = {x[:-4].replace(" ", "_"):i for i, x in enumerate(classes_path)}
labels = {x[:-4].replace(" ", "_")for i, x in enumerate(classes_path)}
n_labels = len(labels)
 print("Number of labels: {}".format(n_labels))
fileList = glob(INPUT_DIR + "train_simplified/*.csv")
 n_files = n_labels
n_records = 49707919
size = 80
print("Number of records: {}".format(n_records))
skf = KFold(n_splits=FOLDS,shuffle=True,random_state=12)
 for fold,(idxT,idxV)in enumerate(skf.split(np.arange(5))):
if fold==(FOLDS-1):
idxTT = idxT; idxVV = idxV
print('
print('Fold',fold,'has TRAIN:',idxT,'VALID:',idxV )<define_variables>
def top_3_accuracy(y_true, y_pred):
return top_k_categorical_accuracy(y_true, y_pred, k=3 )
pred = np.zeros(( test_df.shape[0],5))
for fold,(idxT,idxV)in enumerate(skf.split(np.arange(5))):
print() ; print('
print('
print('
files_train = tf.io.gfile.glob([GCS_PATH_STRATIFICATED + '/train%.2i*.tfrec'%x for x in idxT])
 files_valid = tf.io.gfile.glob([GCS_PATH_STRATIFICATED + '/train%.2i*.tfrec'%x for x in idxV])
 NUM_TRAINING_IMAGES = int(count_data_items(files_train))
NUM_VALIDATION_IMAGES = int(count_data_items(files_valid))
STEPS_PER_EPOCH = NUM_TRAINING_IMAGES // BATCH_SIZE
print('Dataset: {} training images, {} validation images,'.format(NUM_TRAINING_IMAGES, NUM_VALIDATION_IMAGES))
model = get_model()
print('Loading best model...')
 model.load_weights('.. /input/cassavaefnetb0/fold-%i.h5'%fold)
 print('Predicting Test with TTA...')
 tta_steps = TTA
predictions = []
for i in tqdm(range(tta_steps)) :
preds = model.predict_generator(test_generator, verbose=1)
 predictions.append(preds)
 pred += np.mean(predictions, axis=0)/FOLDS
del model; z = gc.collect()<create_dataframe>
STEPS = 1000
batchsize = 512
epochs = 15
ds = get_dataset(files_test, augment=False, repeat=False, dim=IMAGE_SIZE[0],
labeled=False, return_image_names=True)
 image_names = np.array([img_name.numpy().decode("utf-8")
 for img, img_name in iter(ds.unbatch())] )<save_to_csv>
valid_df = pd.read_csv(os.path.join(DP_DIR, 'train_k{}.csv.gz'.format(NCSVS - 1)) , nrows=30000)
 x_valid = df_to_image_array(valid_df, size)
 y_valid = tf.keras.utils.to_categorical(valid_df.y, num_classes=NCATS)
 print(x_valid.shape, y_valid.shape)
 print('Validation array memory {:.2f} GB'.format(x_valid.nbytes / 1024.**3))
prediction = np.argmax(pred, axis=1)
 test_df['label'] = prediction
test_df = test_df[["image_id","label"]]
test_df.to_csv('submission.csv',index=False)
 test_df<import_modules>
train_datagen = image_generator(size=size, batchsize=batchsize, ks=range(NCSVS - 1))
import numpy as np
import pandas as pd<import_modules>
base_model = MobileNet(input_shape=(size, size, 1), include_top=False, weights=None, classes=n_labels)
 x = base_model.output
x = Flatten()(x)
 x = Dense(1024, activation='relu' )(x)
 predictions = Dense(n_labels, activation='softmax' )(x)
 model = Model(inputs=base_model.input, outputs=predictions )
print(tf.__version__ )<set_options>
model.compile(optimizer=Adam(lr=1e-4), loss='categorical_crossentropy',
metrics=[categorical_crossentropy, categorical_accuracy, top_3_accuracy] )
try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print('Running on TPU ', tpu.master())
 except ValueError:
tpu = None
if tpu:
tf.config.experimental_connect_to_cluster(tpu)
 tf.tpu.experimental.initialize_tpu_system(tpu)
 strategy = tf.distribute.experimental.TPUStrategy(tpu)
 else:
strategy = tf.distribute.get_strategy()
print("REPLICAS: ", strategy.num_replicas_in_sync )<define_variables>
callbacks = [
ReduceLROnPlateau(monitor='val_categorical_accuracy', factor=0.5, patience=5,
min_delta=0.005, mode='max', cooldown=3, verbose=1)
 ]
hist = model.fit_generator(
 train_datagen, steps_per_epoch=STEPS, epochs=epochs, verbose=1,
validation_data=(x_valid, y_valid),
callbacks = callbacks
)
EPOCHS = 75
DROP_RATE = 0.4
BATCH_SIZE = 16 * strategy.num_replicas_in_sync
RESIZE_SIZE =(224, 224)
 TTA_COUNT = 10
MODEL_VERSION = 'V17'<load_from_csv>
pred_results = []
chunksize = 10000
reader = pd.read_csv(INPUT_DIR + 'test_simplified.csv', chunksize=chunksize)
 for chunk in tqdm(reader):
imgs = df_to_image_array(chunk)
 pred = model.predict(imgs, verbose=1)
 top_3 = np.argsort(-pred)[:, 0:3]
pred_results.append(top_3)
 print("Finished test predictions...")
DATA_DIR = '.. /input/digit-recognizer/'
def read_df(file_name):
file_path = DATA_DIR + file_name
data_df = pd.read_csv(file_path)
 return data_df<load_from_csv>
reverse_dict = {v: k for k, v in class_dict.items() }
pred_results = np.concatenate(pred_results)
 print("Finished data prep...")
<categorify><EOS> 
preds_df = pd.DataFrame({'first': pred_results[:,0], 'second': pred_results[:,1], 'third': pred_results[:,2]})
 preds_df = preds_df.replace(reverse_dict)
 preds_df['words'] = preds_df['first'] + " " + preds_df['second'] + " " + preds_df['third']
sub = pd.read_csv(INPUT_DIR + 'sample_submission.csv', index_col=['key_id'])
 sub['word'] = preds_df.words.values
sub.to_csv('1class_per_label_proto.csv')
 sub.head()