grain_unearth-bilinear-cutmix.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "executionInfo": {
     "elapsed": 2716,
     "status": "ok",
     "timestamp": 1624439925606,
     "user": {
      "displayName": "ramdhan wibawa",
      "photoUrl": "",
      "userId": "14519448541243845830"
     },
     "user_tz": -420
    },
    "id": "mW8mQghJfh6D"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import logging\n",
    "import sys\n",
    "import os\n",
    "from os import getenv\n",
    "from os.path import abspath, basename, split,dirname\n",
    "import tarfile\n",
    "from shutil import copyfile\n",
    "import random, glob\n",
    "from skimage.util import random_noise\n",
    "from skimage.transform import rotate\n",
    "import time\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "import tensorflow as tf\n",
    "import tensorflow_datasets as tfds\n",
    "#import efficientnet.keras as efn\n",
    "#from efficientnet.tfkeras import EfficientNetB2\n",
    "from tensorflow.keras.applications import EfficientNetB0,EfficientNetB3, EfficientNetB2\n",
    "from tensorflow.keras.applications.resnet50 import ResNet50\n",
    "from tensorflow.keras.applications.resnet import ResNet101\n",
    "from tensorflow.keras.applications.inception_v3 import InceptionV3\n",
    "from tensorflow.keras.applications.mobilenet import MobileNet\n",
    "from tensorflow.keras.applications.densenet import DenseNet121, DenseNet169, DenseNet201\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow import keras\n",
    "#from tensorflow.keras.applications.efficientnet import preprocess_input\n",
    "from tensorflow.keras.applications.resnet50 import preprocess_input\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "import tensorflow.keras.backend as K\n",
    "from sklearn.metrics import accuracy_score\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "logger = logging.getLogger(__name__)\n",
    "logging.basicConfig(level=logging.INFO)\n",
    "ds_build_cmd = \"tfds build grains --manual_dir=\" + \"D:/Ramdhan/Unearth/visual-grain-analysis/data/public2\"\n",
    "logger.info(ds_build_cmd)\n",
    "os.system(ds_build_cmd)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "model1 = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n",
    "    \n",
    "for layer in model1.layers:\n",
    "    print(layer.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_beta_distribution(size, concentration_0=0.2, concentration_1=0.2):\n",
    "    gamma_1_sample = tf.random.gamma(shape=[size], alpha=concentration_1)\n",
    "    gamma_2_sample = tf.random.gamma(shape=[size], alpha=concentration_0)\n",
    "    return gamma_1_sample / (gamma_1_sample + gamma_2_sample)\n",
    "\n",
    "\n",
    "@tf.function\n",
    "def get_box(lambda_value):\n",
    "    cut_rat = tf.math.sqrt(1.0 - lambda_value)\n",
    "\n",
    "    cut_w = IMG_SIZE * cut_rat  # rw\n",
    "    cut_w = tf.cast(cut_w, tf.int32)\n",
    "\n",
    "    cut_h = IMG_SIZE * cut_rat  # rh\n",
    "    cut_h = tf.cast(cut_h, tf.int32)\n",
    "\n",
    "    cut_x = tf.random.uniform((1,), minval=0, maxval=IMG_SIZE, dtype=tf.int32)  # rx\n",
    "    cut_y = tf.random.uniform((1,), minval=0, maxval=IMG_SIZE, dtype=tf.int32)  # ry\n",
    "\n",
    "    boundaryx1 = tf.clip_by_value(cut_x[0] - cut_w // 2, 0, IMG_SIZE)\n",
    "    boundaryy1 = tf.clip_by_value(cut_y[0] - cut_h // 2, 0, IMG_SIZE)\n",
    "    bbx2 = tf.clip_by_value(cut_x[0] + cut_w // 2, 0, IMG_SIZE)\n",
    "    bby2 = tf.clip_by_value(cut_y[0] + cut_h // 2, 0, IMG_SIZE)\n",
    "\n",
    "    target_h = bby2 - boundaryy1\n",
    "    if target_h == 0:\n",
    "        target_h += 1\n",
    "\n",
    "    target_w = bbx2 - boundaryx1\n",
    "    if target_w == 0:\n",
    "        target_w += 1\n",
    "\n",
    "    return boundaryx1, boundaryy1, target_h, target_w\n",
    "\n",
    "\n",
    "@tf.function\n",
    "def cutmix(train_ds_one, train_ds_two):\n",
    "    (image1, label1), (image2, label2) = train_ds_one, train_ds_two\n",
    "\n",
    "    alpha = [0.25]\n",
    "    beta = [0.25]\n",
    "\n",
    "    # Get a sample from the Beta distribution\n",
    "    lambda_value = sample_beta_distribution(1, alpha, beta)\n",
    "\n",
    "    # Define Lambda\n",
    "    lambda_value = lambda_value[0][0]\n",
    "\n",
    "    # Get the bounding box offsets, heights and widths\n",
    "    boundaryx1, boundaryy1, target_h, target_w = get_box(lambda_value)\n",
    "\n",
    "    # Get a patch from the second image (`image2`)\n",
    "    crop2 = tf.image.crop_to_bounding_box(\n",
    "        image2, boundaryy1, boundaryx1, target_h, target_w\n",
    "    )\n",
    "    # Pad the `image2` patch (`crop2`) with the same offset\n",
    "    image2 = tf.image.pad_to_bounding_box(\n",
    "        crop2, boundaryy1, boundaryx1, IMG_SIZE, IMG_SIZE\n",
    "    )\n",
    "    # Get a patch from the first image (`image1`)\n",
    "    crop1 = tf.image.crop_to_bounding_box(\n",
    "        image1, boundaryy1, boundaryx1, target_h, target_w\n",
    "    )\n",
    "    # Pad the `image1` patch (`crop1`) with the same offset\n",
    "    img1 = tf.image.pad_to_bounding_box(\n",
    "        crop1, boundaryy1, boundaryx1, IMG_SIZE, IMG_SIZE\n",
    "    )\n",
    "\n",
    "    # Modify the first image by subtracting the patch from `image1`\n",
    "    # (before applying the `image2` patch)\n",
    "    image1 = image1 - img1\n",
    "    # Add the modified `image1` and `image2`  together to get the CutMix image\n",
    "    image = image1 + image2\n",
    "\n",
    "    # Adjust Lambda in accordance to the pixel ration\n",
    "    lambda_value = 1 - (target_w * target_h) / (IMG_SIZE * IMG_SIZE)\n",
    "    lambda_value = tf.cast(lambda_value, tf.float32)\n",
    "\n",
    "    # Combine the labels of both images\n",
    "    label = lambda_value * label1 + (1 - lambda_value) * label2\n",
    "    return image, label"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "IMG_SIZE = 224\n",
    "size = (IMG_SIZE, IMG_SIZE)\n",
    "batch_size = 32\n",
    "train_ds = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "    \"D:/Ramdhan/Unearth/visual-grain-analysis/data/public/train\",\n",
    "    image_size=size,\n",
    "    batch_size=batch_size,\n",
    "    interpolation='nearest'\n",
    ")\n",
    "\n",
    "train_ds_one = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "    \"D:/Ramdhan/Unearth/visual-grain-analysis/data/public/train\",\n",
    "    image_size=size,\n",
    "    batch_size=batch_size,\n",
    "    interpolation='nearest'\n",
    ")\n",
    "\n",
    "train_ds_two = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "    \"D:/Ramdhan/Unearth/visual-grain-analysis/data/public/train\",\n",
    "    image_size=size,\n",
    "    batch_size=batch_size,\n",
    "    interpolation='nearest'\n",
    ")\n",
    "\n",
    "train_ds_one = train_ds_one.map(lambda image, label: (image, tf.one_hot(label, 28)))\n",
    "train_ds_two = train_ds_two.map(lambda image, label: (image, tf.one_hot(label, 28)))\n",
    "\n",
    "train_ds_combine = tf.data.Dataset.zip((train_ds_one, train_ds_two))\n",
    "\n",
    "val_ds = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "    \"D:/Ramdhan/Unearth/visual-grain-analysis/data/public/val\",\n",
    "    image_size=size,\n",
    "    batch_size=batch_size,\n",
    "    interpolation='nearest'\n",
    ")\n",
    "\n",
    "val_ds = val_ds.map(lambda image, label: (image, tf.one_hot(label, 28)))\n",
    "\n",
    "\n",
    "train_ds_combine_cum = train_ds_combine.map(cutmix)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "image_batch, label_batch = next(iter(train_ds_combine_cum))\n",
    "plt.figure(figsize=(10, 10))\n",
    "for i in range(9):\n",
    "    print(label_batch)\n",
    "    ax = plt.subplot(3, 3, i + 1)\n",
    "    plt.imshow(image_batch[i])\n",
    "    plt.axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "executionInfo": {
     "elapsed": 493,
     "status": "ok",
     "timestamp": 1624440223471,
     "user": {
      "displayName": "ramdhan wibawa",
      "photoUrl": "",
      "userId": "14519448541243845830"
     },
     "user_tz": -420
    },
    "id": "-GFNqiGNfh6F"
   },
   "outputs": [],
   "source": [
    "logger = logging.getLogger(__name__)\n",
    "logging.basicConfig(level=logging.INFO)\n",
    "IMG_SIZE = 224\n",
    "LBL = dict(zip(['B_BSMUT1', 'B_CLEV5B', 'B_DISTO', 'B_GRMEND', 'B_HDBARL',\n",
    "       'B_PICKLD', 'B_SKINED', 'B_SOUND', 'B_SPRTED', 'B_SPTMLD',\n",
    "       'O_GROAT', 'O_HDOATS', 'O_SEPAFF', 'O_SOUND', 'O_SPOTMA',\n",
    "       'WD_RADPODS', 'WD_RYEGRASS', 'WD_SPEARGRASS', 'WD_WILDOATS',\n",
    "       'W_DISTO', 'W_FLDFUN', 'W_INSDA2', 'W_PICKLE', 'W_SEVERE',\n",
    "       'W_SOUND', 'W_SPROUT', 'W_STAIND', 'W_WHITEG'], range(28)))\n",
    "\n",
    "cls_map = dict(zip(LBL.values(),LBL.keys()))\n",
    "\n",
    "model_version = '001'\n",
    "\n",
    "# Work around for a SageMaker path issue\n",
    "# (see https://github.com/aws/sagemaker-python-sdk/issues/648)\n",
    "# WARNING - removing this may cause the submission process to fail\n",
    "#if abspath(\"D:/Ramdhan/Unearth/visual-grain-analysis\") not in sys.path:\n",
    " #   sys.path.append(abspath(\"D:/Ramdhan/Unearth/visual-grain-analysis\"))\n",
    "\n",
    "def input_preprocess(image, label):\n",
    "    label = tf.one_hot(label, NUM_CLASSES)\n",
    "    return image, label\n",
    "\n",
    "def get_subfolders(directory):\n",
    "    subfolders = os.listdir(directory)\n",
    "    subfolders.sort()\n",
    "    return subfolders\n",
    "\n",
    "def save_class_list(class_list):\n",
    "    class_list.sort()\n",
    "    target=open(\"class_list.txt\",'w')\n",
    "    for c in class_list:\n",
    "        target.write(c)\n",
    "        target.write(\"\\n\")\n",
    "\n",
    "def get_num_files(directory):\n",
    "    if not os.path.exists(directory):\n",
    "        return 0\n",
    "    cnt = 0\n",
    "    for r, dirs, files in os.walk(directory):\n",
    "        for dr in dirs:\n",
    "            cnt += len(glob.glob(os.path.join(r, dr + \"/*\")))\n",
    "    return cnt\n",
    "\n",
    "def outer_product(x):\n",
    "    #Einstein Notation  [batch,1,1,depth] x [batch,1,1,depth] -> [batch,depth,depth]\n",
    "    phi_I = tf.einsum('ijkm,ijkn->imn',x[0],x[1])\n",
    "    \n",
    "    # Reshape from [batch_size,depth,depth] to [batch_size, depth*depth]\n",
    "    phi_I = tf.reshape(phi_I,[-1,x[0].shape[3]*x[1].shape[3]])\n",
    "    \n",
    "    # Divide by feature map size [sizexsize]\n",
    "    size1 = int(x[1].shape[1])\n",
    "    size2 = int(x[1].shape[2])\n",
    "    phi_I = tf.divide(phi_I, size1*size2)\n",
    "    \n",
    "    # Take signed square root of phi_I\n",
    "    y_ssqrt = tf.multiply(tf.sign(phi_I),tf.sqrt(tf.abs(phi_I)+1e-12))\n",
    "    \n",
    "    # Apply l2 normalization\n",
    "    z_l2 = tf.nn.l2_normalize(y_ssqrt, axis=1)\n",
    "    return z_l2\n",
    "\n",
    "def get_cosine_schedule_with_warmup(lr, num_warmup_steps, num_training_steps, num_cycles=0.5):\n",
    "    \"\"\"\n",
    "    Modified the get_cosine_schedule_with_warmup from huggingface for tensorflow\n",
    "    (https://huggingface.co/transformers/_modules/transformers/optimization.html#get_cosine_schedule_with_warmup)\n",
    "\n",
    "    Create a schedule with a learning rate that decreases following the\n",
    "    values of the cosine function between 0 and `pi * cycles` after a warmup\n",
    "    period during which it increases linearly between 0 and 1.\n",
    "    \"\"\"\n",
    "\n",
    "    def lrfn(epoch):\n",
    "        if epoch < num_warmup_steps:\n",
    "            return float(epoch) / float(max(1, num_warmup_steps)) * lr\n",
    "        progress = float(epoch - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))\n",
    "        return max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress))) * lr\n",
    "\n",
    "    return tf.keras.callbacks.LearningRateScheduler(lrfn, verbose=True)\n",
    "\n",
    "def random_rotation(image_array):\n",
    "    # pick a random degree of rotation between 25% on the left and 25% on the right\n",
    "    random_degree = random.uniform(-180, 180)\n",
    "    return rotate(image_array, random_degree, mode='edge')\n",
    "\n",
    "def rotation_generator(batches):\n",
    "    while True:\n",
    "        batch_x, batch_y = next(batches)\n",
    "        batch_crops = np.zeros((batch_x.shape[0], 224, 224, 3))\n",
    "        for i in range(batch_x.shape[0]):\n",
    "            #batch_crops[i] = resize_pad(batch_x[i])\n",
    "            batch_crops[i] = random_rotation(batch_x[i])\n",
    "        yield (batch_crops, batch_y)\n",
    "        \n",
    "\n",
    "\n",
    "def train(args):\n",
    "    global NUM_CLASSES\n",
    "    TRAIN_DIR = os.path.join(args['data_dir'],  'train')\n",
    "    VAL_DIR = os.path.join(args['data_dir'], 'val')\n",
    "    size = (IMG_SIZE, IMG_SIZE)\n",
    "    batch_size = 32\n",
    "    train_ds = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "        \"D:/Ramdhan/Unearth/visual-grain-analysis/data/public/train\",\n",
    "        image_size=size,\n",
    "        batch_size=batch_size,\n",
    "        interpolation='nearest'\n",
    "    )\n",
    "\n",
    "    train_ds_one = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "        \"D:/Ramdhan/Unearth/visual-grain-analysis/data/public/train\",\n",
    "        image_size=size,\n",
    "        batch_size=batch_size,\n",
    "        interpolation='nearest'\n",
    "    )\n",
    "\n",
    "    train_ds_two = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "        \"D:/Ramdhan/Unearth/visual-grain-analysis/data/public/train\",\n",
    "        image_size=size,\n",
    "        batch_size=batch_size,\n",
    "        interpolation='nearest'\n",
    "    )\n",
    "\n",
    "    train_ds_one = train_ds_one.map(lambda image, label: (image, tf.one_hot(label, 28)))\n",
    "    train_ds_two = train_ds_two.map(lambda image, label: (image, tf.one_hot(label, 28)))\n",
    "\n",
    "    train_ds_combine = tf.data.Dataset.zip((train_ds_one, train_ds_two))\n",
    "\n",
    "    val_ds = tf.keras.preprocessing.image_dataset_from_directory(\n",
    "        \"D:/Ramdhan/Unearth/visual-grain-analysis/data/public/val\",\n",
    "        image_size=size,\n",
    "        batch_size=batch_size,\n",
    "        interpolation='nearest'\n",
    "    )\n",
    "\n",
    "    val_ds = val_ds.map(lambda image, label: (image, tf.one_hot(label, 28)))\n",
    "\n",
    "\n",
    "    train_ds_combine_cum = train_ds_combine.map(cutmix)\n",
    "\n",
    "    logger.info(\"Training Model\")\n",
    "    class_list = get_subfolders(TRAIN_DIR)\n",
    "    NUM_CLASSES = len(class_list)\n",
    "\n",
    "    num_train_images = get_num_files(TRAIN_DIR)\n",
    "    num_val_images = get_num_files(VAL_DIR)\n",
    "    \n",
    "    model = build_model_bilinear(num_classes=NUM_CLASSES)\n",
    "    filename = 'best.h5'\n",
    "    #reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor='loss', factor=0.5, patience=50, min_lr=0.0001)\n",
    "    checkpoint = ModelCheckpoint(filename, monitor='val_acc_grain', verbose=1, save_best_only=True, mode='max')\n",
    "    stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=40, mode= 'min', min_delta=0.00)\n",
    "    lr_schedule= get_cosine_schedule_with_warmup(lr=0.001, num_warmup_steps=4, num_training_steps=10)\n",
    "\n",
    "    # This comes from an environment variable so we can set it to 1 for our\n",
    "    # development pipeline. Feel free to set this to any value.\n",
    "    weights = dict(zip([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27], [1,1,1,1,1,1,1,8.94,1,1,1,1,1,8.94,1,1,1,1,1,1,1,1,1,1,8.94,1,1,1]))\n",
    "    \n",
    "    history = model.fit(train_ds_combine_cum, epochs=10, validation_data=val_ds, shuffle=True,\n",
    "                        callbacks=[stop,checkpoint,lr_schedule],#steps_per_epoch=num_train_images // batch_size,\n",
    "                         verbose=1, class_weight=weights)\n",
    "    \n",
    "    #save_model(model,args['model_dir'])\n",
    "    #save_model(model,filename)\n",
    "    \n",
    "    return history\n",
    "\n",
    "def acc_grain(y_true, y_pred):\n",
    "    y_true_class = K.argmax(y_true, axis=-1)\n",
    "    y_pred_class = K.argmax(y_pred, axis=-1)\n",
    "    sample_weight = np.hstack((np.where(y_true_class.numpy().reshape(-1,1)==7,True,False),np.where(y_true_class.numpy().reshape(-1,1)==24,True,False),np.where(y_true_class.numpy().reshape(-1,1)==13,True,False)))\n",
    "    sample_weight = np.any(sample_weight,axis=1)\n",
    "    sample_weight = np.where(sample_weight,8.94,1.0)\n",
    "    return K.constant(accuracy_score(y_true_class,y_pred_class,sample_weight=sample_weight))\n",
    "\n",
    "# Add on new FC layers with dropout for fine tuning\n",
    "def build_model_bilinear(num_classes):\n",
    "    \n",
    "    input_tensor = layers.Input(shape=(IMG_SIZE, IMG_SIZE, 3))\n",
    "    \n",
    "    model1 = ResNet50(weights='imagenet', include_top=False, input_tensor=input_tensor,input_shape=(IMG_SIZE, IMG_SIZE, 3))\n",
    "    model2 = ResNet50(weights='imagenet', include_top=False, input_tensor=input_tensor,input_shape=(IMG_SIZE, IMG_SIZE, 3))\n",
    "    \n",
    "    for layer in model1.layers[:]:\n",
    "        layer.trainable = False\n",
    "    for layer in model2.layers[:-1]:\n",
    "        layer.trainable = False\n",
    "        \n",
    "    for i, layer in enumerate(model1.layers):\n",
    "        layer._name = 'model1_' + layer.name\n",
    "\n",
    "    last_layer1 = model1.get_layer('model1_conv5_block3_out')\n",
    "    last_output1 = last_layer1.output\n",
    "\n",
    "    for i, layer in enumerate(model2.layers):\n",
    "        layer._name = 'model2_' + layer.name\n",
    "\n",
    "    last_layer2 = model2.get_layer('model2_conv5_block3_out')\n",
    "    #last_layer2 = model2.get_layer('model2_top_conv')\n",
    "    last_output2 = last_layer2.output\n",
    "    \n",
    "    \n",
    "    model1_ = tf.keras.Model(inputs=model1.input, outputs=last_output1)\n",
    "    model2_ = tf.keras.Model(inputs=model2.input, outputs=last_output2)\n",
    "    \n",
    "    #optimizer = tf.keras.optimizers.Adam(learning_rate=1e-5, decay=1e-3)\n",
    "   \n",
    "    \n",
    "    model1_.compile(optimizer='adam',loss=\"categorical_crossentropy\", metrics=[acc_grain],run_eagerly=True)\n",
    "    model2_.compile(optimizer='adam',loss=\"categorical_crossentropy\", metrics=[acc_grain],run_eagerly=True)\n",
    "    \n",
    "    d1=model1_.output\n",
    "    d2=model2_.output\n",
    "\n",
    "    bilinear = layers.Lambda(outer_product, name='outer_product1')([d1,d2])\n",
    "    \n",
    "    predictions= layers.Dense(num_classes, activation='softmax', name='pred')(bilinear)\n",
    "    model = tf.keras.Model(inputs=model1.input, outputs=predictions)\n",
    "    \n",
    "    model.compile(optimizer='adam', loss=\"categorical_crossentropy\", metrics=[acc_grain],run_eagerly=True)\n",
    "    \n",
    "    return model\n",
    "    \n",
    "def save_model(model, model_dir):\n",
    "    \"\"\"Save model to a binary file.\n",
    "\n",
    "    This function must write the model to disk in a format that can\n",
    "    be loaded from the model_fn.\n",
    "\n",
    "    WARNING - modifying this function may cause the submission process to fail.\n",
    "    \"\"\"\n",
    "    #sm_model_dir = os.path.join(model_dir, model_version)\n",
    "    sm_model_dir = model_dir\n",
    "    if (not os.path.isdir(sm_model_dir)):\n",
    "        os.makedirs(sm_model_dir)\n",
    "        \n",
    "    logger.info(f\" model dir is {model_dir}\")\n",
    "    model.save(sm_model_dir)\n",
    "    \n",
    "    modelPath = os.path.join(sm_model_dir, 'output')\n",
    "    if (not os.path.isdir(modelPath)):\n",
    "        os.makedirs(modelPath)\n",
    "    #if (not os.path.isdir(sm_model_dir + '/code')):\n",
    "        #os.makedirs(sm_model_dir + '/code')\n",
    "\n",
    "    # Move inference.py so it gets picked up in the archive\n",
    "    #copyfile('/content/sample_data/inference.py', sm_model_dir + '/code/inference.py')\n",
    "    #copyfile('/content/sample_data/inference-requirements.txt', sm_model_dir+ '/code/requirements.txt')\n",
    "\n",
    "    with tarfile.open(os.path.join(modelPath, 'model.tar.gz'), mode='x:gz') as archive:\n",
    "        archive.add(sm_model_dir, recursive=True)\n",
    "\n",
    "def model_fn(model_dir):\n",
    "    \"\"\"Load model from binary file.\n",
    "\n",
    "    This function loads the model from disk. It is called by SageMaker.\n",
    "\n",
    "    WARNING - modifying this function may case the submission process to fail.\n",
    "    \"\"\"\n",
    "    #model_filepath = os.path.join(model_dir,  model_version)\n",
    "    #logger.info(\"loading model from \" + model_filepath)\n",
    "    model = keras.models.load_model('best.h5',custom_objects={'acc_grain':acc_grain},compile=False)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.test.is_gpu_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/device:GPU:0'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.test.gpu_device_name() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 459
    },
    "executionInfo": {
     "elapsed": 38441,
     "status": "error",
     "timestamp": 1624440265326,
     "user": {
      "displayName": "ramdhan wibawa",
      "photoUrl": "",
      "userId": "14519448541243845830"
     },
     "user_tz": -420
    },
    "id": "RLmWtwmRfh6P",
    "outputId": "e5e2ae19-620c-4d31-f907-12bb2132639e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 19182 files belonging to 28 classes.\n",
      "Found 19182 files belonging to 28 classes.\n",
      "Found 19182 files belonging to 28 classes.\n",
      "Found 7648 files belonging to 28 classes.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:Training Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 00001: LearningRateScheduler reducing learning rate to 0.0.\n",
      "Epoch 1/10\n",
      "600/600 [==============================] - ETA: 0s - loss: 21.3714 - acc_grain: 0.0218\n",
      "Epoch 00001: val_acc_grain improved from -inf to 0.04586, saving model to best.h5\n",
      "600/600 [==============================] - 509s 849ms/step - loss: 21.3714 - acc_grain: 0.0218 - val_loss: 3.3324 - val_acc_grain: 0.0459\n",
      "\n",
      "Epoch 00002: LearningRateScheduler reducing learning rate to 0.00025.\n",
      "Epoch 2/10\n",
      "600/600 [==============================] - ETA: 0s - loss: 7.0872 - acc_grain: 0.8086\n",
      "Epoch 00002: val_acc_grain improved from 0.04586 to 0.94220, saving model to best.h5\n",
      "600/600 [==============================] - 504s 840ms/step - loss: 7.0872 - acc_grain: 0.8086 - val_loss: 1.3271 - val_acc_grain: 0.9422\n",
      "\n",
      "Epoch 00003: LearningRateScheduler reducing learning rate to 0.0005.\n",
      "Epoch 3/10\n",
      "600/600 [==============================] - ETA: 0s - loss: 5.8870 - acc_grain: 0.8633\n",
      "Epoch 00003: val_acc_grain improved from 0.94220 to 0.95097, saving model to best.h5\n",
      "600/600 [==============================] - 505s 841ms/step - loss: 5.8870 - acc_grain: 0.8633 - val_loss: 0.9361 - val_acc_grain: 0.9510\n",
      "\n",
      "Epoch 00004: LearningRateScheduler reducing learning rate to 0.00075.\n",
      "Epoch 4/10\n",
      "600/600 [==============================] - ETA: 0s - loss: 5.2902 - acc_grain: 0.8856\n",
      "Epoch 00004: val_acc_grain improved from 0.95097 to 0.96166, saving model to best.h5\n",
      "600/600 [==============================] - 508s 847ms/step - loss: 5.2902 - acc_grain: 0.8856 - val_loss: 0.7695 - val_acc_grain: 0.9617\n",
      "\n",
      "Epoch 00005: LearningRateScheduler reducing learning rate to 0.001.\n",
      "Epoch 5/10\n",
      "600/600 [==============================] - ETA: 0s - loss: 5.2815 - acc_grain: 0.8852\n",
      "Epoch 00005: val_acc_grain improved from 0.96166 to 0.96591, saving model to best.h5\n",
      "600/600 [==============================] - 507s 846ms/step - loss: 5.2815 - acc_grain: 0.8852 - val_loss: 0.6824 - val_acc_grain: 0.9659\n",
      "\n",
      "Epoch 00006: LearningRateScheduler reducing learning rate to 0.0009330127018922195.\n",
      "Epoch 6/10\n",
      "600/600 [==============================] - ETA: 0s - loss: 5.1996 - acc_grain: 0.8890\n",
      "Epoch 00006: val_acc_grain did not improve from 0.96591\n",
      "600/600 [==============================] - 505s 841ms/step - loss: 5.1996 - acc_grain: 0.8890 - val_loss: 0.7066 - val_acc_grain: 0.9642\n",
      "\n",
      "Epoch 00007: LearningRateScheduler reducing learning rate to 0.00075.\n",
      "Epoch 7/10\n",
      "600/600 [==============================] - ETA: 0s - loss: 5.2093 - acc_grain: 0.8873\n",
      "Epoch 00007: val_acc_grain improved from 0.96591 to 0.96770, saving model to best.h5\n",
      "600/600 [==============================] - 507s 845ms/step - loss: 5.2093 - acc_grain: 0.8873 - val_loss: 0.6534 - val_acc_grain: 0.9677\n",
      "\n",
      "Epoch 00008: LearningRateScheduler reducing learning rate to 0.0005.\n",
      "Epoch 8/10\n",
      "600/600 [==============================] - ETA: 0s - loss: 4.8114 - acc_grain: 0.8964\n",
      "Epoch 00008: val_acc_grain improved from 0.96770 to 0.97031, saving model to best.h5\n",
      "600/600 [==============================] - 505s 842ms/step - loss: 4.8114 - acc_grain: 0.8964 - val_loss: 0.5910 - val_acc_grain: 0.9703\n",
      "\n",
      "Epoch 00009: LearningRateScheduler reducing learning rate to 0.0002500000000000001.\n",
      "Epoch 9/10\n",
      "600/600 [==============================] - ETA: 0s - loss: 4.7445 - acc_grain: 0.9015\n",
      "Epoch 00009: val_acc_grain improved from 0.97031 to 0.97155, saving model to best.h5\n",
      "600/600 [==============================] - 507s 845ms/step - loss: 4.7445 - acc_grain: 0.9015 - val_loss: 0.5501 - val_acc_grain: 0.9715\n",
      "\n",
      "Epoch 00010: LearningRateScheduler reducing learning rate to 6.698729810778065e-05.\n",
      "Epoch 10/10\n",
      "600/600 [==============================] - ETA: 0s - loss: 4.7353 - acc_grain: 0.8972\n",
      "Epoch 00010: val_acc_grain did not improve from 0.97155\n",
      "600/600 [==============================] - 502s 837ms/step - loss: 4.7353 - acc_grain: 0.8972 - val_loss: 0.5573 - val_acc_grain: 0.9714\n",
      "duration run 1.4157542919450337  hours\n"
     ]
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    \"\"\"Training Main\n",
    "\n",
    "    The main function is called by both Unearthed's SageMaker pipeline and the\n",
    "    Unearthed CLI's \"unearthed train\" command.\n",
    "    \n",
    "    WARNING - modifying this function may cause the submission process to fail.\n",
    "\n",
    "    The main function must call preprocess, arrange th\n",
    "    \"\"\"\n",
    "    \n",
    "    args = {'model_dir': \"D:/Ramdhan/Unearth/visual-grain-analysis/models/\",\n",
    "           'data_dir' : \"D:/Ramdhan/Unearth/visual-grain-analysis/data/public/\"}\n",
    "    start = time.time()\n",
    "    history = train(args)\n",
    "    print('duration run',(time.time()-start)/60/60,' hours')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x1440 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# Plot training & validation iou_score values\n",
    "plt.figure(figsize=(30, 20))\n",
    "plt.subplot(121)\n",
    "plt.plot(history.history['acc_grain'])\n",
    "plt.plot(history.history['val_acc_grain'])\n",
    "plt.title('Model acc_score')\n",
    "plt.ylabel('acc_score')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Test'], loc='upper left')\n",
    "\n",
    "# Plot training & validation loss values\n",
    "plt.subplot(122)\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('Model loss')\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Test'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 350
    },
    "executionInfo": {
     "elapsed": 2298,
     "status": "error",
     "timestamp": 1624373965288,
     "user": {
      "displayName": "ramdhan wibawa",
      "photoUrl": "",
      "userId": "14519448541243845830"
     },
     "user_tz": -420
    },
    "id": "UejZgfeXZ5C7",
    "outputId": "fbfcc699-a9ac-4b16-ccbb-0a8c4a25222e"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:loading the model\n",
      "INFO:__main__:Reading the test set\n",
      "INFO:__main__:predictions have shape of (7648, 9)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score:0.9725736430087167\n",
      "Duration Run 0.10519496023654938  hours\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing import image\n",
    "import pandas as pd\n",
    "import zipfile\n",
    "import csv\n",
    "\n",
    "start = time.time()\n",
    "\n",
    "def load_class_list(class_list_file):\n",
    "    class_list = []\n",
    "    with open(class_list_file, 'r') as csvfile:\n",
    "        file_reader = csv.reader(csvfile)\n",
    "        for row in file_reader:\n",
    "            class_list.append(row[0])\n",
    "    class_list.sort()\n",
    "    return class_list\n",
    "\n",
    "class_list = load_class_list('class_list.txt')\n",
    "\n",
    "IMG_SIZE=224\n",
    "LBL = dict(zip(class_list, range(28)))\n",
    "\n",
    "cls_map = dict(zip(LBL.values(),LBL.keys()))\n",
    "\n",
    "def init_dir(pth):\n",
    "    if os.path.exists(pth):\n",
    "        shutil.rmtree(pth)\n",
    "    os.mkdir(pth)\n",
    "\n",
    "logger.info(\"loading the model\")\n",
    "model = model_fn(args['model_dir'])\n",
    "logger.info(\"Reading the test set\")\n",
    "\n",
    "res = []\n",
    "for fn in glob.iglob(args['data_dir'] + 'val/**/*.png', recursive=True):\n",
    "    file_name = os.path.basename(fn)\n",
    "    path = os.path.abspath(fn)\n",
    "    folder = os.path.split(os.path.dirname(path))[1]\n",
    "    if len(file_name.split(\"-\")) > 2:  # ignore master image with may grains, raw image names are in guid format\n",
    "        im = image.load_img(path, target_size=(IMG_SIZE, IMG_SIZE))\n",
    "        img_array = image.img_to_array(im)\n",
    "        img_batch = np.expand_dims(img_array, axis=0)\n",
    "        #img_preprocessed = preprocess_input(img_batch)\n",
    "        img_preprocessed = img_batch\n",
    "        pred = model.predict(img_preprocessed)\n",
    "        top3 = (-pred[0]).argsort()[:3]\n",
    "        res.append({'file_name': file_name, 'path': path, 'cls': folder, 'prediction':top3[0],  'proba_1':pred[0][top3[0]], 'prediction2':top3[1], 'proba_2':pred[0][top3[1]],  'prediction3':top3[2], 'proba_3':pred[0][top3[2]]})\n",
    "\n",
    "df = pd.DataFrame(res)\n",
    "df['prediction'] = df.prediction.map(cls_map)\n",
    "df['prediction2'] = df.prediction2.map(cls_map)\n",
    "df['prediction3'] = df.prediction3.map(cls_map)\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "def w(x):\n",
    "    if \"_SOUND\" in x:\n",
    "        return 8.94 # weighting  Healthy grains more important than defective grains\n",
    "    return 1\n",
    "\n",
    "def scoring_fn(df):\n",
    "    \"\"\"\n",
    "    Weighted Accuracy Metric 90% Healthy grains, 10% unhealthy grains\n",
    "    \"\"\"\n",
    "    df['weight'] = df.cls.apply(w)\n",
    "    return accuracy_score(df.cls,df.prediction,sample_weight=df.weight)\n",
    "\n",
    "logger.info(f\"predictions have shape of {df.shape}\")\n",
    "\n",
    "score = scoring_fn(df)\n",
    "print (\"Accuracy Score:\" + str(score))\n",
    "# write to the output location\n",
    "\n",
    "print('Duration Run',(time.time()-start)/3600,' hours')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               precision    recall  f1-score   support\n",
      "\n",
      "     B_BSMUT1       0.98      0.90      0.94       105\n",
      "     B_CLEV5B       0.95      0.41      0.57       100\n",
      "      B_DISTO       0.93      0.43      0.59       100\n",
      "     B_GRMEND       0.98      0.51      0.67        88\n",
      "     B_HDBARL       0.67      0.33      0.44        30\n",
      "     B_PICKLD       0.96      0.47      0.63        92\n",
      "     B_SKINED       1.00      0.20      0.34        88\n",
      "      B_SOUND       0.81      1.00      0.89      1653\n",
      "     B_SPRTED       1.00      0.87      0.93        93\n",
      "     B_SPTMLD       0.90      0.23      0.37       112\n",
      "      O_GROAT       1.00      0.78      0.88        90\n",
      "     O_HDOATS       0.76      0.26      0.39        99\n",
      "     O_SEPAFF       0.94      0.72      0.81       109\n",
      "      O_SOUND       0.92      1.00      0.96      1988\n",
      "     O_SPOTMA       0.83      0.29      0.43       103\n",
      "   WD_RADPODS       0.99      0.99      0.99        94\n",
      "  WD_RYEGRASS       0.96      0.94      0.95        87\n",
      "WD_SPEARGRASS       0.99      0.95      0.97        94\n",
      "  WD_WILDOATS       1.00      0.99      0.99        92\n",
      "      W_DISTO       0.87      0.66      0.75       102\n",
      "     W_FLDFUN       0.74      0.16      0.27       105\n",
      "     W_INSDA2       0.89      0.60      0.72        97\n",
      "     W_PICKLE       0.96      0.88      0.92       104\n",
      "     W_SEVERE       0.97      0.93      0.95       101\n",
      "      W_SOUND       0.83      1.00      0.90      1611\n",
      "     W_SPROUT       0.97      0.33      0.50       108\n",
      "     W_STAIND       0.75      0.43      0.55        92\n",
      "     W_WHITEG       0.93      0.47      0.62       111\n",
      "\n",
      "     accuracy                           0.87      7648\n",
      "    macro avg       0.91      0.63      0.71      7648\n",
      " weighted avg       0.88      0.87      0.85      7648\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(df['cls'], df['prediction']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import confusion_matrix\n",
    "ticks=np.linspace(0, 27,num=28)\n",
    "plt.figure(figsize=(15,15))\n",
    "plt.imshow(confusion_matrix(df['cls'], df['prediction'],normalize='true'), interpolation='none')\n",
    "plt.colorbar()\n",
    "plt.xticks(ticks,fontsize=6)\n",
    "plt.yticks(ticks,fontsize=6)\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WZXP_9Kzfh6Q"
   },
   "outputs": [],
   "source": [
    "from keras_preprocessing import image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "s0bgHcc9rskI"
   },
   "outputs": [],
   "source": [
    "NUM_CLASSES=28\n",
    "model = build_model(num_classes=NUM_CLASSES)\n",
    "model.fit?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3Fcx6Qvnfh6Q",
    "outputId": "fc7bceb9-5ffb-46bc-ffaf-7e1cf07f05c0"
   },
   "outputs": [],
   "source": [
    "image.random_rotation(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "saWJd9X3fh6R"
   },
   "outputs": [],
   "source": [
    " rotation_range=args.rotation,\n",
    "      shear_range=args.shear,\n",
    "      zoom_range=args.zoom,\n",
    "      horizontal_flip=args.h_flip,\n",
    "      vertical_flip=args.v_flip"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "grain_unearth.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}