Kaggle competition: Petals to the Metal - Flower Classification on TPU
<SOS> metric: macrofscore Kaggle data source: petals-to-the-metal-flower-classification-on-tpu<count_values>
!pip install -q efficientnet
hasCabin =(train["Cabin"].notnull().astype('int'))
sns.set_style('whitegrid')
 sns.countplot(x='Survived', hue=hasCabin, data=train)
 print("Percentage by has Cabin: ", train["Survived"][hasCabin == 1].value_counts(normalize=True)[1] * 100)
 print("Percentage of hasn't Cabin: ", train["Survived"][hasCabin == 0].value_counts(normalize=True)[1] * 100 )<data_type_conversions>
%matplotlib inline
print("Tensorflow version " + tf.__version__ )
train["Age"].fillna(train["Age"].median() , inplace = True)
 test["Age"].fillna(test["Age"].median() , inplace = True)
 train["Fare"].fillna(train["Fare"].median() , inplace = True)
 test["Fare"].fillna(test["Fare"].median() , inplace = True)
 train["Embarked"].fillna(( train["Embarked"].append(test["Embarked"])).mode() , inplace = True)
 test["Embarked"].fillna(( train["Embarked"].append(test["Embarked"])).mode() , inplace = True)
 drop_column = ["PassengerId","Cabin", "Ticket"]
train.drop(drop_column, axis=1, inplace = True)
 print(train.isnull().sum())
 print("-"*10)
 print(test.isnull().sum() )<feature_engineering>
GCS_DS_PATH = KaggleDatasets().get_gcs_path("tpu-getting-started" )
train["FamilySize"] = train["SibSp"] + train["Parch"] + 1
test["FamilySize"] = test["SibSp"] + test["Parch"] + 1
train["IsAlone"] = 1
test["IsAlone"] = 1
train["IsAlone"].loc[train["FamilySize"] > 1] = 0
test["IsAlone"].loc[test["FamilySize"] > 1] = 0
train["Title"] = train["Name"].str.split(",", expand = True)[1].str.split(".", expand = True)[0]
test["Title"] = test["Name"].str.split(",", expand = True)[1].str.split(".", expand = True)[0]
train["FareBin"] = pd.qcut(train["Fare"], 4)
 test["FareBin"] = pd.qcut(test["Fare"], 4)
 train["AgeBin"] = pd.cut(train["Age"].astype(int), 5)
 test["AgeBin"] = pd.cut(test["Age"].astype(int), 5 )<feature_engineering>
IMAGE_SIZE = [512, 512]
BATCH_SIZE = 16 * strategy.num_replicas_in_sync
GCS_PATH_SELECT = {
192: GCS_DS_PATH + '/tfrecords-jpeg-192x192',
224: GCS_DS_PATH + '/tfrecords-jpeg-224x224',
331: GCS_DS_PATH + '/tfrecords-jpeg-331x331',
512: GCS_DS_PATH + '/tfrecords-jpeg-512x512'
}
GCS_PATH = GCS_PATH_SELECT[IMAGE_SIZE[0]]
VALIDATION_FILENAMES = tf.io.gfile.glob(GCS_PATH + '/val/*.tfrec')
 TEST_FILENAMES = tf.io.gfile.glob(GCS_PATH + '/test/*.tfrec')
 SEED = 2020
stat_min = 10
title_names =(train["Title"].value_counts() < stat_min)
 title_names_t =(test["Title"].value_counts() < stat_min)
 train["Title"] = train["Title"].apply(lambda x: "Misc" if title_names.loc[x] == True else x)
 test["Title"] = test["Title"].apply(lambda x: "Misc" if title_names_t.loc[x] == True else x)
 print(train["Title"].value_counts())
 print("-"*10)
 train.info()
test.info()
train.sample(10 )<categorify>
def decode_image(image_data):

 image = tf.image.decode_jpeg(image_data, channels=3)
 image = tf.cast(image, tf.float32)/ 255.0
image = tf.reshape(image, [*IMAGE_SIZE, 3])
 return image
def read_labeled_tfrecord(example):
LABELED_TFREC_FORMAT = {
"image": tf.io.FixedLenFeature([], tf.string),
"class": tf.io.FixedLenFeature([], tf.int64),
}
example = tf.io.parse_single_example(example, LABELED_TFREC_FORMAT)
 image = decode_image(example['image'])
 label = tf.cast(example['class'], tf.int32)
 return image, label
def read_unlabeled_tfrecord(example):
UNLABELED_TFREC_FORMAT = {
"image": tf.io.FixedLenFeature([], tf.string),
"id": tf.io.FixedLenFeature([], tf.string),
}
example = tf.io.parse_single_example(example, UNLABELED_TFREC_FORMAT)
 image = decode_image(example['image'])
 idnum = example['id']
return image, idnum
def load_dataset(filenames, labeled=True, ordered=False):

 ignore_order = tf.data.Options()
if not ordered:
ignore_order.experimental_deterministic = False
dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTO)
 dataset = dataset.with_options(ignore_order)
 dataset = dataset.map(read_labeled_tfrecord if labeled else read_unlabeled_tfrecord, num_parallel_calls=AUTO)
 return dataset
def get_validation_dataset() :
dataset = load_dataset(VALIDATION_FILENAMES, labeled=True, ordered=True)
 dataset = dataset.batch(BATCH_SIZE)
 dataset = dataset.cache()
