{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Flower Classification Dataset\n\nAmazonas State University\n\nData Science Specialization\n\nApplied Deep Learning\n\nStudents: \n* Andrea Monicque\n* Marcos Wenneton","metadata":{"id":"wA0Wr1iw_oGJ"}},{"cell_type":"markdown","source":"**Abstract:**\n\nThis notebook aims to show how to perform a Transfer Learning model for Flower Classification. We used InceptionV3 with and without weights from imagenet, which is available together with keras/tensorflow framework.\n\n---\n\n* [dataset](https://www.kaggle.com/c/tpu-getting-started)\n","metadata":{}},{"cell_type":"code","source":"# General Libs\nfrom tensorflow import keras\nfrom tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input\nfrom tensorflow.keras.applications.mobilenet_v2 import MobileNetV2, preprocess_input\nfrom tensorflow.keras.applications import EfficientNetB7\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator\nfrom tensorflow.keras.preprocessing import image\nfrom tensorflow.keras.models import Sequential, Model\nfrom tensorflow.keras.layers import GlobalAveragePooling2D, Dense, BatchNormalization, Dropout, Flatten, Conv2D, MaxPooling2D\nfrom tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.optimizers import *\nfrom tensorflow.keras.initializers import *\nimport numpy as np\nimport random\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\n%matplotlib inline\n\nfrom sklearn.metrics import f1_score, precision_score, recall_score, confusion_matrix, accuracy_score\n\nimport os\nimport re\nimport math\n\nfrom kaggle_datasets import KaggleDatasets","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:42:55.796634Z","iopub.execute_input":"2021-11-04T02:42:55.797792Z","iopub.status.idle":"2021-11-04T02:42:55.813506Z","shell.execute_reply.started":"2021-11-04T02:42:55.797728Z","shell.execute_reply":"2021-11-04T02:42:55.812573Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import tensorflow as tf\nimport PIL\nimport PIL.Image","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:42:55.815655Z","iopub.execute_input":"2021-11-04T02:42:55.816392Z","iopub.status.idle":"2021-11-04T02:42:55.824863Z","shell.execute_reply.started":"2021-11-04T02:42:55.816345Z","shell.execute_reply":"2021-11-04T02:42:55.824250Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Util functions","metadata":{}},{"cell_type":"code","source":"def display_confusion_matrix(cmat, score, precision, recall, accuracy):\n    plt.figure(figsize=(15,15))\n    ax = plt.gca()\n    ax.matshow(cmat, cmap='Reds')\n    ax.set_xticks(range(len(CLASSES)))\n    ax.set_xticklabels(CLASSES, fontdict={'fontsize': 7})\n    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"left\", rotation_mode=\"anchor\")\n    ax.set_yticks(range(len(CLASSES)))\n    ax.set_yticklabels(CLASSES, fontdict={'fontsize': 7})\n    plt.setp(ax.get_yticklabels(), rotation=45, ha=\"right\", rotation_mode=\"anchor\")\n    titlestring = \"\"\n    if score is not None:\n        titlestring += 'f1 = {:.3f} '.format(score)\n    if accuracy is not None:\n        titlestring += '\\naccuracy = {:.3f} '.format(accuracy)\n    if precision is not None:\n        titlestring += '\\nprecision = {:.3f} '.format(precision)\n    if recall is not None:\n        titlestring += '\\nrecall = {:.3f} '.format(recall)\n    if len(titlestring) > 0:\n        ax.text(101, 1, titlestring, fontdict={'fontsize': 18, 'horizontalalignment':'right', 'verticalalignment':'top', 'color':'#804040'})\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:42:55.826040Z","iopub.execute_input":"2021-11-04T02:42:55.826450Z","iopub.status.idle":"2021-11-04T02:42:55.837186Z","shell.execute_reply.started":"2021-11-04T02:42:55.826417Z","shell.execute_reply":"2021-11-04T02:42:55.836579Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def display_training_curves(training, validation, title, subplot):\n    if subplot%10==1: # set up the subplots on the first call\n        plt.subplots(figsize=(10,10), facecolor='#F0F0F0')\n        plt.tight_layout()\n    ax = plt.subplot(subplot)\n    ax.set_facecolor('#F8F8F8')\n    ax.plot(training)\n    ax.plot(validation)\n    ax.set_title('model '+ title)\n    ax.set_ylabel(title)\n    #ax.set_ylim(0.28,1.05)\n    ax.set_xlabel('epoch')\n    ax.legend(['train', 'valid.'])","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:42:55.839168Z","iopub.execute_input":"2021-11-04T02:42:55.839601Z","iopub.status.idle":"2021-11-04T02:42:55.851928Z","shell.execute_reply.started":"2021-11-04T02:42:55.839571Z","shell.execute_reply":"2021-11-04T02:42:55.851295Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Instance TPU","metadata":{}},{"cell_type":"code","source":"# Detect TPU, return appropriate distribution strategy\ntry:\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver() \n    print('Running on TPU ', tpu.master())\nexcept ValueError:\n    tpu = None\n\nif tpu:\n    tf.config.experimental_connect_to_cluster(tpu)\n    tf.tpu.experimental.initialize_tpu_system(tpu)\n    strategy = tf.distribute.experimental.TPUStrategy(tpu)\nelse:\n    strategy = tf.distribute.get_strategy() \n\nprint(\"REPLICAS: \", strategy.num_replicas_in_sync)","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:42:55.853509Z","iopub.execute_input":"2021-11-04T02:42:55.854246Z","iopub.status.idle":"2021-11-04T02:43:02.133288Z","shell.execute_reply.started":"2021-11-04T02:42:55.854206Z","shell.execute_reply":"2021-11-04T02:43:02.132605Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from kaggle_datasets import KaggleDatasets\n\nGCS_DS_PATH = KaggleDatasets().get_gcs_path('tpu-getting-started')\nprint(GCS_DS_PATH) # what do gcs paths look like?","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:43:02.134821Z","iopub.execute_input":"2021-11-04T02:43:02.135044Z","iopub.status.idle":"2021-11-04T02:43:02.616393Z","shell.execute_reply.started":"2021-11-04T02:43:02.135017Z","shell.execute_reply":"2021-11-04T02:43:02.615493Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Read data","metadata":{}},{"cell_type":"code","source":"IMAGE_SIZE = [512, 512]\nGCS_PATH = GCS_DS_PATH + '/tfrecords-jpeg-512x512'\nAUTO = tf.data.experimental.AUTOTUNE\n\nTRAINING_FILENAMES = tf.io.gfile.glob(GCS_PATH + '/train/*.tfrec')\nVALIDATION_FILENAMES = tf.io.gfile.glob(GCS_PATH + '/val/*.tfrec')\nTEST_FILENAMES = tf.io.gfile.glob(GCS_PATH + '/test/*.tfrec') \n\nCLASSES = ['pink primrose',    'hard-leaved pocket orchid', 'canterbury bells', 'sweet pea',     'wild geranium',     'tiger lily',           'moon orchid',              'bird of paradise', 'monkshood',        'globe thistle',         # 00 - 09\n           'snapdragon',       \"colt's foot\",               'king protea',      'spear thistle', 'yellow iris',       'globe-flower',         'purple coneflower',        'peruvian lily',    'balloon flower',   'giant white arum lily', # 10 - 19\n           'fire lily',        'pincushion flower',         'fritillary',       'red ginger',    'grape hyacinth',    'corn poppy',           'prince of wales feathers', 'stemless gentian', 'artichoke',        'sweet william',         # 20 - 29\n           'carnation',        'garden phlox',              'love in the mist', 'cosmos',        'alpine sea holly',  'ruby-lipped cattleya', 'cape flower',              'great masterwort', 'siam tulip',       'lenten rose',           # 30 - 39\n           'barberton daisy',  'daffodil',                  'sword lily',       'poinsettia',    'bolero deep blue',  'wallflower',           'marigold',                 'buttercup',        'daisy',            'common dandelion',      # 40 - 49\n           'petunia',          'wild pansy',                'primula',          'sunflower',     'lilac hibiscus',    'bishop of llandaff',   'gaura',                    'geranium',         'orange dahlia',    'pink-yellow dahlia',    # 50 - 59\n           'cautleya spicata', 'japanese anemone',          'black-eyed susan', 'silverbush',    'californian poppy', 'osteospermum',         'spring crocus',            'iris',             'windflower',       'tree poppy',            # 60 - 69\n           'gazania',          'azalea',                    'water lily',       'rose',          'thorn apple',       'morning glory',        'passion flower',           'lotus',            'toad lily',        'anthurium',             # 70 - 79\n           'frangipani',       'clematis',                  'hibiscus',         'columbine',     'desert-rose',       'tree mallow',          'magnolia',                 'cyclamen ',        'watercress',       'canna lily',            # 80 - 89\n           'hippeastrum ',     'bee balm',                  'pink quill',       'foxglove',      'bougainvillea',     'camellia',             'mallow',                   'mexican petunia',  'bromelia',         'blanket flower',        # 90 - 99\n           'trumpet creeper',  'blackberry lily',           'common tulip',     'wild rose']                                                                                                                                               # 100 - 102\n\n\ndef decode_image(image_data):\n    image = tf.image.decode_jpeg(image_data, channels=3)\n    image = tf.cast(image, tf.float32) / 255.0  # convert image to floats in [0, 1] range\n    image = tf.reshape(image, [*IMAGE_SIZE, 3]) # explicit size needed for TPU\n    return image\n\ndef read_labeled_tfrecord(example):\n    LABELED_TFREC_FORMAT = {\n        \"image\": tf.io.FixedLenFeature([], tf.string), # tf.string means bytestring\n        \"class\": tf.io.FixedLenFeature([], tf.int64),  # shape [] means single element\n    }\n    example = tf.io.parse_single_example(example, LABELED_TFREC_FORMAT)\n    image = decode_image(example['image'])\n    label = tf.cast(example['class'], tf.int32)\n    return image, label # returns a dataset of (image, label) pairs\n\ndef read_unlabeled_tfrecord(example):\n    UNLABELED_TFREC_FORMAT = {\n        \"image\": tf.io.FixedLenFeature([], tf.string), # tf.string means bytestring\n        \"id\": tf.io.FixedLenFeature([], tf.string),  # shape [] means single element\n        # class is missing, this competitions's challenge is to predict flower classes for the test dataset\n    }\n    example = tf.io.parse_single_example(example, UNLABELED_TFREC_FORMAT)\n    image = decode_image(example['image'])\n    idnum = example['id']\n    return image, idnum # returns a dataset of image(s)\n\ndef load_dataset(filenames, labeled=True, ordered=False):\n    # Read from TFRecords. For optimal performance, reading from multiple files at once and\n    # disregarding data order. Order does not matter since we will be shuffling the data anyway.\n\n    ignore_order = tf.data.Options()\n    if not ordered:\n        ignore_order.experimental_deterministic = False # disable order, increase speed\n\n    dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTO) # automatically interleaves reads from multiple files\n    dataset = dataset.with_options(ignore_order) # uses data as soon as it streams in, rather than in its original order\n    dataset = dataset.map(read_labeled_tfrecord if labeled else read_unlabeled_tfrecord, num_parallel_calls=AUTO)\n    # returns a dataset of (image, label) pairs if labeled=True or (image, id) pairs if labeled=False\n    return dataset","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:43:02.617942Z","iopub.execute_input":"2021-11-04T02:43:02.618195Z","iopub.status.idle":"2021-11-04T02:43:02.861415Z","shell.execute_reply.started":"2021-11-04T02:43:02.618165Z","shell.execute_reply":"2021-11-04T02:43:02.860331Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def data_augment(image, label):\n    # Thanks to the dataset.prefetch(AUTO)\n    # statement in the next function (below), this happens essentially\n    # for free on TPU. Data pipeline code is executed on the \"CPU\"\n    # part of the TPU while the TPU itself is computing gradients.\n    image = tf.image.random_flip_left_right(image)\n    #image = tf.image.random_saturation(image, 0, 2)\n    return image, label   \n\ndef get_training_dataset():\n    dataset = load_dataset(TRAINING_FILENAMES, labeled=True)\n    dataset = dataset.map(data_augment, num_parallel_calls=AUTO)\n    dataset = dataset.repeat() # the training dataset must repeat for several epochs\n    dataset = dataset.shuffle(2048)\n    dataset = dataset.batch(BATCH_SIZE)\n    dataset = dataset.prefetch(AUTO) # prefetch next batch while training (autotune prefetch buffer size)\n    return dataset\n\ndef get_validation_dataset(ordered=False):\n    dataset = load_dataset(VALIDATION_FILENAMES, labeled=True, ordered=ordered)\n    dataset = dataset.batch(BATCH_SIZE)\n    dataset = dataset.cache()\n    dataset = dataset.prefetch(AUTO)\n    return dataset\n\ndef get_test_dataset(ordered=False):\n    dataset = load_dataset(TEST_FILENAMES, labeled=False, ordered=ordered)\n    dataset = dataset.batch(BATCH_SIZE)\n    dataset = dataset.prefetch(AUTO)\n    return dataset\n\ndef count_data_items(filenames):\n    # the number of data items is written in the name of the .tfrec\n    # files, i.e. flowers00-230.tfrec = 230 data items\n    n = [int(re.compile(r\"-([0-9]*)\\.\").search(filename).group(1)) for filename in filenames]\n    return np.sum(n)\n\nNUM_TRAINING_IMAGES = count_data_items(TRAINING_FILENAMES)\nNUM_VALIDATION_IMAGES = count_data_items(VALIDATION_FILENAMES)\nNUM_TEST_IMAGES = count_data_items(TEST_FILENAMES)\nprint('Dataset: {} training images, {} validation images, {} unlabeled test images'.format(NUM_TRAINING_IMAGES, NUM_VALIDATION_IMAGES, NUM_TEST_IMAGES))","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:43:02.863218Z","iopub.execute_input":"2021-11-04T02:43:02.863707Z","iopub.status.idle":"2021-11-04T02:43:02.878275Z","shell.execute_reply.started":"2021-11-04T02:43:02.863659Z","shell.execute_reply":"2021-11-04T02:43:02.877372Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Define the batch size. This will be 16 with TPU off and 128 (=16*8) with TPU on\nBATCH_SIZE = 16 * strategy.num_replicas_in_sync\n\nds_train = get_training_dataset()\nds_valid = get_validation_dataset()\nds_test = get_test_dataset()\n\nprint(\"Training:\", ds_train)\nprint (\"Validation:\", ds_valid)\nprint(\"Test:\", ds_test)","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:43:02.879336Z","iopub.execute_input":"2021-11-04T02:43:02.879890Z","iopub.status.idle":"2021-11-04T02:43:03.243034Z","shell.execute_reply.started":"2021-11-04T02:43:02.879856Z","shell.execute_reply":"2021-11-04T02:43:03.242307Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"np.set_printoptions(threshold=15, linewidth=80)\n\nprint(\"Training data shapes:\")\nfor image, label in ds_train.take(3):\n    print(image.numpy().shape, label.numpy().shape)\nprint(\"Training data label examples:\", label.numpy())","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:43:03.245655Z","iopub.execute_input":"2021-11-04T02:43:03.245909Z","iopub.status.idle":"2021-11-04T02:43:11.305801Z","shell.execute_reply.started":"2021-11-04T02:43:03.245883Z","shell.execute_reply":"2021-11-04T02:43:11.304868Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"seed = random.randint(1, 1000)\nlearning_rate = 0.0001","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:43:11.307628Z","iopub.execute_input":"2021-11-04T02:43:11.307938Z","iopub.status.idle":"2021-11-04T02:43:11.312665Z","shell.execute_reply.started":"2021-11-04T02:43:11.307899Z","shell.execute_reply":"2021-11-04T02:43:11.311807Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Define Simple Model","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n    model = Sequential()\n    model.add(Conv2D(20, kernel_size=(3, 3),\n                     activation='relu',\n                     input_shape=(IMAGE_SIZE[0],IMAGE_SIZE[1],3)))\n\n    model.add(MaxPooling2D(pool_size=(2, 2)))\n    model.add(Conv2D(40, kernel_size=(3,3), activation='relu'))\n    model.add(MaxPooling2D(pool_size=(2, 2)))\n    model.add(Conv2D(30, kernel_size=(3,3), activation='relu'))\n    model.add(Flatten())\n    model.add(Dense(100, activation='elu'))\n    model.add(Dropout(0.2))\n    model.add(Dense(50, activation='elu'))\n    model.add(Dropout(0.2))\n    model.add(Dense(len(CLASSES), activation='softmax'))\n    model.summary()\n\n# Compila o modelo\nmodel.compile(loss='sparse_categorical_crossentropy',\n              optimizer=Adam(learning_rate=learning_rate),\n              metrics=['sparse_categorical_accuracy'])","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:43:11.314131Z","iopub.execute_input":"2021-11-04T02:43:11.314831Z","iopub.status.idle":"2021-11-04T02:43:12.821672Z","shell.execute_reply.started":"2021-11-04T02:43:11.314788Z","shell.execute_reply":"2021-11-04T02:43:12.820865Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Training","metadata":{"execution":{"iopub.status.busy":"2021-10-30T05:26:13.062307Z","iopub.execute_input":"2021-10-30T05:26:13.063023Z","iopub.status.idle":"2021-10-30T05:26:13.067833Z","shell.execute_reply.started":"2021-10-30T05:26:13.062977Z","shell.execute_reply":"2021-10-30T05:26:13.066945Z"}}},{"cell_type":"code","source":"EPOCHS = 15\nSTEPS_PER_EPOCH = NUM_TRAINING_IMAGES // BATCH_SIZE\n\n#Salvar o melhor modelo\ncallbacks_list = [\n    keras.callbacks.ModelCheckpoint(\n        filepath='simple_model.h5',\n        monitor='val_loss', save_best_only=True, verbose=1),\n    keras.callbacks.EarlyStopping(monitor='val_loss', patience=50,verbose=1)\n]\n\nhistory = model.fit(\n        ds_train,\n        steps_per_epoch=STEPS_PER_EPOCH,\n        epochs=EPOCHS,\n        callbacks = callbacks_list,\n        validation_data=ds_valid,\n        verbose = 1)","metadata":{"execution":{"iopub.status.busy":"2021-11-04T02:43:12.823058Z","iopub.execute_input":"2021-11-04T02:43:12.823567Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"display_training_curves(\n    history.history['loss'],\n    history.history['val_loss'],\n    'loss',\n    211,\n)\ndisplay_training_curves(\n    history.history['sparse_categorical_accuracy'],\n    history.history['val_sparse_categorical_accuracy'],\n    'accuracy',\n    212,\n)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Evaluate model","metadata":{}},{"cell_type":"code","source":"from tensorflow.keras.models import load_model\n# Load the best saved model\nmodel = load_model('simple_model.h5')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"cmdataset = get_validation_dataset(ordered=True)\nimages_ds = cmdataset.map(lambda image, label: image)\nlabels_ds = cmdataset.map(lambda image, label: label).unbatch()\n\ncm_correct_labels = next(iter(labels_ds.batch(NUM_VALIDATION_IMAGES))).numpy()\ncm_probabilities = model.predict(images_ds)\ncm_predictions = np.argmax(cm_probabilities, axis=-1)\n\nlabels = range(len(CLASSES))\ncmat = confusion_matrix(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n)\ncmat = (cmat.T / cmat.sum(axis=1)).T # normalize","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"score = f1_score(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n    average='macro',\n)\nprecision = precision_score(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n    average='macro',\n)\nrecall = recall_score(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n    average='macro',\n)\naccuracy = accuracy_score(\n    cm_correct_labels,\n    cm_predictions)\ndisplay_confusion_matrix(cmat, score, precision, recall, accuracy)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Define InceptionV3 Model","metadata":{}},{"cell_type":"code","source":"with strategy.scope():\n    base_model = InceptionV3(weights=None, include_top=False, input_shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3))\n    \n    x = base_model.output\n    x = Flatten()(x)\n    predictions = Dense(len(CLASSES), activation='softmax', kernel_initializer='random_uniform')(x)\n\n#     x = base_model.output\n#     x = GlobalAveragePooling2D()(x)\n#     x = Dropout(rate = .4)(x)\n#     x = BatchNormalization()(x)\n#     x = Dense(1280, activation='relu',  kernel_initializer=glorot_uniform(seed))(x)\n#     x = Dropout(rate = .4)(x)\n#     x = BatchNormalization()(x)\n#     predictions = Dense(len(CLASSES), activation='softmax', kernel_initializer='random_uniform')(x)\n\n    model = Model(inputs=base_model.input, outputs=predictions)\n    \n#optimizer = Adam(lr=learning_rate)\noptimizer = keras.optimizers.RMSprop(lr=0.001)\nmodel.compile(optimizer=optimizer,loss='sparse_categorical_crossentropy',metrics=['sparse_categorical_accuracy'])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Training","metadata":{}},{"cell_type":"code","source":"EPOCHS = 20\nSTEPS_PER_EPOCH = NUM_TRAINING_IMAGES // BATCH_SIZE\n\n#Salvar o melhor modelo\ncallbacks_list = [\n    keras.callbacks.ModelCheckpoint(\n        filepath='inceptionv3_model.h5',\n        monitor='val_loss', save_best_only=True, verbose=1),\n    keras.callbacks.EarlyStopping(monitor='val_loss', patience=50, verbose=1)\n]\n\nhistory = model.fit(\n        ds_train,\n        steps_per_epoch=STEPS_PER_EPOCH,\n        epochs=EPOCHS,\n        callbacks = callbacks_list,\n        validation_data=ds_valid,\n        verbose = 1)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"display_training_curves(\n    history.history['loss'],\n    history.history['val_loss'],\n    'loss',\n    211,\n)\ndisplay_training_curves(\n    history.history['sparse_categorical_accuracy'],\n    history.history['val_sparse_categorical_accuracy'],\n    'accuracy',\n    212,\n)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Evaluate","metadata":{}},{"cell_type":"code","source":"# Load the best saved model\nmodel = load_model('inceptionv3_model.h5')\n\n# Generate confusion matrix data\ncmdataset = get_validation_dataset(ordered=True)\nimages_ds = cmdataset.map(lambda image, label: image)\nlabels_ds = cmdataset.map(lambda image, label: label).unbatch()\n\ncm_correct_labels = next(iter(labels_ds.batch(NUM_VALIDATION_IMAGES))).numpy()\ncm_probabilities = model.predict(images_ds)\ncm_predictions = np.argmax(cm_probabilities, axis=-1)\n\nlabels = range(len(CLASSES))\ncmat = confusion_matrix(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n)\ncmat = (cmat.T / cmat.sum(axis=1)).T # normalize","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"score = f1_score(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n    average='macro',\n)\nprecision = precision_score(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n    average='macro',\n)\nrecall = recall_score(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n    average='macro',\n)\naccuracy = accuracy_score(\n    cm_correct_labels,\n    cm_predictions)\ndisplay_confusion_matrix(cmat, score, precision, recall, accuracy)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Define InceptionV3 Model with Transfer Learning","metadata":{"id":"kSjVIWfkvQaL"}},{"cell_type":"code","source":"# Loading MobileNet without top layer\nwith strategy.scope():\n    pre_trained_weights = '../input/keras-pretrained-models/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'\n    base_model = InceptionV3(weights=pre_trained_weights, include_top=False, input_shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3))\n\n    x = base_model.output\n    x = Flatten()(x)\n    predictions = Dense(len(CLASSES), activation='softmax', kernel_initializer='random_uniform')(x)\n\n#     x = base_model.output\n#     x = GlobalAveragePooling2D()(x)\n#     x = Dropout(rate = .4)(x)\n#     x = BatchNormalization()(x)\n#     x = Dense(1280, activation='relu',  kernel_initializer=glorot_uniform(seed))(x)\n#     x = Dropout(rate = .4)(x)\n#     x = BatchNormalization()(x)\n#     predictions = Dense(len(CLASSES), activation='softmax', kernel_initializer='random_uniform')(x)\n\n    model = Model(inputs=base_model.input, outputs=predictions)\n\n    # Freezing pretrained layers\n    for layer in base_model.layers:\n        layer.trainable=False\n    \n#optimizer = Adam(lr=learning_rate)\noptimizer = keras.optimizers.RMSprop(lr=0.0005)\nmodel.compile(optimizer=optimizer,loss='sparse_categorical_crossentropy',metrics=['sparse_categorical_accuracy'])","metadata":{"id":"MROFFdCavBn0","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Training","metadata":{}},{"cell_type":"code","source":"EPOCHS = 20\nSTEPS_PER_EPOCH = NUM_TRAINING_IMAGES // BATCH_SIZE\n\n#Salvar o melhor modelo\ncallbacks_list = [\n    keras.callbacks.ModelCheckpoint(\n        filepath='inceptionv3_transfer_model.h5',\n        monitor='val_loss', save_best_only=True, verbose=1),\n    keras.callbacks.EarlyStopping(monitor='val_loss', patience=10, verbose=1)\n]\n\nhistory = model.fit(\n        ds_train,\n        steps_per_epoch=STEPS_PER_EPOCH,\n        epochs=EPOCHS,\n        callbacks = callbacks_list,\n        validation_data=ds_valid,\n        verbose = 1)","metadata":{"id":"OzmBvqTPFVo-","outputId":"88011256-19ed-4abf-820f-0999bf8475d4","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"display_training_curves(\n    history.history['loss'],\n    history.history['val_loss'],\n    'loss',\n    211,\n)\ndisplay_training_curves(\n    history.history['sparse_categorical_accuracy'],\n    history.history['val_sparse_categorical_accuracy'],\n    'accuracy',\n    212,\n)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Evaluate","metadata":{"id":"PRZ2XHnoSL4L"}},{"cell_type":"code","source":"model = load_model('inceptionv3_transfer_model.h5')\n\ncmdataset = get_validation_dataset(ordered=True)\nimages_ds = cmdataset.map(lambda image, label: image)\nlabels_ds = cmdataset.map(lambda image, label: label).unbatch()\n\ncm_correct_labels = next(iter(labels_ds.batch(NUM_VALIDATION_IMAGES))).numpy()\ncm_probabilities = model.predict(images_ds)\ncm_predictions = np.argmax(cm_probabilities, axis=-1)\n\nlabels = range(len(CLASSES))\ncmat = confusion_matrix(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n)\ncmat = (cmat.T / cmat.sum(axis=1)).T # normalize","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"score = f1_score(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n    average='macro',\n)\nprecision = precision_score(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n    average='macro',\n)\nrecall = recall_score(\n    cm_correct_labels,\n    cm_predictions,\n    labels=labels,\n    average='macro',\n)\naccuracy = accuracy_score(\n    cm_correct_labels,\n    cm_predictions)\ndisplay_confusion_matrix(cmat, score, precision, recall, accuracy)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# InceptionV3 Architecture\n![image.png](attachment:d14b5c84-29c3-495e-a0f9-86f8645e37f1.png)","metadata":{},"attachments":{"d14b5c84-29c3-495e-a0f9-86f8645e37f1.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"# Results with best model","metadata":{}},{"cell_type":"code","source":"# best model\nmodel = load_model('inceptionv3_transfer_model.h5')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dataset = get_validation_dataset()\ndataset = dataset.unbatch().batch(20)\nbatch = iter(dataset)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def batch_to_numpy_images_and_labels(data):\n    images, labels = data\n    numpy_images = images.numpy()\n    numpy_labels = labels.numpy()\n    if numpy_labels.dtype == object: # binary string in this case, these are image ID strings\n        numpy_labels = [None for _ in enumerate(numpy_images)]\n    # If no labels, only image IDs, return None for labels (this is the case for test data)\n    return numpy_images, numpy_labels\n\ndef title_from_label_and_target(label, correct_label):\n    if correct_label is None:\n        return CLASSES[label], True\n    correct = (label == correct_label)\n    return \"{} [{}{}{}]\".format(CLASSES[label], 'OK' if correct else 'NO', u\"\\u2192\" if not correct else '',\n                                CLASSES[correct_label] if not correct else ''), correct\n\ndef display_one_flower(image, title, subplot, red=False, titlesize=16):\n    plt.subplot(*subplot)\n    plt.axis('off')\n    plt.imshow(image)\n    if len(title) > 0:\n        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))\n    return (subplot[0], subplot[1], subplot[2]+1)\n\ndef display_batch_of_images(databatch, predictions=None):\n    \"\"\"This will work with:\n    display_batch_of_images(images)\n    display_batch_of_images(images, predictions)\n    display_batch_of_images((images, labels))\n    display_batch_of_images((images, labels), predictions)\n    \"\"\"\n    # data\n    images, labels = batch_to_numpy_images_and_labels(databatch)\n    if labels is None:\n        labels = [None for _ in enumerate(images)]\n        \n    # auto-squaring: this will drop data that does not fit into square or square-ish rectangle\n    rows = int(math.sqrt(len(images)))\n    cols = len(images)//rows\n        \n    # size and spacing\n    FIGSIZE = 13.0\n    SPACING = 0.1\n    subplot=(rows,cols,1)\n    if rows < cols:\n        plt.figure(figsize=(FIGSIZE,FIGSIZE/cols*rows))\n    else:\n        plt.figure(figsize=(FIGSIZE/rows*cols,FIGSIZE))\n    \n    # display\n    for i, (image, label) in enumerate(zip(images[:rows*cols], labels[:rows*cols])):\n        title = '' if label is None else CLASSES[label]\n        correct = True\n        if predictions is not None:\n            title, correct = title_from_label_and_target(predictions[i], label)\n        dynamic_titlesize = FIGSIZE*SPACING/max(rows,cols)*40+3 # magic formula tested to work from 1x1 to 10x10 images\n        subplot = display_one_flower(image, title, subplot, not correct, titlesize=dynamic_titlesize)\n    \n    #layout\n    plt.tight_layout()\n    if label is None and predictions is None:\n        plt.subplots_adjust(wspace=0, hspace=0)\n    else:\n        plt.subplots_adjust(wspace=SPACING, hspace=SPACING)\n    plt.show()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"images, labels = next(batch)\nprobabilities = model.predict(images)\npredictions = np.argmax(probabilities, axis=-1)\ndisplay_batch_of_images((images, labels), predictions)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Make prediciton","metadata":{}},{"cell_type":"code","source":"test_ds = get_test_dataset(ordered=True)\n\nprint('Computing predictions...')\ntest_images_ds = test_ds.map(lambda image, idnum: image)\nprobabilities = model.predict(test_images_ds)\npredictions = np.argmax(probabilities, axis=-1)\nprint(predictions)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print('Generating submission.csv file...')\n\n# Get image ids from test set and convert to unicode\ntest_ids_ds = test_ds.map(lambda image, idnum: idnum).unbatch()\ntest_ids = next(iter(test_ids_ds.batch(NUM_TEST_IMAGES))).numpy().astype('U')\n\n# Write the submission file\nnp.savetxt(\n    'submission.csv',\n    np.rec.fromarrays([test_ids, predictions]),\n    fmt=['%s', '%d'],\n    delimiter=',',\n    header='id,label',\n    comments='',\n)\n\n# Look at the first few predictions\n!head submission.csv","metadata":{},"execution_count":null,"outputs":[]}]}