inference.py

import os
import numpy as np
import scipy as sp
# from tensorflow.contrib.saved_model import load_keras_model
# from tensorflow import keras
from tensorflow.keras.models import load_model
import tensorflow.keras as keras
import tensorflow.keras.backend as K
from tensorflow.keras import backend
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.utils import get_custom_objects
from functools import partial
from sklearn import metrics
from sklearn.model_selection import KFold
import efficientnet.tfkeras

# # Read data

# +
df_test = pd.read_csv("../data/train.csv")
df_test["filename"] = df_test["id_code"] + ".png"

df_train = pd.read_csv("../data/train.csv")
df_train["filename"] = df_train["id_code"] + ".png"

df_train.head()


# -

# # Data Generator Object

def data_generator(df, img_dir, batch_size):
    test_gen = ImageDataGenerator()

    test_generator = test_gen.flow_from_dataframe(
        dataframe = df,
        directory = img_dir,
        x_col = "filename",
        y_col = None,
        shuffle = False,
        class_mode = None,
        batch_size = batch_size,
        target_size = (300, 300)
    )
    
    return test_generator


# # Functions to predict from cv folds

# +
# Custom loss
def root_mse(y_true, y_pred):
    return K.sqrt(K.mean(K.square(y_pred - y_true)))

# Fetch model
def get_model(model_dir, fold_nr):
    K.clear_session()
    tf.reset_default_graph()
    best_epoch_model = load_model(
        model_dir + "effnet_reg_fold" + str(fold_nr) + ".h5", 
        custom_objects = {"root_mse": root_mse})
    return(best_epoch_model)


#### Test set prediction functino ####

def pred_cv_test(
    df,
    model_dir,
    folds,
    nr_samples = len(df_test),
    batch_size = 8
):
    
    all_preds = []
    
    for fold in range(1, folds + 1):
        
        test_generator = data_generator(df, 
                                    img_dir = "E:/Kaggle/abd/lalush/data/test_images",
                                    batch_size = batch_size)
        
        model = get_model(model_dir = model_dir, fold_nr = fold)
        preds = model.predict_generator(
            generator = test_generator,
            steps = np.ceil(nr_samples/batch_size),
            workers=8
        )
        
        all_preds.append(preds)
        
    return(all_preds)



#### Valid sets prediction functino ####

def pred_cv_valid(
    df,
    model_dir,
    folds,
    batch_size = 64
):
    
    kf = KFold(n_splits = folds, shuffle = True, random_state = 10)
    fold_nr = 1
    
    all_preds = []
    
    for train_index, valid_index in kf.split(df):
        
        # Get validation data of each split
        df_valid = df.iloc[valid_index]
        nr_valid_samples = np.ceil(len(df_valid))
        
        valid_generator = data_generator(df_valid, img_dir = "E:/Kaggle/abd/lalush/data/train_images",
                                         batch_size = batch_size)
        
        model = get_model(model_dir = model_dir, fold_nr = fold_nr)
        preds = model.predict_generator(
            generator = valid_generator,
            steps = np.ceil(nr_valid_samples/batch_size),
            workers = 8
        )
        
        all_preds.append(preds)
        valid_generator.reset()
        fold_nr += 1
        
    return(all_preds)
# -

# # Predict validation sets

# +
preds = pred_cv_valid(df = df_train,
                      model_dir = "../",
                      folds = 1,
                      batch_size = 16)