dataset = dataset.prefetch(AUTO)
 return dataset
def get_test_dataset(ordered=False):
dataset = load_dataset(TEST_FILENAMES, labeled=False, ordered=ordered)
 dataset = dataset.batch(BATCH_SIZE)
 dataset = dataset.prefetch(AUTO)
 return dataset
def count_data_items(filenames):
n = [int(re.compile(r"-([0-9]*)\." ).search(filename ).group(1)) for filename in filenames]
return np.sum(n)
 NUM_VALIDATION_IMAGES = count_data_items(VALIDATION_FILENAMES)
 NUM_TEST_IMAGES = count_data_items(TEST_FILENAMES)
 print('Dataset: {} validation images, {} unlabeled test images'.format(NUM_VALIDATION_IMAGES, NUM_TEST_IMAGES))
label = preprocessing.LabelEncoder()
train["Sex_Code"] = label.fit_transform(train["Sex"])
 test["Sex_Code"] = label.fit_transform(test["Sex"])
 train["Embarked_Code"] = label.fit_transform(train["Embarked"].astype(str))
test["Embarked_Code"] = label.fit_transform(test["Embarked"].astype(str))
train["Title_Code"] = label.fit_transform(train["Title"])
 test["Title_Code"] = label.fit_transform(test["Title"])
 train["AgeBin_Code"] = label.fit_transform(train["AgeBin"])
 test["AgeBin_Code"] = label.fit_transform(test["AgeBin"])
 train["FareBin_Code"] = label.fit_transform(train["FareBin"])
 test["FareBin_Code"] = label.fit_transform(test["FareBin"] )<define_variables>
def get_model(use_model):
base_model = use_model(weights='imagenet',
include_top=False, pooling='avg',
input_shape=(*IMAGE_SIZE, 3))
x = base_model.output
predictions = Dense(104, activation='softmax' )(x)
 model = Model(inputs=base_model.input, outputs=predictions)
 model.compile(
 optimizer='nadam',
loss = 'sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'] 
)
 return model
with strategy.scope() :
model1 = get_model(DenseNet201)
 model1.load_weights("/kaggle/input/start-with-densenet201/my_densenet_201.h5" )
Target = ["Survived"]
train_x = ["Sex", "Pclass", "Embarked", "Title", "SibSp", "Parch", "Age", "Fare", "FamilySize", "IsAlone"]
train_x_calc = ["Sex_Code", "Pclass", "Embarked_Code", "Title_Code", "SibSp", "Parch", "Age", "Fare"]
train_x_bin = ["Sex_Code", "Pclass", "Embarked_Code", "Title_Code", "FamilySize", "AgeBin_Code", "FareBin_Code"]<categorify>
def get_model(use_model):
base_model = use_model(weights='noisy-student',
include_top=False, pooling='avg',
input_shape=(*IMAGE_SIZE, 3))
x = base_model.output
predictions = Dense(104, activation='softmax' )(x)
 model = Model(inputs=base_model.input, outputs=predictions)
 model.compile(
 optimizer='nadam',
loss = 'sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'] 
)
 return model
with strategy.scope() :
model2 = get_model(EfficientNetB7)
 model2.load_weights("/kaggle/input/start-with-pre-train/my_ef_net_b7.h5" )
train_dummy = pd.get_dummies(train[train_x])
 train_x_dummy = train_dummy.columns.tolist()
train_xy_dummy = Target + train_x_dummy
print("Dummy X Y: ", train_xy_dummy, '
')
 train_dummy.head()<categorify>
val_dataset = get_validation_dataset()
images_ds = val_dataset.map(lambda image, label: image)
 labels_ds = val_dataset.map(lambda image, label: label ).unbatch()
val_labels = next(iter(labels_ds.batch(NUM_VALIDATION_IMAGES)) ).numpy()
m1 = model1.predict(images_ds)
 m2 = model2.predict(images_ds)
 scores = []
for alpha in np.linspace(0,1,100):
val_probabilities = alpha*m1+(1-alpha)*m2
val_predictions = np.argmax(val_probabilities, axis=-1)
 scores.append(f1_score(val_labels, val_predictions, labels=range(104), average='macro'))
best_alpha = np.argmax(scores)/100
print('Best alpha: ' + str(best_alpha))
test_dummy = pd.get_dummies(test[train_x])
 test_x_dummy = train_dummy.columns.tolist()
test_xy_dummy = Target + test_x_dummy
print("Dummy X Y: ", test_xy_dummy, '
')
 test_dummy.head()<split>
test_ds = get_test_dataset(ordered=True)
 print('Вычисляем предсказания...')
 test_images_ds = test_ds.map(lambda image, idnum: image)
 probabilities1 = model1.predict(test_images_ds)
 probabilities2 = model2.predict(test_images_ds)
 probabilities = best_alpha * probabilities1 +(1 - best_alpha)* probabilities2
predictions = np.argmax(probabilities, axis=-1)
 print(predictions)
 print('Создание файла submission.csv...')
 test_ids_ds = test_ds.map(lambda image, idnum: idnum ).unbatch()
test_ids = next(iter(test_ids_ds.batch(NUM_TEST_IMAGES)) ).numpy().astype('U')
 np.savetxt('submission.csv', np.rec.fromarrays([test_ids, predictions]), fmt=['%s', '%d'], delimiter=',', header='id,label', comments='' )