Kaggle competition: Petals to the Metal - Flower Classification on TPU
<SOS> metric: macrofscore Kaggle data source: petals-to-the-metal-flower-classification-on-tpu<compute_train_metric>
tf.data.experimental.AUTOTUNE
print("TF version " + tf.__version__)
 AUTO = tf.data.experimental.AUTOTUNE
m4, feats4, trainm4, testm4 = Auto_ViML(train_nlp, target, test_nlp,
sample_submission=subm,
scoring_parameter='balanced-accuracy',
hyper_param='GS',feature_reduction=True,
Boosting_Flag="CatBoost",Binning_Flag=False,
Add_Poly=0, Stacking_Flag=False,Imbalanced_Flag=False,
verbose=2 )<data_type_conversions>
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 )
subm[target] = testm4['Survived_CatBoost_predictions'].values.astype(int)
 subm.head()<save_to_csv>
IMAGE_SIZE = [512, 512]
EPOCHS = 8
BATCH_SIZE = 16 * strategy.num_replicas_in_sync
SEED = 752
SKIP_VALIDATION = False
TTA_NUM = 5
random.seed(SEED)
 np.random.seed(SEED)
 tf.random.set_seed(SEED )
subm.to_csv('sample_submission4.csv',index=False )<compute_train_metric>
np.set_printoptions(threshold=15, linewidth=80)
 def batch_to_numpy_images_and_labels(data):
images, labels = data
numpy_images = images.numpy()
numpy_labels = labels.numpy()
if numpy_labels.dtype == object:
numpy_labels = [None for _ in enumerate(numpy_images)]
return numpy_images, numpy_labels
def title_from_label_and_target(label, correct_label):
if correct_label is None:
return CLASSES[label], True
correct =(label == correct_label)
 return "{} [{}{}{}]".format(CLASSES[label], 'OK' if correct else 'NO', u"\u2192" if not correct else '',
CLASSES[correct_label] if not correct else ''), correct
def display_one_flower(image, title, subplot, red=False, titlesize=16):
plt.subplot(*subplot)
 plt.axis('off')
 plt.imshow(image)
 if len(title)> 0:
plt.title(title, fontsize=int(titlesize)if not red else int(titlesize/1.2), color='red' if red else 'black', fontdict={'verticalalignment':'center'}, pad=int(titlesize/1.5))
return(subplot[0], subplot[1], subplot[2]+1)
 def display_batch_of_images(databatch, predictions=None):

 images, labels = batch_to_numpy_images_and_labels(databatch)
 if labels is None:
labels = [None for _ in enumerate(images)]
rows = int(math.sqrt(len(images)))
 cols = len(images)//rows
FIGSIZE = 13.0
SPACING = 0.1
subplot=(rows,cols,1)
 if rows < cols:
plt.figure(figsize=(FIGSIZE,FIGSIZE/cols*rows))
else:
plt.figure(figsize=(FIGSIZE/rows*cols,FIGSIZE))
for i,(image, label)in enumerate(zip(images[:rows*cols], labels[:rows*cols])) :
title = '' if label is None else CLASSES[label]
correct = True
if predictions is not None:
title, correct = title_from_label_and_target(predictions[i], label)
 dynamic_titlesize = FIGSIZE*SPACING/max(rows,cols)*40+3
subplot = display_one_flower(image, title, subplot, not correct, titlesize=dynamic_titlesize)
 plt.tight_layout()
if label is None and predictions is None:
plt.subplots_adjust(wspace=0, hspace=0)
 else:
plt.subplots_adjust(wspace=SPACING, hspace=SPACING)
 plt.show()
def display_confusion_matrix(cmat, score, precision, recall):
plt.figure(figsize=(15,15))
ax = plt.gca()
ax.matshow(cmat, cmap='Reds')
 ax.set_xticks(range(len(CLASSES)))
 ax.set_xticklabels(CLASSES, fontdict={'fontsize': 7})
 plt.setp(ax.get_xticklabels() , rotation=45, ha="left", rotation_mode="anchor")
 ax.set_yticks(range(len(CLASSES)))
 ax.set_yticklabels(CLASSES, fontdict={'fontsize': 7})
 plt.setp(ax.get_yticklabels() , rotation=45, ha="right", rotation_mode="anchor")
 titlestring = ""
if score is not None:
titlestring += 'f1 = {:.3f} '.format(score)
 if precision is not None:
titlestring += '
precision = {:.3f} '.format(precision)
 if recall is not None:
titlestring += '
recall = {:.3f} '.format(recall)
 if len(titlestring)> 0:
ax.text(101, 1, titlestring, fontdict={'fontsize': 18, 'horizontalalignment':'right', 'verticalalignment':'top', 'color':'
plt.show()
def display_training_curves(training, validation, title, subplot):
if subplot%10==1:
plt.subplots(figsize=(10,10), facecolor='
plt.tight_layout()
ax = plt.subplot(subplot)
 ax.set_facecolor('
ax.plot(training)
 ax.plot(validation)
 ax.set_title('model '+ title)
 ax.set_ylabel(title)
 ax.set_xlabel('epoch')
 ax.legend(['train', 'valid.'] )
m2, feats2, trainm2, testm2 = Auto_ViML(train_nlp, target, test_nlp,
sample_submission=subm,
scoring_parameter='balanced-accuracy',
hyper_param='GS',feature_reduction=True,
Boosting_Flag=None,Binning_Flag=False,
Add_Poly=0, Stacking_Flag=False,
Imbalanced_Flag=False,
verbose=2 )<data_type_conversions>
def random_blockout(img, sl=0.1, sh=0.2, rl=0.4):
p=random.random()
if p>=0.25:
w, h, c = IMAGE_SIZE[0], IMAGE_SIZE[1], 3
origin_area = tf.cast(h*w, tf.float32)
 e_size_l = tf.cast(tf.round(tf.sqrt(origin_area * sl * rl)) , tf.int32)
 e_size_h = tf.cast(tf.round(tf.sqrt(origin_area * sh / rl)) , tf.int32)
 e_height_h = tf.minimum(e_size_h, h)
 e_width_h = tf.minimum(e_size_h, w)
 erase_height = tf.random.uniform(shape=[], minval=e_size_l, maxval=e_height_h, dtype=tf.int32)
 erase_width = tf.random.uniform(shape=[], minval=e_size_l, maxval=e_width_h, dtype=tf.int32)
 erase_area = tf.zeros(shape=[erase_height, erase_width, c])
 erase_area = tf.cast(erase_area, tf.uint8)
 pad_h = h - erase_height
pad_top = tf.random.uniform(shape=[], minval=0, maxval=pad_h, dtype=tf.int32)
 pad_bottom = pad_h - pad_top
pad_w = w - erase_width
pad_left = tf.random.uniform(shape=[], minval=0, maxval=pad_w, dtype=tf.int32)
 pad_right = pad_w - pad_left
erase_mask = tf.pad([erase_area], [[0,0],[pad_top, pad_bottom], [pad_left, pad_right], [0,0]], constant_values=1)
 erase_mask = tf.squeeze(erase_mask, axis=0)
 erased_img = tf.multiply(tf.cast(img,tf.float32), tf.cast(erase_mask, tf.float32))
return tf.cast(erased_img, img.dtype)
 else:
return tf.cast(img, img.dtype )
subm[target] =(testm2['Survived_proba_1']>0.5 ).astype(int ).values
subm.head()<save_to_csv>
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 data_augment(image, label):
image = tf.image.random_flip_left_right(image, seed=SEED)
 image = random_blockout(image)
 return image, label
def get_training_dataset() :
dataset = load_dataset(TRAINING_FILENAMES, labeled=True)
 dataset = dataset.map(data_augment, num_parallel_calls=AUTO)
 dataset = dataset.repeat()
dataset = dataset.shuffle(2048)
 dataset = dataset.batch(BATCH_SIZE)
 dataset = dataset.prefetch(AUTO)
 return dataset
def get_validation_dataset(ordered=False):
dataset = load_dataset(VALIDATION_FILENAMES, labeled=True, ordered=ordered)
 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_TRAINING_IMAGES = count_data_items(TRAINING_FILENAMES)
 NUM_VALIDATION_IMAGES = count_data_items(VALIDATION_FILENAMES)
 NUM_TEST_IMAGES = count_data_items(TEST_FILENAMES)
 STEPS_PER_EPOCH = NUM_TRAINING_IMAGES // BATCH_SIZE
print('Dataset: {} training images, {} validation images, {} unlabeled test images'.format(NUM_TRAINING_IMAGES, NUM_VALIDATION_IMAGES, NUM_TEST_IMAGES))
subm.to_csv('sample_submission2.csv',index=False )<compute_train_metric>
if SKIP_VALIDATION:
TRAINING_FILENAMES = TRAINING_FILENAMES + VALIDATION_FILENAMES
m3, feats3, trainm3, testm3 = Auto_ViML(train_nlp, target, test_nlp,
sample_submission=subm,
scoring_parameter='balanced-accuracy',
hyper_param='RS',feature_reduction=True,
Boosting_Flag=True,Binning_Flag=False,
Add_Poly=0, Stacking_Flag=False,
Imbalanced_Flag=False,
verbose=2 )<data_type_conversions>
training_dataset = get_training_dataset()
validation_dataset = get_validation_dataset()
training_dataset,validation_dataset
subm[target] =(testm3['Survived_proba_1']>0.5 ).astype(int ).values
subm.head()<save_to_csv>
print("Number of classes: {}".format(len(CLASSES)))
 print("First five classes, sorted alphabetically:")
 for name in sorted(CLASSES)[:5]:
print(name)
 print("Number of training images: {}".format(NUM_TRAINING_IMAGES))
subm.to_csv('sample_submission3.csv',index=False )<set_options>
print("Training data shapes:")
 for image, label in get_training_dataset().take(1):
print(image.numpy().shape, label.numpy().shape)
 print("Training data label examples:", label.numpy())
 print("Validation data shapes:")
 for image, label in get_validation_dataset().take(1):
print(image.numpy().shape, label.numpy().shape)
 print("Validation data label examples:", label.numpy())
 print("Test data shapes:")
 for image, idnum in get_test_dataset().take(1):
print(image.numpy().shape, idnum.numpy().shape)
 print("Test data IDs:", idnum.numpy().astype('U'))
warnings.filterwarnings('ignore' )<load_from_csv>
training_dataset = get_training_dataset()
training_dataset = training_dataset.unbatch().batch(20)
 train_batch = iter(training_dataset )
df = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv',index_col='Id')
 df_val = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv',index_col='Id')
 y=np.log1p(df.SalePrice)
 df=df.drop(['SalePrice'],axis=1)
 print('shape of df:', df.shape)
 print('shape of df_val:', df_val.shape )<filter>
display_batch_of_images(next(train_batch))
def remove_nanish(nan_thresh,df,df_val):
X=df
mask1=X.isnull().sum() /len(X)<nan_thresh
mask2=df_val.isnull().sum() /len(df_val)<nan_thresh
keeps=X.columns[mask1 & mask2]
X=X[keeps]
X_valid=df_val[keeps]
return X, X_valid<rename_columns>
test_dataset = get_test_dataset()
test_dataset = test_dataset.unbatch().batch(20)
 test_batch = iter(test_dataset )
def impute_nums(num_X_train,num_X_test,num_X_valid):
SI=SimpleImputer(strategy='mean')
 num_X_train = pd.DataFrame(SI.fit_transform(num_X_train),index=num_X_train.index, columns=num_X_train.columns)
 num_X_test = pd.DataFrame(SI.transform(num_X_test),index=num_X_test.index, columns=num_X_test.columns)
 num_X_valid = pd.DataFrame(SI.transform(num_X_valid),index=num_X_valid.index, columns=num_X_valid.columns)
 return num_X_train, num_X_test, num_X_valid<normalization>
display_batch_of_images(next(test_batch))
def scale(num_X_train,num_X_test,num_X_valid):
SS=StandardScaler()
num_X_train = pd.DataFrame(SS.fit_transform(num_X_train),index=num_X_train.index, columns=num_X_train.columns)
 num_X_test = pd.DataFrame(SS.transform(num_X_test),index=num_X_test.index, columns=num_X_test.columns)
 num_X_valid = pd.DataFrame(SS.transform(num_X_valid),index=num_X_valid.index, columns=num_X_valid.columns)
 return num_X_train, num_X_test, num_X_valid<categorify>
LR_START = 0.00001
LR_MAX = 0.00006 * strategy.num_replicas_in_sync
LR_MIN = 0.00001
LR_RAMPUP_EPOCHS = 5
LR_SUSTAIN_EPOCHS = 0
LR_EXP_DECAY =.8
def lrfn(epoch):
if epoch < LR_RAMPUP_EPOCHS:
lr =(LR_MAX - LR_START)/ LR_RAMPUP_EPOCHS * epoch + LR_START
elif epoch < LR_RAMPUP_EPOCHS + LR_SUSTAIN_EPOCHS:
lr = LR_MAX
else:
lr =(LR_MAX - LR_MIN)* LR_EXP_DECAY**(epoch - LR_RAMPUP_EPOCHS - LR_SUSTAIN_EPOCHS)+ LR_MIN
return lr
lr_callback = tf.keras.callbacks.LearningRateScheduler(lrfn, verbose = True)
 rng = [i for i in range(25 if EPOCHS<25 else EPOCHS)]
y = [lrfn(x)for x in rng]
plt.plot(rng, y)
 print("Learning rate schedule: {:.3g} to {:.3g} to {:.3g}".format(y[0], max(y), y[-1]))
def impute_encode(cat_X_train,cat_X_test,cat_X_valid):
im=SimpleImputer(strategy='most_frequent')
 cat_X_train = pd.DataFrame(im.fit_transform(cat_X_train),index=cat_X_train.index, columns=cat_X_train.columns)
 cat_X_test = pd.DataFrame(im.transform(cat_X_test),index=cat_X_test.index, columns=cat_X_test.columns)
 cat_X_valid = pd.DataFrame(im.transform(cat_X_valid),index=cat_X_valid.index, columns=cat_X_valid.columns)
 OH = OneHotEncoder(handle_unknown='ignore',sparse=False)
 cat_X_train = pd.DataFrame(OH.fit_transform(cat_X_train),index=cat_X_train.index)
 cat_X_test = pd.DataFrame(OH.transform(cat_X_test),index=cat_X_test.index)
 cat_X_valid = pd.DataFrame(OH.transform(cat_X_valid),index=cat_X_valid.index)
 return cat_X_train, cat_X_test, cat_X_valid<categorify>
!pip install -q efficientnet
def preprocess(X,df_val):
nan_thresh=0.0450
skew_thresh=40
target_corr=0.01
X, X_valid=remove_nanish(nan_thresh,df,df_val)
 categorical_cols = [cname for cname in X.columns if X[cname].dtype == "object" ]
numerical_cols = [cname for cname in X.columns if X[cname].dtype in ['int64', 'float64']]
cols=categorical_cols+numerical_cols
X = X[cols]
X_valid= X_valid[cols]
X_train, X_test, y_train, y_test =train_test_split(X,y,test_size=0.2)
 num_X_train = X_train.drop(categorical_cols, axis=1)
 num_X_test = X_test.drop(categorical_cols, axis=1)
 num_X_valid = X_valid.drop(categorical_cols, axis=1)
 num_X_train, num_X_test, num_X_valid= impute_nums(num_X_train, num_X_test, num_X_valid)
 skewed=[col for col in num_X_train.columns if abs(num_X_train[col].skew(axis=0)) >skew_thresh]
for col in skewed:
num_X_train[col]=np.log1p(num_X_train[col])
 num_X_test[col]=np.log1p(num_X_test[col])
 num_X_valid[col]=np.log1p(num_X_valid[col])
 num_X_train, num_X_test, num_X_valid= scale(num_X_train, num_X_test, num_X_valid)
 for col in numerical_cols:
if abs(y.corr(num_X_train[col])) < target_corr:
num_X_train.drop([col],axis='columns',inplace=True)
 num_X_test.drop([col],axis='columns',inplace=True)
 num_X_valid.drop([col],axis='columns',inplace=True)
 numerical_cols = [cname for cname in num_X_train.columns if num_X_train[cname].dtype in ['int64', 'float64']]
cat_X_train = X_train[categorical_cols]
cat_X_test = X_test[categorical_cols]
cat_X_valid = X_valid[categorical_cols]
cat_X_train,cat_X_test,cat_X_valid = impute_encode(cat_X_train,cat_X_test,cat_X_valid)
 X_train = pd.concat([num_X_train, cat_X_train], axis=1,join='inner')
 X_test = pd.concat([num_X_test, cat_X_test ], axis=1,join='inner')
 X_valid = pd.concat([num_X_valid, cat_X_valid ], axis=1,join='inner')
 return X_train, X_test, X_valid, y_train, y_test, numerical_cols<split>
with strategy.scope() :
enet = efn.EfficientNetB7(input_shape=[*IMAGE_SIZE, 3], weights='imagenet', include_top=False)
 enet.trainable = True
model1 = tf.keras.Sequential([
enet,
tf.keras.layers.GlobalAveragePooling2D() ,
tf.keras.layers.Dense(len(CLASSES), activation='softmax')
 ])
 model1.compile(
 optimizer=tf.keras.optimizers.Adam() ,
loss = 'sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'] 
)
 model1.summary()
X_train, X_test, X_valid, y_train, y_test, numerical_cols = preprocess(df,df_val )<compute_train_metric>
weight_path_save1 = 'Effnet_best_model.hdf5'
checkpoint = ModelCheckpoint(weight_path_save1,
monitor= 'val_loss',
verbose=1,
save_best_only=True,
mode= 'min',
save_weights_only = False,
period = 1)
 early = EarlyStopping(monitor= 'val_loss',
mode= 'min',
patience=2)
 callbacks_list = [checkpoint, early, lr_callback]
best_lasso=Lasso(alpha=0.00045)
 best_lasso.fit(X_train,y_train)
 test_preds=best_lasso.predict(X_test)
 test_rmse=np.sqrt(mean_squared_error(y_test,test_preds))
train_preds=best_lasso.predict(X_train)
 train_rmse=np.sqrt(mean_squared_error(y_train,train_preds))
print(f'train error {train_rmse}')
 print(f'test error {test_rmse}' )<save_to_csv>
if not SKIP_VALIDATION:
history1 = model1.fit(get_training_dataset() ,
steps_per_epoch=STEPS_PER_EPOCH,
epochs=EPOCHS,
validation_data=get_validation_dataset() ,
callbacks = callbacks_list)
 else:
history1 = model1.fit(get_training_dataset() ,
steps_per_epoch=STEPS_PER_EPOCH,
epochs=EPOCHS,
callbacks = callbacks_list )
valid_preds=np.expm1(pd.Series(best_lasso.predict(X_valid),index=X_valid.index))
example=pd.read_csv('.. /input/house-prices-advanced-regression-techniques/sample_submission.csv',index_col='Id')
 example['SalePrice']=valid_preds
example.to_csv('submission.csv',index='Id' )<import_modules>
with strategy.scope() :
densenet = tf.keras.applications.DenseNet201(input_shape=[*IMAGE_SIZE, 3], weights='imagenet', include_top=False)
 densenet.trainable = True
model2 = tf.keras.Sequential([
densenet,
tf.keras.layers.GlobalAveragePooling2D() ,
tf.keras.layers.Dense(len(CLASSES), activation='softmax')
 ])
 model2.compile(
 optimizer=tf.keras.optimizers.Adam() ,
loss = 'sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'] 
)
 model2.summary()
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, AdaBoostClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from lightgbm import LGBMClassifier
from xgboost import XGBClassifier
from tpot import TPOTClassifier<load_from_csv>
weight_path_save2 = 'Dense_best_model.hdf5'
checkpoint = ModelCheckpoint(weight_path_save2,
monitor= 'val_loss',
verbose=1,
save_best_only=True,
mode= 'min',
save_weights_only = False)
 early = EarlyStopping(monitor= 'val_loss',
mode= 'min',
patience=2)
 callbacks_list = [checkpoint, early, lr_callback]
train_df = pd.read_csv('.. /input/titanic/train.csv')
 test_df = pd.read_csv('.. /input/titanic/test.csv')
 print('train_df.shape:', train_df.shape)
 print('test_df.shape:', test_df.shape )<create_dataframe>
if not SKIP_VALIDATION:
history2 = model2.fit(get_training_dataset() ,
steps_per_epoch=STEPS_PER_EPOCH,
epochs=EPOCHS,
validation_data=get_validation_dataset() ,
callbacks = callbacks_list)
 else:
history2 = model2.fit(get_training_dataset() ,
steps_per_epoch=STEPS_PER_EPOCH,
epochs=EPOCHS,
callbacks = [lr_callback] )
train_test_data = [train_df, test_df]<data_type_conversions>
model1.load_weights(weight_path_save1)
 model2.load_weights(weight_path_save2 )
print(train_df.columns.to_list())
 print(test_df.columns.to_list() )<count_missing_values>
if not SKIP_VALIDATION:
cmdataset = get_validation_dataset(ordered=True)
 images_ds = cmdataset.map(lambda image, label: image)
 labels_ds = cmdataset.map(lambda image, label: label ).unbatch()
cm_correct_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):
cm_probabilities = alpha*m1+(1-alpha)*m2
cm_predictions = np.argmax(cm_probabilities, axis=-1)
 scores.append(f1_score(cm_correct_labels, cm_predictions, labels=range(len(CLASSES)) , average='macro'))
best_alpha = np.argmax(scores)/100
else:
best_alpha = 0.51
print('Best alpha: ' + str(best_alpha))
train_null_s = train_df.isnull().sum()
print(train_null_s[train_null_s != 0])
 print('-'*80)
 test_null_s = test_df.isnull().sum()
print(test_null_s[test_null_s != 0] )<define_variables>
if not SKIP_VALIDATION:
cmat = confusion_matrix(cm_correct_labels, cm_predictions, labels=range(len(CLASSES)))
 score = f1_score(cm_correct_labels, cm_predictions, labels=range(len(CLASSES)) , average='macro')
 precision = precision_score(cm_correct_labels, cm_predictions, labels=range(len(CLASSES)) , average='macro')
 recall = recall_score(cm_correct_labels, cm_predictions, labels=range(len(CLASSES)) , average='macro')
 display_confusion_matrix(cmat, score, precision, recall)
 print('f1 score: {:.3f}, precision: {:.3f}, recall: {:.3f}'.format(score, precision, recall))
outlier_detection_field = ['Age', 'Fare']
weight = 2
outlier_indices = []
for col in outlier_detection_field:
q1 = np.nanpercentile(train_df[col], 25)
 q3 = np.nanpercentile(train_df[col], 75)
 iqr = q3-q1
iqr_weight = iqr * weight
lowest_val = q1 - iqr_weight
highest_val = q3 + iqr_weight
outlier_index = train_df[(train_df[col]<lowest_val)|(highest_val<train_df[col])].index
outlier_indices.extend(outlier_index)
 print('{}: {} / {}(record size:{})'.format(col, lowest_val, highest_val, outlier_index.shape[0]))<drop_column>
def predict_tta(model, n_iter):
probs = []
for i in range(n_iter):
test_ds = get_test_dataset(ordered=True)
 test_images_ds = test_ds.map(lambda image, idnum: image)
 probs.append(model.predict(test_images_ds,verbose=0))
return probs
<drop_column><EOS> 
test_ds = get_test_dataset(ordered=True)
 print('Calculating predictions...')
 test_images_ds = test_ds.map(lambda image, idnum: image)
 probs1 = np.mean(predict_tta(model1, TTA_NUM), axis=0)
 probs2 = np.mean(predict_tta(model2, TTA_NUM), axis=0)
 probabilities = best_alpha*probs1 +(1-best_alpha)*probs2
predictions = np.argmax(probabilities, axis=-1)
 print('Generating submission file...')
 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='' )